Although UTF-16 text is converted to UTF-8 before transmission it's stored inline rather than in the dictionary.
Signed-off-by: Hans Leidekker hans@codeweavers.com --- dlls/webservices/reader.c | 12 + dlls/webservices/webservices_private.h | 1 + dlls/webservices/writer.c | 1411 +++++++++++++++++--------------- 3 files changed, 754 insertions(+), 670 deletions(-)
diff --git a/dlls/webservices/reader.c b/dlls/webservices/reader.c index 9d024a3446..a05b1edb33 100644 --- a/dlls/webservices/reader.c +++ b/dlls/webservices/reader.c @@ -788,6 +788,18 @@ WS_XML_UTF8_TEXT *alloc_utf8_text( const BYTE *data, ULONG len ) return ret; }
+WS_XML_UTF16_TEXT *alloc_utf16_text( const BYTE *data, ULONG len ) +{ + WS_XML_UTF16_TEXT *ret; + + if (!(ret = heap_alloc( sizeof(*ret) + len ))) return NULL; + ret->text.textType = WS_XML_TEXT_TYPE_UTF16; + ret->byteCount = len; + ret->bytes = len ? (BYTE *)(ret + 1) : NULL; + if (data) memcpy( ret->bytes, data, len ); + return ret; +} + WS_XML_BASE64_TEXT *alloc_base64_text( const BYTE *data, ULONG len ) { WS_XML_BASE64_TEXT *ret; diff --git a/dlls/webservices/webservices_private.h b/dlls/webservices/webservices_private.h index f8cc6d9cfe..e477e0fc3f 100644 --- a/dlls/webservices/webservices_private.h +++ b/dlls/webservices/webservices_private.h @@ -68,6 +68,7 @@ HRESULT read_header( WS_XML_READER *, const WS_XML_STRING *, const WS_XML_STRING HRESULT create_header_buffer( WS_XML_READER *, WS_HEAP *, WS_XML_BUFFER ** ) DECLSPEC_HIDDEN;
WS_XML_UTF8_TEXT *alloc_utf8_text( const BYTE *, ULONG ) DECLSPEC_HIDDEN; +WS_XML_UTF16_TEXT *alloc_utf16_text( const BYTE *, ULONG ) DECLSPEC_HIDDEN; WS_XML_BASE64_TEXT *alloc_base64_text( const BYTE *, ULONG ) DECLSPEC_HIDDEN; WS_XML_BOOL_TEXT *alloc_bool_text( BOOL ) DECLSPEC_HIDDEN; WS_XML_INT32_TEXT *alloc_int32_text( INT32 ) DECLSPEC_HIDDEN; diff --git a/dlls/webservices/writer.c b/dlls/webservices/writer.c index 4b2466390c..be2994af83 100644 --- a/dlls/webservices/writer.c +++ b/dlls/webservices/writer.c @@ -667,6 +667,15 @@ static enum record_type get_attr_text_record_type( const WS_XML_TEXT *text, BOOL if (text_utf8->value.length <= MAX_UINT16) return RECORD_CHARS16_TEXT; return RECORD_CHARS32_TEXT; } + case WS_XML_TEXT_TYPE_UTF16: + { + const WS_XML_UTF16_TEXT *text_utf16 = (const WS_XML_UTF16_TEXT *)text; + int len = text_utf16->byteCount / sizeof(WCHAR); + int len_utf8 = WideCharToMultiByte( CP_UTF8, 0, (const WCHAR *)text_utf16->bytes, len, NULL, 0, NULL, NULL ); + if (len_utf8 <= MAX_UINT8) return RECORD_CHARS8_TEXT; + if (len_utf8 <= MAX_UINT16) return RECORD_CHARS16_TEXT; + return RECORD_CHARS32_TEXT; + } case WS_XML_TEXT_TYPE_BASE64: { const WS_XML_BASE64_TEXT *text_base64 = (const WS_XML_BASE64_TEXT *)text; @@ -784,153 +793,566 @@ static BOOL get_string_id( struct writer *writer, const WS_XML_STRING *str, ULON return FALSE; }
-static HRESULT write_attribute_value_bin( struct writer *writer, const WS_XML_TEXT *text ) +static ULONG format_bool( const BOOL *ptr, unsigned char *buf ) { - enum record_type type; - BOOL use_dict = FALSE; - HRESULT hr; - ULONG id; - - if (text && text->textType == WS_XML_TEXT_TYPE_UTF8) + static const unsigned char bool_true[] = {'t','r','u','e'}, bool_false[] = {'f','a','l','s','e'}; + if (*ptr) { - const WS_XML_UTF8_TEXT *utf8 = (const WS_XML_UTF8_TEXT *)text; - use_dict = get_string_id( writer, &utf8->value, &id ); + memcpy( buf, bool_true, sizeof(bool_true) ); + return sizeof(bool_true); } - type = get_attr_text_record_type( text, use_dict ); + memcpy( buf, bool_false, sizeof(bool_false) ); + return sizeof(bool_false); +}
- if ((hr = write_grow_buffer( writer, 1 )) != S_OK) return hr; - write_char( writer, type ); +static ULONG format_int32( const INT32 *ptr, unsigned char *buf ) +{ + return wsprintfA( (char *)buf, "%d", *ptr ); +}
- switch (type) +static ULONG format_int64( const INT64 *ptr, unsigned char *buf ) +{ + return wsprintfA( (char *)buf, "%I64d", *ptr ); +} + +static ULONG format_uint64( const UINT64 *ptr, unsigned char *buf ) +{ + return wsprintfA( (char *)buf, "%I64u", *ptr ); +} + +static ULONG format_double( const double *ptr, unsigned char *buf ) +{ +#ifdef HAVE_POWL + static const long double precision = 0.0000000000000001; + unsigned char *p = buf; + long double val = *ptr; + int neg, mag, mag2, use_exp; + + if (isnan( val )) { - case RECORD_CHARS8_TEXT: + memcpy( buf, "NaN", 3 ); + return 3; + } + if (isinf( val )) { - WS_XML_UTF8_TEXT *text_utf8 = (WS_XML_UTF8_TEXT *)text; - if (!text_utf8) + if (val < 0) { - if ((hr = write_grow_buffer( writer, 1 )) != S_OK) return hr; - write_char( writer, 0 ); - return S_OK; + memcpy( buf, "-INF", 4 ); + return 4; } - if ((hr = write_grow_buffer( writer, 1 + text_utf8->value.length )) != S_OK) return hr; - write_char( writer, text_utf8->value.length ); - write_bytes( writer, text_utf8->value.bytes, text_utf8->value.length ); - return S_OK; + memcpy( buf, "INF", 3 ); + return 3; } - case RECORD_CHARS16_TEXT: + if (val == 0.0) { - WS_XML_UTF8_TEXT *text_utf8 = (WS_XML_UTF8_TEXT *)text; - UINT16 len = text_utf8->value.length; - if ((hr = write_grow_buffer( writer, sizeof(len) + len )) != S_OK) return hr; - write_bytes( writer, (const BYTE *)&len, sizeof(len) ); - write_bytes( writer, text_utf8->value.bytes, len ); - return S_OK; + *p = '0'; + return 1; } - case RECORD_BYTES8_TEXT: + + if ((neg = val < 0)) { - WS_XML_BASE64_TEXT *text_base64 = (WS_XML_BASE64_TEXT *)text; - if ((hr = write_grow_buffer( writer, 1 + text_base64->length )) != S_OK) return hr; - write_char( writer, text_base64->length ); - write_bytes( writer, text_base64->bytes, text_base64->length ); - return S_OK; + *p++ = '-'; + val = -val; } - case RECORD_BYTES16_TEXT: + + mag = log10l( val ); + use_exp = (mag >= 15 || (neg && mag >= 1) || mag <= -1); + if (use_exp) { - WS_XML_BASE64_TEXT *text_base64 = (WS_XML_BASE64_TEXT *)text; - UINT16 len = text_base64->length; - if ((hr = write_grow_buffer( writer, sizeof(len) + len )) != S_OK) return hr; - write_bytes( writer, (const BYTE *)&len, sizeof(len) ); - write_bytes( writer, text_base64->bytes, len ); - return S_OK; + if (mag < 0) mag -= 1; + val = val / powl( 10.0, mag ); + mag2 = mag; + mag = 0; } - case RECORD_ZERO_TEXT: - case RECORD_ONE_TEXT: - case RECORD_FALSE_TEXT: - case RECORD_TRUE_TEXT: - return S_OK; + else if (mag < 1) mag = 0;
- case RECORD_INT8_TEXT: + while (val > precision || mag >= 0) { - INT8 val = get_text_value_int( text ); - if ((hr = write_grow_buffer( writer, sizeof(val) )) != S_OK) return hr; - write_char( writer, val ); - return S_OK; + long double weight = powl( 10.0, mag ); + if (weight > 0 && !isinf( weight )) + { + int digit = floorl( val / weight ); + val -= digit * weight; + *(p++) = '0' + digit; + } + if (!mag && val > precision) *(p++) = '.'; + mag--; } - case RECORD_INT16_TEXT: + + if (use_exp) { - INT16 val = get_text_value_int( text ); - if ((hr = write_grow_buffer( writer, sizeof(val) )) != S_OK) return hr; - write_bytes( writer, (const BYTE *)&val, sizeof(val) ); - return S_OK; + int i, j; + *(p++) = 'E'; + if (mag2 > 0) *(p++) = '+'; + else + { + *(p++) = '-'; + mag2 = -mag2; + } + mag = 0; + while (mag2 > 0) + { + *(p++) = '0' + mag2 % 10; + mag2 /= 10; + mag++; + } + for (i = -mag, j = -1; i < j; i++, j--) + { + p[i] ^= p[j]; + p[j] ^= p[i]; + p[i] ^= p[j]; + } } - case RECORD_INT32_TEXT: + + return p - buf; +#else + FIXME( "powl not found at build time\n" ); + return 0; +#endif +} + +static inline int year_size( int year ) +{ + return leap_year( year ) ? 366 : 365; +} + +#define TZ_OFFSET 8 +static ULONG format_datetime( const WS_DATETIME *ptr, unsigned char *buf ) +{ + static const char fmt[] = "%04u-%02u-%02uT%02u:%02u:%02u"; + int day, hour, min, sec, sec_frac, month = 0, year = 1, tz_hour; + unsigned __int64 ticks, day_ticks; + ULONG len; + + if (ptr->format == WS_DATETIME_FORMAT_LOCAL && + ptr->ticks >= TICKS_1601_01_01 + TZ_OFFSET * TICKS_PER_HOUR) { - INT32 val = get_text_value_int( text ); - if ((hr = write_grow_buffer( writer, sizeof(val) )) != S_OK) return hr; - write_bytes( writer, (const BYTE *)&val, sizeof(val) ); - return S_OK; + ticks = ptr->ticks - TZ_OFFSET * TICKS_PER_HOUR; + tz_hour = TZ_OFFSET; } - case RECORD_INT64_TEXT: + else { - INT64 val = get_text_value_int( text ); - if ((hr = write_grow_buffer( writer, sizeof(val) )) != S_OK) return hr; - write_bytes( writer, (const BYTE *)&val, sizeof(val) ); - return S_OK; + ticks = ptr->ticks; + tz_hour = 0; } - case RECORD_UINT64_TEXT: + day = ticks / TICKS_PER_DAY; + day_ticks = ticks % TICKS_PER_DAY; + hour = day_ticks / TICKS_PER_HOUR; + min = (day_ticks % TICKS_PER_HOUR) / TICKS_PER_MIN; + sec = (day_ticks % TICKS_PER_MIN) / TICKS_PER_SEC; + sec_frac = day_ticks % TICKS_PER_SEC; + + while (day >= year_size( year )) { - WS_XML_UINT64_TEXT *text_uint64 = (WS_XML_UINT64_TEXT *)text; - if ((hr = write_grow_buffer( writer, sizeof(text_uint64->value) )) != S_OK) return hr; - write_bytes( writer, (const BYTE *)&text_uint64->value, sizeof(text_uint64->value) ); - return S_OK; + day -= year_size( year ); + year++; } - case RECORD_DOUBLE_TEXT: + while (day >= month_days[leap_year( year )][month]) { - WS_XML_DOUBLE_TEXT *text_double = (WS_XML_DOUBLE_TEXT *)text; - if ((hr = write_grow_buffer( writer, sizeof(text_double->value) )) != S_OK) return hr; - write_bytes( writer, (const BYTE *)&text_double->value, sizeof(text_double->value) ); - return S_OK; + day -= month_days[leap_year( year )][month]; + month++; } - case RECORD_GUID_TEXT: + + len = sprintf( (char *)buf, fmt, year, month + 1, day + 1, hour, min, sec ); + if (sec_frac) { - WS_XML_GUID_TEXT *text_guid = (WS_XML_GUID_TEXT *)text; - if ((hr = write_grow_buffer( writer, sizeof(text_guid->value) )) != S_OK) return hr; - write_bytes( writer, (const BYTE *)&text_guid->value, sizeof(text_guid->value) ); - return S_OK; + static const char fmt_frac[] = ".%07u"; + len += sprintf( (char *)buf + len, fmt_frac, sec_frac ); + while (buf[len - 1] == '0') len--; } - case RECORD_UNIQUE_ID_TEXT: + if (ptr->format == WS_DATETIME_FORMAT_UTC) { - WS_XML_UNIQUE_ID_TEXT *text_unique_id = (WS_XML_UNIQUE_ID_TEXT *)text; - if ((hr = write_grow_buffer( writer, sizeof(text_unique_id->value) )) != S_OK) return hr; - write_bytes( writer, (const BYTE *)&text_unique_id->value, sizeof(text_unique_id->value) ); - return S_OK; + buf[len++] = 'Z'; } - case RECORD_DATETIME_TEXT: + else if (ptr->format == WS_DATETIME_FORMAT_LOCAL) { - WS_XML_DATETIME_TEXT *text_datetime = (WS_XML_DATETIME_TEXT *)text; - UINT64 val = text_datetime->value.ticks; + static const char fmt_tz[] = "%c%02u:00"; + len += sprintf( (char *)buf + len, fmt_tz, tz_hour ? '-' : '+', tz_hour ); + }
- assert( val <= TICKS_MAX ); - if (text_datetime->value.format == WS_DATETIME_FORMAT_UTC) val |= (UINT64)1 << 62; - else if (text_datetime->value.format == WS_DATETIME_FORMAT_LOCAL) val |= (UINT64)1 << 63; + return len; +}
- if ((hr = write_grow_buffer( writer, sizeof(val) )) != S_OK) return hr; - write_bytes( writer, (const BYTE *)&val, sizeof(val) ); - return S_OK; - } - default: - FIXME( "unhandled record type %02x\n", type ); - return E_NOTIMPL; - } +static ULONG format_guid( const GUID *ptr, unsigned char *buf ) +{ + static const char fmt[] = "%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x"; + return sprintf( (char *)buf, fmt, ptr->Data1, ptr->Data2, ptr->Data3, + ptr->Data4[0], ptr->Data4[1], ptr->Data4[2], ptr->Data4[3], + ptr->Data4[4], ptr->Data4[5], ptr->Data4[6], ptr->Data4[7] ); }
-static enum record_type get_attr_record_type( const WS_XML_ATTRIBUTE *attr, BOOL use_dict ) +static ULONG format_urn( const GUID *ptr, unsigned char *buf ) { - if (!attr->prefix || !attr->prefix->length) - { - if (use_dict) return RECORD_SHORT_DICTIONARY_ATTRIBUTE; - return RECORD_SHORT_ATTRIBUTE; - } + static const char fmt[] = "urn:uuid:%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x"; + return sprintf( (char *)buf, fmt, ptr->Data1, ptr->Data2, ptr->Data3, + ptr->Data4[0], ptr->Data4[1], ptr->Data4[2], ptr->Data4[3], + ptr->Data4[4], ptr->Data4[5], ptr->Data4[6], ptr->Data4[7] ); +} + +static ULONG format_qname( const WS_XML_STRING *prefix, const WS_XML_STRING *localname, unsigned char *buf ) +{ + ULONG len = 0; + if (prefix && prefix->length) + { + memcpy( buf, prefix->bytes, prefix->length ); + len += prefix->length; + buf[len++] = ':'; + } + memcpy( buf + len, localname->bytes, localname->length ); + return len + localname->length; +} + +static ULONG encode_base64( const unsigned char *bin, ULONG len, unsigned char *buf ) +{ + static const char base64[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; + ULONG i = 0, x; + + while (len > 0) + { + buf[i++] = base64[(bin[0] & 0xfc) >> 2]; + x = (bin[0] & 3) << 4; + if (len == 1) + { + buf[i++] = base64[x]; + buf[i++] = '='; + buf[i++] = '='; + break; + } + buf[i++] = base64[x | ((bin[1] & 0xf0) >> 4)]; + x = (bin[1] & 0x0f) << 2; + if (len == 2) + { + buf[i++] = base64[x]; + buf[i++] = '='; + break; + } + buf[i++] = base64[x | ((bin[2] & 0xc0) >> 6)]; + buf[i++] = base64[bin[2] & 0x3f]; + bin += 3; + len -= 3; + } + return i; +} + +static HRESULT text_to_utf8text( const WS_XML_TEXT *text, const WS_XML_UTF8_TEXT *old, ULONG *offset, + WS_XML_UTF8_TEXT **ret ) +{ + ULONG len_old = old ? old->value.length : 0; + if (offset) *offset = len_old; + + switch (text->textType) + { + case WS_XML_TEXT_TYPE_UTF8: + { + const WS_XML_UTF8_TEXT *src = (const WS_XML_UTF8_TEXT *)text; + + if (!(*ret = alloc_utf8_text( NULL, len_old + src->value.length ))) return E_OUTOFMEMORY; + if (old) memcpy( (*ret)->value.bytes, old->value.bytes, len_old ); + memcpy( (*ret)->value.bytes + len_old, src->value.bytes, src->value.length ); + return S_OK; + } + case WS_XML_TEXT_TYPE_UTF16: + { + const WS_XML_UTF16_TEXT *src = (const WS_XML_UTF16_TEXT *)text; + const WCHAR *str = (const WCHAR *)src->bytes; + ULONG len = src->byteCount / sizeof(WCHAR), len_utf8; + + if (src->byteCount % sizeof(WCHAR)) return E_INVALIDARG; + len_utf8 = WideCharToMultiByte( CP_UTF8, 0, str, len, NULL, 0, NULL, NULL ); + if (!(*ret = alloc_utf8_text( NULL, len_old + len_utf8 ))) return E_OUTOFMEMORY; + if (old) memcpy( (*ret)->value.bytes, old->value.bytes, len_old ); + WideCharToMultiByte( CP_UTF8, 0, str, len, (char *)(*ret)->value.bytes + len_old, len_utf8, NULL, NULL ); + return S_OK; + } + case WS_XML_TEXT_TYPE_BASE64: + { + const WS_XML_BASE64_TEXT *base64 = (const WS_XML_BASE64_TEXT *)text; + ULONG len = ((4 * base64->length / 3) + 3) & ~3; + + if (!(*ret = alloc_utf8_text( NULL, len_old + len ))) return E_OUTOFMEMORY; + if (old) memcpy( (*ret)->value.bytes, old->value.bytes, len_old ); + (*ret)->value.length = encode_base64( base64->bytes, base64->length, (*ret)->value.bytes + len_old ) + len_old; + return S_OK; + } + case WS_XML_TEXT_TYPE_BOOL: + { + const WS_XML_BOOL_TEXT *bool_text = (const WS_XML_BOOL_TEXT *)text; + + if (!(*ret = alloc_utf8_text( NULL, len_old + 5 ))) return E_OUTOFMEMORY; + if (old) memcpy( (*ret)->value.bytes, old->value.bytes, len_old ); + (*ret)->value.length = format_bool( &bool_text->value, (*ret)->value.bytes + len_old ) + len_old; + return S_OK; + } + case WS_XML_TEXT_TYPE_INT32: + { + const WS_XML_INT32_TEXT *int32_text = (const WS_XML_INT32_TEXT *)text; + unsigned char buf[12]; /* "-2147483648" */ + ULONG len = format_int32( &int32_text->value, buf ); + + if (!(*ret = alloc_utf8_text( NULL, len_old + len ))) return E_OUTOFMEMORY; + if (old) memcpy( (*ret)->value.bytes, old->value.bytes, len_old ); + memcpy( (*ret)->value.bytes + len_old, buf, len ); + return S_OK; + } + case WS_XML_TEXT_TYPE_INT64: + { + const WS_XML_INT64_TEXT *int64_text = (const WS_XML_INT64_TEXT *)text; + unsigned char buf[21]; /* "-9223372036854775808" */ + ULONG len = format_int64( &int64_text->value, buf ); + + if (!(*ret = alloc_utf8_text( NULL, len_old + len ))) return E_OUTOFMEMORY; + if (old) memcpy( (*ret)->value.bytes, old->value.bytes, len_old ); + memcpy( (*ret)->value.bytes + len_old, buf, len ); + return S_OK; + } + case WS_XML_TEXT_TYPE_UINT64: + { + const WS_XML_UINT64_TEXT *uint64_text = (const WS_XML_UINT64_TEXT *)text; + unsigned char buf[21]; /* "18446744073709551615" */ + ULONG len = format_uint64( &uint64_text->value, buf ); + + if (!(*ret = alloc_utf8_text( NULL, len_old + len ))) return E_OUTOFMEMORY; + if (old) memcpy( (*ret)->value.bytes, old->value.bytes, len_old ); + memcpy( (*ret)->value.bytes + len_old, buf, len ); + return S_OK; + } + case WS_XML_TEXT_TYPE_DOUBLE: + { + const WS_XML_DOUBLE_TEXT *double_text = (const WS_XML_DOUBLE_TEXT *)text; + unsigned char buf[32]; /* "-1.1111111111111111E-308", oversized to address Valgrind limitations */ + unsigned short fpword; + ULONG len; + + if (!set_fpword( 0x37f, &fpword )) return E_NOTIMPL; + len = format_double( &double_text->value, buf ); + restore_fpword( fpword ); + if (!len) return E_NOTIMPL; + + if (!(*ret = alloc_utf8_text( NULL, len_old + len ))) return E_OUTOFMEMORY; + if (old) memcpy( (*ret)->value.bytes, old->value.bytes, len_old ); + memcpy( (*ret)->value.bytes + len_old, buf, len ); + return S_OK; + } + case WS_XML_TEXT_TYPE_GUID: + { + const WS_XML_GUID_TEXT *id = (const WS_XML_GUID_TEXT *)text; + + if (!(*ret = alloc_utf8_text( NULL, len_old + 37 ))) return E_OUTOFMEMORY; + if (old) memcpy( (*ret)->value.bytes, old->value.bytes, len_old ); + (*ret)->value.length = format_guid( &id->value, (*ret)->value.bytes + len_old ) + len_old; + return S_OK; + } + case WS_XML_TEXT_TYPE_UNIQUE_ID: + { + const WS_XML_UNIQUE_ID_TEXT *id = (const WS_XML_UNIQUE_ID_TEXT *)text; + + if (!(*ret = alloc_utf8_text( NULL, len_old + 46 ))) return E_OUTOFMEMORY; + if (old) memcpy( (*ret)->value.bytes, old->value.bytes, len_old ); + (*ret)->value.length = format_urn( &id->value, (*ret)->value.bytes + len_old ) + len_old; + return S_OK; + } + case WS_XML_TEXT_TYPE_DATETIME: + { + const WS_XML_DATETIME_TEXT *dt = (const WS_XML_DATETIME_TEXT *)text; + + if (!(*ret = alloc_utf8_text( NULL, len_old + 34 ))) return E_OUTOFMEMORY; + if (old) memcpy( (*ret)->value.bytes, old->value.bytes, len_old ); + (*ret)->value.length = format_datetime( &dt->value, (*ret)->value.bytes + len_old ) + len_old; + return S_OK; + } + case WS_XML_TEXT_TYPE_QNAME: + { + const WS_XML_QNAME_TEXT *qn = (const WS_XML_QNAME_TEXT *)text; + ULONG len = qn->localName->length; + + if (qn->prefix && qn->prefix->length) len += qn->prefix->length + 1; + if (!(*ret = alloc_utf8_text( NULL, len_old + len ))) return E_OUTOFMEMORY; + if (old) memcpy( (*ret)->value.bytes, old->value.bytes, len_old ); + (*ret)->value.length = format_qname( qn->prefix, qn->localName, (*ret)->value.bytes + len_old ) + len_old; + return S_OK; + } + default: + FIXME( "unhandled text type %u\n", text->textType ); + return E_NOTIMPL; + } +} + +static HRESULT write_attribute_value_bin( struct writer *writer, const WS_XML_TEXT *text ) +{ + enum record_type type; + BOOL use_dict = FALSE; + HRESULT hr; + ULONG id; + + if (text && text->textType == WS_XML_TEXT_TYPE_UTF8) + { + const WS_XML_UTF8_TEXT *utf8 = (const WS_XML_UTF8_TEXT *)text; + use_dict = get_string_id( writer, &utf8->value, &id ); + } + type = get_attr_text_record_type( text, use_dict ); + + if ((hr = write_grow_buffer( writer, 1 )) != S_OK) return hr; + write_char( writer, type ); + + switch (type) + { + case RECORD_CHARS8_TEXT: + { + const WS_XML_UTF8_TEXT *text_utf8; + WS_XML_UTF8_TEXT *new = NULL; + UINT8 len; + + if (!text) + { + if ((hr = write_grow_buffer( writer, 1 )) != S_OK) return hr; + write_char( writer, 0 ); + return S_OK; + } + if (text->textType == WS_XML_TEXT_TYPE_UTF8) text_utf8 = (const WS_XML_UTF8_TEXT *)text; + else + { + if ((hr = text_to_utf8text( text, NULL, NULL, &new )) != S_OK) return hr; + text_utf8 = new; + } + len = text_utf8->value.length; + if ((hr = write_grow_buffer( writer, sizeof(len) + len )) != S_OK) + { + heap_free( new ); + return hr; + } + write_char( writer, len ); + write_bytes( writer, text_utf8->value.bytes, len ); + heap_free( new ); + return S_OK; + } + case RECORD_CHARS16_TEXT: + { + const WS_XML_UTF8_TEXT *text_utf8; + WS_XML_UTF8_TEXT *new = NULL; + UINT16 len; + + if (text->textType == WS_XML_TEXT_TYPE_UTF8) text_utf8 = (const WS_XML_UTF8_TEXT *)text; + else + { + if ((hr = text_to_utf8text( text, NULL, NULL, &new )) != S_OK) return hr; + text_utf8 = new; + } + len = text_utf8->value.length; + if ((hr = write_grow_buffer( writer, sizeof(len) + len )) != S_OK) + { + heap_free( new ); + return hr; + } + write_bytes( writer, (const BYTE *)&len, sizeof(len) ); + write_bytes( writer, text_utf8->value.bytes, len ); + heap_free( new ); + return S_OK; + } + case RECORD_BYTES8_TEXT: + { + WS_XML_BASE64_TEXT *text_base64 = (WS_XML_BASE64_TEXT *)text; + if ((hr = write_grow_buffer( writer, 1 + text_base64->length )) != S_OK) return hr; + write_char( writer, text_base64->length ); + write_bytes( writer, text_base64->bytes, text_base64->length ); + return S_OK; + } + case RECORD_BYTES16_TEXT: + { + WS_XML_BASE64_TEXT *text_base64 = (WS_XML_BASE64_TEXT *)text; + UINT16 len = text_base64->length; + if ((hr = write_grow_buffer( writer, sizeof(len) + len )) != S_OK) return hr; + write_bytes( writer, (const BYTE *)&len, sizeof(len) ); + write_bytes( writer, text_base64->bytes, len ); + return S_OK; + } + case RECORD_ZERO_TEXT: + case RECORD_ONE_TEXT: + case RECORD_FALSE_TEXT: + case RECORD_TRUE_TEXT: + return S_OK; + + case RECORD_INT8_TEXT: + { + INT8 val = get_text_value_int( text ); + if ((hr = write_grow_buffer( writer, sizeof(val) )) != S_OK) return hr; + write_char( writer, val ); + return S_OK; + } + case RECORD_INT16_TEXT: + { + INT16 val = get_text_value_int( text ); + if ((hr = write_grow_buffer( writer, sizeof(val) )) != S_OK) return hr; + write_bytes( writer, (const BYTE *)&val, sizeof(val) ); + return S_OK; + } + case RECORD_INT32_TEXT: + { + INT32 val = get_text_value_int( text ); + if ((hr = write_grow_buffer( writer, sizeof(val) )) != S_OK) return hr; + write_bytes( writer, (const BYTE *)&val, sizeof(val) ); + return S_OK; + } + case RECORD_INT64_TEXT: + { + INT64 val = get_text_value_int( text ); + if ((hr = write_grow_buffer( writer, sizeof(val) )) != S_OK) return hr; + write_bytes( writer, (const BYTE *)&val, sizeof(val) ); + return S_OK; + } + case RECORD_UINT64_TEXT: + { + WS_XML_UINT64_TEXT *text_uint64 = (WS_XML_UINT64_TEXT *)text; + if ((hr = write_grow_buffer( writer, sizeof(text_uint64->value) )) != S_OK) return hr; + write_bytes( writer, (const BYTE *)&text_uint64->value, sizeof(text_uint64->value) ); + return S_OK; + } + case RECORD_DOUBLE_TEXT: + { + WS_XML_DOUBLE_TEXT *text_double = (WS_XML_DOUBLE_TEXT *)text; + if ((hr = write_grow_buffer( writer, sizeof(text_double->value) )) != S_OK) return hr; + write_bytes( writer, (const BYTE *)&text_double->value, sizeof(text_double->value) ); + return S_OK; + } + case RECORD_GUID_TEXT: + { + WS_XML_GUID_TEXT *text_guid = (WS_XML_GUID_TEXT *)text; + if ((hr = write_grow_buffer( writer, sizeof(text_guid->value) )) != S_OK) return hr; + write_bytes( writer, (const BYTE *)&text_guid->value, sizeof(text_guid->value) ); + return S_OK; + } + case RECORD_UNIQUE_ID_TEXT: + { + WS_XML_UNIQUE_ID_TEXT *text_unique_id = (WS_XML_UNIQUE_ID_TEXT *)text; + if ((hr = write_grow_buffer( writer, sizeof(text_unique_id->value) )) != S_OK) return hr; + write_bytes( writer, (const BYTE *)&text_unique_id->value, sizeof(text_unique_id->value) ); + return S_OK; + } + case RECORD_DATETIME_TEXT: + { + WS_XML_DATETIME_TEXT *text_datetime = (WS_XML_DATETIME_TEXT *)text; + UINT64 val = text_datetime->value.ticks; + + assert( val <= TICKS_MAX ); + if (text_datetime->value.format == WS_DATETIME_FORMAT_UTC) val |= (UINT64)1 << 62; + else if (text_datetime->value.format == WS_DATETIME_FORMAT_LOCAL) val |= (UINT64)1 << 63; + + if ((hr = write_grow_buffer( writer, sizeof(val) )) != S_OK) return hr; + write_bytes( writer, (const BYTE *)&val, sizeof(val) ); + return S_OK; + } + default: + FIXME( "unhandled record type %02x\n", type ); + return E_NOTIMPL; + } +} + +static enum record_type get_attr_record_type( const WS_XML_ATTRIBUTE *attr, BOOL use_dict ) +{ + if (!attr->prefix || !attr->prefix->length) + { + if (use_dict) return RECORD_SHORT_DICTIONARY_ATTRIBUTE; + return RECORD_SHORT_ATTRIBUTE; + } if (attr->prefix->length == 1 && attr->prefix->bytes[0] >= 'a' && attr->prefix->bytes[0] <= 'z') { if (use_dict) return RECORD_PREFIX_DICTIONARY_ATTRIBUTE_A + attr->prefix->bytes[0] - 'a'; @@ -1584,236 +2006,15 @@ static HRESULT write_add_attribute( struct writer *writer, const WS_XML_STRING * /************************************************************************** * WsWriteStartAttribute [webservices.@] */ -HRESULT WINAPI WsWriteStartAttribute( WS_XML_WRITER *handle, const WS_XML_STRING *prefix, - const WS_XML_STRING *localname, const WS_XML_STRING *ns, - BOOL single, WS_ERROR *error ) -{ - struct writer *writer = (struct writer *)handle; - HRESULT hr; - - TRACE( "%p %s %s %s %d %p\n", handle, debugstr_xmlstr(prefix), debugstr_xmlstr(localname), - debugstr_xmlstr(ns), single, error ); - if (error) FIXME( "ignoring error parameter\n" ); - - if (!writer || !localname || !ns) return E_INVALIDARG; - - EnterCriticalSection( &writer->cs ); - - if (writer->magic != WRITER_MAGIC) - { - LeaveCriticalSection( &writer->cs ); - return E_INVALIDARG; - } - - if (writer->state != WRITER_STATE_STARTELEMENT) - { - LeaveCriticalSection( &writer->cs ); - return WS_E_INVALID_OPERATION; - } - - if ((hr = write_add_attribute( writer, prefix, localname, ns, single )) == S_OK) - writer->state = WRITER_STATE_STARTATTRIBUTE; - - LeaveCriticalSection( &writer->cs ); - return hr; -} - -/* flush current start element if necessary */ -static HRESULT write_flush( struct writer *writer ) -{ - if (writer->state == WRITER_STATE_STARTELEMENT) - { - HRESULT hr; - if ((hr = set_namespaces( writer )) != S_OK) return hr; - if ((hr = write_startelement( writer )) != S_OK) return hr; - if ((hr = write_endstartelement( writer )) != S_OK) return hr; - writer->state = WRITER_STATE_ENDSTARTELEMENT; - } - return S_OK; -} - -static HRESULT write_add_cdata_node( struct writer *writer ) -{ - struct node *node, *parent; - if (!(parent = find_parent( writer ))) return WS_E_INVALID_FORMAT; - if (!(node = alloc_node( WS_XML_NODE_TYPE_CDATA ))) return E_OUTOFMEMORY; - write_insert_node( writer, parent, node ); - return S_OK; -} - -static HRESULT write_add_endcdata_node( struct writer *writer ) -{ - struct node *node; - if (!(node = alloc_node( WS_XML_NODE_TYPE_END_CDATA ))) return E_OUTOFMEMORY; - node->parent = writer->current; - list_add_tail( &node->parent->children, &node->entry ); - return S_OK; -} - -static HRESULT write_cdata( struct writer *writer ) -{ - HRESULT hr; - if ((hr = write_grow_buffer( writer, 9 )) != S_OK) return hr; - write_bytes( writer, (const BYTE *)"<![CDATA[", 9 ); - return S_OK; -} - -static HRESULT write_cdata_node( struct writer *writer ) -{ - HRESULT hr; - if ((hr = write_flush( writer )) != S_OK) return hr; - if ((hr = write_add_cdata_node( writer )) != S_OK) return hr; - if ((hr = write_add_endcdata_node( writer )) != S_OK) return hr; - if ((hr = write_cdata( writer )) != S_OK) return hr; - writer->state = WRITER_STATE_STARTCDATA; - return S_OK; -} - -/************************************************************************** - * WsWriteStartCData [webservices.@] - */ -HRESULT WINAPI WsWriteStartCData( WS_XML_WRITER *handle, WS_ERROR *error ) -{ - struct writer *writer = (struct writer *)handle; - HRESULT hr; - - TRACE( "%p %p\n", handle, error ); - if (error) FIXME( "ignoring error parameter\n" ); - - if (!writer) return E_INVALIDARG; - - EnterCriticalSection( &writer->cs ); - - if (writer->magic != WRITER_MAGIC) - { - LeaveCriticalSection( &writer->cs ); - return E_INVALIDARG; - } - - hr = write_cdata_node( writer ); - - LeaveCriticalSection( &writer->cs ); - return hr; -} - -static HRESULT write_endcdata( struct writer *writer ) -{ - HRESULT hr; - if ((hr = write_grow_buffer( writer, 3 )) != S_OK) return hr; - write_bytes( writer, (const BYTE *)"]]>", 3 ); - return S_OK; -} - -static HRESULT write_endcdata_node( struct writer *writer ) -{ - HRESULT hr; - if ((hr = write_endcdata( writer )) != S_OK) return hr; - writer->current = writer->current->parent; - writer->state = WRITER_STATE_ENDCDATA; - return S_OK; -} - -/************************************************************************** - * WsWriteEndCData [webservices.@] - */ -HRESULT WINAPI WsWriteEndCData( WS_XML_WRITER *handle, WS_ERROR *error ) -{ - struct writer *writer = (struct writer *)handle; - HRESULT hr; - - TRACE( "%p %p\n", handle, error ); - if (error) FIXME( "ignoring error parameter\n" ); - - if (!writer) return E_INVALIDARG; - - EnterCriticalSection( &writer->cs ); - - if (writer->magic != WRITER_MAGIC) - { - LeaveCriticalSection( &writer->cs ); - return E_INVALIDARG; - } - - if (writer->state != WRITER_STATE_TEXT) - { - LeaveCriticalSection( &writer->cs ); - return WS_E_INVALID_OPERATION; - } - - hr = write_endcdata_node( writer ); - - LeaveCriticalSection( &writer->cs ); - return hr; -} - -static HRESULT write_add_element_node( struct writer *writer, const WS_XML_STRING *prefix, - const WS_XML_STRING *localname, const WS_XML_STRING *ns ) -{ - struct node *node, *parent; - WS_XML_ELEMENT_NODE *elem; - - if (!(parent = find_parent( writer ))) return WS_E_INVALID_FORMAT; - - if (!prefix && node_type( parent ) == WS_XML_NODE_TYPE_ELEMENT) - { - elem = &parent->hdr; - if (WsXmlStringEquals( ns, elem->ns, NULL ) == S_OK) prefix = elem->prefix; - } - - if (!(node = alloc_node( WS_XML_NODE_TYPE_ELEMENT ))) return E_OUTOFMEMORY; - elem = &node->hdr; - - if (prefix && !(elem->prefix = dup_xml_string( prefix, writer->dict_do_lookup ))) - { - free_node( node ); - return E_OUTOFMEMORY; - } - if (!(elem->localName = dup_xml_string( localname, writer->dict_do_lookup ))) - { - free_node( node ); - return E_OUTOFMEMORY; - } - if (!(elem->ns = dup_xml_string( ns, writer->dict_do_lookup ))) - { - free_node( node ); - return E_OUTOFMEMORY; - } - write_insert_node( writer, parent, node ); - return S_OK; -} - -static HRESULT write_add_endelement_node( struct writer *writer, struct node *parent ) -{ - struct node *node; - if (!(node = alloc_node( WS_XML_NODE_TYPE_END_ELEMENT ))) return E_OUTOFMEMORY; - node->parent = parent; - list_add_tail( &parent->children, &node->entry ); - return S_OK; -} - -static HRESULT write_element_node( struct writer *writer, const WS_XML_STRING *prefix, - const WS_XML_STRING *localname, const WS_XML_STRING *ns ) -{ - HRESULT hr; - if ((hr = write_flush( writer )) != S_OK) return hr; - if ((hr = write_add_element_node( writer, prefix, localname, ns )) != S_OK) return hr; - if ((hr = write_add_endelement_node( writer, writer->current )) != S_OK) return hr; - writer->state = WRITER_STATE_STARTELEMENT; - return S_OK; -} - -/************************************************************************** - * WsWriteStartElement [webservices.@] - */ -HRESULT WINAPI WsWriteStartElement( WS_XML_WRITER *handle, const WS_XML_STRING *prefix, - const WS_XML_STRING *localname, const WS_XML_STRING *ns, - WS_ERROR *error ) +HRESULT WINAPI WsWriteStartAttribute( WS_XML_WRITER *handle, const WS_XML_STRING *prefix, + const WS_XML_STRING *localname, const WS_XML_STRING *ns, + BOOL single, WS_ERROR *error ) { struct writer *writer = (struct writer *)handle; HRESULT hr;
- TRACE( "%p %s %s %s %p\n", handle, debugstr_xmlstr(prefix), debugstr_xmlstr(localname), - debugstr_xmlstr(ns), error ); + TRACE( "%p %s %s %s %d %p\n", handle, debugstr_xmlstr(prefix), debugstr_xmlstr(localname), + debugstr_xmlstr(ns), single, error ); if (error) FIXME( "ignoring error parameter\n" );
if (!writer || !localname || !ns) return E_INVALIDARG; @@ -1826,394 +2027,231 @@ HRESULT WINAPI WsWriteStartElement( WS_XML_WRITER *handle, const WS_XML_STRING * return E_INVALIDARG; }
- hr = write_element_node( writer, prefix, localname, ns ); + if (writer->state != WRITER_STATE_STARTELEMENT) + { + LeaveCriticalSection( &writer->cs ); + return WS_E_INVALID_OPERATION; + } + + if ((hr = write_add_attribute( writer, prefix, localname, ns, single )) == S_OK) + writer->state = WRITER_STATE_STARTATTRIBUTE;
LeaveCriticalSection( &writer->cs ); return hr; }
-static ULONG format_bool( const BOOL *ptr, unsigned char *buf ) +/* flush current start element if necessary */ +static HRESULT write_flush( struct writer *writer ) { - static const unsigned char bool_true[] = {'t','r','u','e'}, bool_false[] = {'f','a','l','s','e'}; - if (*ptr) + if (writer->state == WRITER_STATE_STARTELEMENT) { - memcpy( buf, bool_true, sizeof(bool_true) ); - return sizeof(bool_true); + HRESULT hr; + if ((hr = set_namespaces( writer )) != S_OK) return hr; + if ((hr = write_startelement( writer )) != S_OK) return hr; + if ((hr = write_endstartelement( writer )) != S_OK) return hr; + writer->state = WRITER_STATE_ENDSTARTELEMENT; } - memcpy( buf, bool_false, sizeof(bool_false) ); - return sizeof(bool_false); + return S_OK; }
-static ULONG format_int32( const INT32 *ptr, unsigned char *buf ) +static HRESULT write_add_cdata_node( struct writer *writer ) { - return wsprintfA( (char *)buf, "%d", *ptr ); + struct node *node, *parent; + if (!(parent = find_parent( writer ))) return WS_E_INVALID_FORMAT; + if (!(node = alloc_node( WS_XML_NODE_TYPE_CDATA ))) return E_OUTOFMEMORY; + write_insert_node( writer, parent, node ); + return S_OK; }
-static ULONG format_int64( const INT64 *ptr, unsigned char *buf ) +static HRESULT write_add_endcdata_node( struct writer *writer ) { - return wsprintfA( (char *)buf, "%I64d", *ptr ); + struct node *node; + if (!(node = alloc_node( WS_XML_NODE_TYPE_END_CDATA ))) return E_OUTOFMEMORY; + node->parent = writer->current; + list_add_tail( &node->parent->children, &node->entry ); + return S_OK; }
-static ULONG format_uint64( const UINT64 *ptr, unsigned char *buf ) +static HRESULT write_cdata( struct writer *writer ) { - return wsprintfA( (char *)buf, "%I64u", *ptr ); + HRESULT hr; + if ((hr = write_grow_buffer( writer, 9 )) != S_OK) return hr; + write_bytes( writer, (const BYTE *)"<![CDATA[", 9 ); + return S_OK; }
-static ULONG format_double( const double *ptr, unsigned char *buf ) +static HRESULT write_cdata_node( struct writer *writer ) { -#ifdef HAVE_POWL - static const long double precision = 0.0000000000000001; - unsigned char *p = buf; - long double val = *ptr; - int neg, mag, mag2, use_exp; + HRESULT hr; + if ((hr = write_flush( writer )) != S_OK) return hr; + if ((hr = write_add_cdata_node( writer )) != S_OK) return hr; + if ((hr = write_add_endcdata_node( writer )) != S_OK) return hr; + if ((hr = write_cdata( writer )) != S_OK) return hr; + writer->state = WRITER_STATE_STARTCDATA; + return S_OK; +}
- if (isnan( val )) - { - memcpy( buf, "NaN", 3 ); - return 3; - } - if (isinf( val )) - { - if (val < 0) - { - memcpy( buf, "-INF", 4 ); - return 4; - } - memcpy( buf, "INF", 3 ); - return 3; - } - if (val == 0.0) - { - *p = '0'; - return 1; - } +/************************************************************************** + * WsWriteStartCData [webservices.@] + */ +HRESULT WINAPI WsWriteStartCData( WS_XML_WRITER *handle, WS_ERROR *error ) +{ + struct writer *writer = (struct writer *)handle; + HRESULT hr;
- if ((neg = val < 0)) - { - *p++ = '-'; - val = -val; - } + TRACE( "%p %p\n", handle, error ); + if (error) FIXME( "ignoring error parameter\n" );
- mag = log10l( val ); - use_exp = (mag >= 15 || (neg && mag >= 1) || mag <= -1); - if (use_exp) - { - if (mag < 0) mag -= 1; - val = val / powl( 10.0, mag ); - mag2 = mag; - mag = 0; - } - else if (mag < 1) mag = 0; + if (!writer) return E_INVALIDARG;
- while (val > precision || mag >= 0) - { - long double weight = powl( 10.0, mag ); - if (weight > 0 && !isinf( weight )) - { - int digit = floorl( val / weight ); - val -= digit * weight; - *(p++) = '0' + digit; - } - if (!mag && val > precision) *(p++) = '.'; - mag--; - } + EnterCriticalSection( &writer->cs );
- if (use_exp) + if (writer->magic != WRITER_MAGIC) { - int i, j; - *(p++) = 'E'; - if (mag2 > 0) *(p++) = '+'; - else - { - *(p++) = '-'; - mag2 = -mag2; - } - mag = 0; - while (mag2 > 0) - { - *(p++) = '0' + mag2 % 10; - mag2 /= 10; - mag++; - } - for (i = -mag, j = -1; i < j; i++, j--) - { - p[i] ^= p[j]; - p[j] ^= p[i]; - p[i] ^= p[j]; - } + LeaveCriticalSection( &writer->cs ); + return E_INVALIDARG; }
- return p - buf; -#else - FIXME( "powl not found at build time\n" ); - return 0; -#endif -} + hr = write_cdata_node( writer );
-static inline int year_size( int year ) -{ - return leap_year( year ) ? 366 : 365; + LeaveCriticalSection( &writer->cs ); + return hr; }
-#define TZ_OFFSET 8 -static ULONG format_datetime( const WS_DATETIME *ptr, unsigned char *buf ) +static HRESULT write_endcdata( struct writer *writer ) { - static const char fmt[] = "%04u-%02u-%02uT%02u:%02u:%02u"; - int day, hour, min, sec, sec_frac, month = 0, year = 1, tz_hour; - unsigned __int64 ticks, day_ticks; - ULONG len; - - if (ptr->format == WS_DATETIME_FORMAT_LOCAL && - ptr->ticks >= TICKS_1601_01_01 + TZ_OFFSET * TICKS_PER_HOUR) - { - ticks = ptr->ticks - TZ_OFFSET * TICKS_PER_HOUR; - tz_hour = TZ_OFFSET; - } - else - { - ticks = ptr->ticks; - tz_hour = 0; - } - day = ticks / TICKS_PER_DAY; - day_ticks = ticks % TICKS_PER_DAY; - hour = day_ticks / TICKS_PER_HOUR; - min = (day_ticks % TICKS_PER_HOUR) / TICKS_PER_MIN; - sec = (day_ticks % TICKS_PER_MIN) / TICKS_PER_SEC; - sec_frac = day_ticks % TICKS_PER_SEC; - - while (day >= year_size( year )) - { - day -= year_size( year ); - year++; - } - while (day >= month_days[leap_year( year )][month]) - { - day -= month_days[leap_year( year )][month]; - month++; - } - - len = sprintf( (char *)buf, fmt, year, month + 1, day + 1, hour, min, sec ); - if (sec_frac) - { - static const char fmt_frac[] = ".%07u"; - len += sprintf( (char *)buf + len, fmt_frac, sec_frac ); - while (buf[len - 1] == '0') len--; - } - if (ptr->format == WS_DATETIME_FORMAT_UTC) - { - buf[len++] = 'Z'; - } - else if (ptr->format == WS_DATETIME_FORMAT_LOCAL) - { - static const char fmt_tz[] = "%c%02u:00"; - len += sprintf( (char *)buf + len, fmt_tz, tz_hour ? '-' : '+', tz_hour ); - } - - return len; + HRESULT hr; + if ((hr = write_grow_buffer( writer, 3 )) != S_OK) return hr; + write_bytes( writer, (const BYTE *)"]]>", 3 ); + return S_OK; }
-static ULONG format_guid( const GUID *ptr, unsigned char *buf ) +static HRESULT write_endcdata_node( struct writer *writer ) { - static const char fmt[] = "%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x"; - return sprintf( (char *)buf, fmt, ptr->Data1, ptr->Data2, ptr->Data3, - ptr->Data4[0], ptr->Data4[1], ptr->Data4[2], ptr->Data4[3], - ptr->Data4[4], ptr->Data4[5], ptr->Data4[6], ptr->Data4[7] ); + HRESULT hr; + if ((hr = write_endcdata( writer )) != S_OK) return hr; + writer->current = writer->current->parent; + writer->state = WRITER_STATE_ENDCDATA; + return S_OK; }
-static ULONG format_urn( const GUID *ptr, unsigned char *buf ) +/************************************************************************** + * WsWriteEndCData [webservices.@] + */ +HRESULT WINAPI WsWriteEndCData( WS_XML_WRITER *handle, WS_ERROR *error ) { - static const char fmt[] = "urn:uuid:%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x"; - return sprintf( (char *)buf, fmt, ptr->Data1, ptr->Data2, ptr->Data3, - ptr->Data4[0], ptr->Data4[1], ptr->Data4[2], ptr->Data4[3], - ptr->Data4[4], ptr->Data4[5], ptr->Data4[6], ptr->Data4[7] ); -} + struct writer *writer = (struct writer *)handle; + HRESULT hr; + + TRACE( "%p %p\n", handle, error ); + if (error) FIXME( "ignoring error parameter\n" ); + + if (!writer) return E_INVALIDARG; + + EnterCriticalSection( &writer->cs );
-static ULONG format_qname( const WS_XML_STRING *prefix, const WS_XML_STRING *localname, unsigned char *buf ) -{ - ULONG len = 0; - if (prefix && prefix->length) + if (writer->magic != WRITER_MAGIC) { - memcpy( buf, prefix->bytes, prefix->length ); - len += prefix->length; - buf[len++] = ':'; + LeaveCriticalSection( &writer->cs ); + return E_INVALIDARG; } - memcpy( buf + len, localname->bytes, localname->length ); - return len + localname->length; -} - -static ULONG encode_base64( const unsigned char *bin, ULONG len, unsigned char *buf ) -{ - static const char base64[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; - ULONG i = 0, x;
- while (len > 0) + if (writer->state != WRITER_STATE_TEXT) { - buf[i++] = base64[(bin[0] & 0xfc) >> 2]; - x = (bin[0] & 3) << 4; - if (len == 1) - { - buf[i++] = base64[x]; - buf[i++] = '='; - buf[i++] = '='; - break; - } - buf[i++] = base64[x | ((bin[1] & 0xf0) >> 4)]; - x = (bin[1] & 0x0f) << 2; - if (len == 2) - { - buf[i++] = base64[x]; - buf[i++] = '='; - break; - } - buf[i++] = base64[x | ((bin[2] & 0xc0) >> 6)]; - buf[i++] = base64[bin[2] & 0x3f]; - bin += 3; - len -= 3; + LeaveCriticalSection( &writer->cs ); + return WS_E_INVALID_OPERATION; } - return i; + + hr = write_endcdata_node( writer ); + + LeaveCriticalSection( &writer->cs ); + return hr; }
-static HRESULT text_to_utf8text( const WS_XML_TEXT *text, const WS_XML_UTF8_TEXT *old, ULONG *offset, - WS_XML_UTF8_TEXT **ret ) +static HRESULT write_add_element_node( struct writer *writer, const WS_XML_STRING *prefix, + const WS_XML_STRING *localname, const WS_XML_STRING *ns ) { - ULONG len_old = old ? old->value.length : 0; - if (offset) *offset = len_old; + struct node *node, *parent; + WS_XML_ELEMENT_NODE *elem;
- switch (text->textType) - { - case WS_XML_TEXT_TYPE_UTF8: - { - const WS_XML_UTF8_TEXT *src = (const WS_XML_UTF8_TEXT *)text; + if (!(parent = find_parent( writer ))) return WS_E_INVALID_FORMAT;
- if (!(*ret = alloc_utf8_text( NULL, len_old + src->value.length ))) return E_OUTOFMEMORY; - if (old) memcpy( (*ret)->value.bytes, old->value.bytes, len_old ); - memcpy( (*ret)->value.bytes + len_old, src->value.bytes, src->value.length ); - return S_OK; - } - case WS_XML_TEXT_TYPE_UTF16: + if (!prefix && node_type( parent ) == WS_XML_NODE_TYPE_ELEMENT) { - const WS_XML_UTF16_TEXT *src = (const WS_XML_UTF16_TEXT *)text; - const WCHAR *str = (const WCHAR *)src->bytes; - ULONG len = src->byteCount / sizeof(WCHAR), len_utf8; - - if (src->byteCount % sizeof(WCHAR)) return E_INVALIDARG; - len_utf8 = WideCharToMultiByte( CP_UTF8, 0, str, len, NULL, 0, NULL, NULL ); - if (!(*ret = alloc_utf8_text( NULL, len_old + len_utf8 ))) return E_OUTOFMEMORY; - if (old) memcpy( (*ret)->value.bytes, old->value.bytes, len_old ); - WideCharToMultiByte( CP_UTF8, 0, str, len, (char *)(*ret)->value.bytes + len_old, len_utf8, NULL, NULL ); - return S_OK; + elem = &parent->hdr; + if (WsXmlStringEquals( ns, elem->ns, NULL ) == S_OK) prefix = elem->prefix; } - case WS_XML_TEXT_TYPE_BASE64: - { - const WS_XML_BASE64_TEXT *base64 = (const WS_XML_BASE64_TEXT *)text; - ULONG len = ((4 * base64->length / 3) + 3) & ~3;
- if (!(*ret = alloc_utf8_text( NULL, len_old + len ))) return E_OUTOFMEMORY; - if (old) memcpy( (*ret)->value.bytes, old->value.bytes, len_old ); - (*ret)->value.length = encode_base64( base64->bytes, base64->length, (*ret)->value.bytes + len_old ) + len_old; - return S_OK; - } - case WS_XML_TEXT_TYPE_BOOL: - { - const WS_XML_BOOL_TEXT *bool_text = (const WS_XML_BOOL_TEXT *)text; + if (!(node = alloc_node( WS_XML_NODE_TYPE_ELEMENT ))) return E_OUTOFMEMORY; + elem = &node->hdr;
- if (!(*ret = alloc_utf8_text( NULL, len_old + 5 ))) return E_OUTOFMEMORY; - if (old) memcpy( (*ret)->value.bytes, old->value.bytes, len_old ); - (*ret)->value.length = format_bool( &bool_text->value, (*ret)->value.bytes + len_old ) + len_old; - return S_OK; - } - case WS_XML_TEXT_TYPE_INT32: + if (prefix && !(elem->prefix = dup_xml_string( prefix, writer->dict_do_lookup ))) { - const WS_XML_INT32_TEXT *int32_text = (const WS_XML_INT32_TEXT *)text; - unsigned char buf[12]; /* "-2147483648" */ - ULONG len = format_int32( &int32_text->value, buf ); - - if (!(*ret = alloc_utf8_text( NULL, len_old + len ))) return E_OUTOFMEMORY; - if (old) memcpy( (*ret)->value.bytes, old->value.bytes, len_old ); - memcpy( (*ret)->value.bytes + len_old, buf, len ); - return S_OK; + free_node( node ); + return E_OUTOFMEMORY; } - case WS_XML_TEXT_TYPE_INT64: + if (!(elem->localName = dup_xml_string( localname, writer->dict_do_lookup ))) { - const WS_XML_INT64_TEXT *int64_text = (const WS_XML_INT64_TEXT *)text; - unsigned char buf[21]; /* "-9223372036854775808" */ - ULONG len = format_int64( &int64_text->value, buf ); - - if (!(*ret = alloc_utf8_text( NULL, len_old + len ))) return E_OUTOFMEMORY; - if (old) memcpy( (*ret)->value.bytes, old->value.bytes, len_old ); - memcpy( (*ret)->value.bytes + len_old, buf, len ); - return S_OK; + free_node( node ); + return E_OUTOFMEMORY; } - case WS_XML_TEXT_TYPE_UINT64: + if (!(elem->ns = dup_xml_string( ns, writer->dict_do_lookup ))) { - const WS_XML_UINT64_TEXT *uint64_text = (const WS_XML_UINT64_TEXT *)text; - unsigned char buf[21]; /* "18446744073709551615" */ - ULONG len = format_uint64( &uint64_text->value, buf ); - - if (!(*ret = alloc_utf8_text( NULL, len_old + len ))) return E_OUTOFMEMORY; - if (old) memcpy( (*ret)->value.bytes, old->value.bytes, len_old ); - memcpy( (*ret)->value.bytes + len_old, buf, len ); - return S_OK; + free_node( node ); + return E_OUTOFMEMORY; } - case WS_XML_TEXT_TYPE_DOUBLE: - { - const WS_XML_DOUBLE_TEXT *double_text = (const WS_XML_DOUBLE_TEXT *)text; - unsigned char buf[32]; /* "-1.1111111111111111E-308", oversized to address Valgrind limitations */ - unsigned short fpword; - ULONG len; + write_insert_node( writer, parent, node ); + return S_OK; +}
- if (!set_fpword( 0x37f, &fpword )) return E_NOTIMPL; - len = format_double( &double_text->value, buf ); - restore_fpword( fpword ); - if (!len) return E_NOTIMPL; +static HRESULT write_add_endelement_node( struct writer *writer, struct node *parent ) +{ + struct node *node; + if (!(node = alloc_node( WS_XML_NODE_TYPE_END_ELEMENT ))) return E_OUTOFMEMORY; + node->parent = parent; + list_add_tail( &parent->children, &node->entry ); + return S_OK; +}
- if (!(*ret = alloc_utf8_text( NULL, len_old + len ))) return E_OUTOFMEMORY; - if (old) memcpy( (*ret)->value.bytes, old->value.bytes, len_old ); - memcpy( (*ret)->value.bytes + len_old, buf, len ); - return S_OK; - } - case WS_XML_TEXT_TYPE_GUID: - { - const WS_XML_GUID_TEXT *id = (const WS_XML_GUID_TEXT *)text; +static HRESULT write_element_node( struct writer *writer, const WS_XML_STRING *prefix, + const WS_XML_STRING *localname, const WS_XML_STRING *ns ) +{ + HRESULT hr; + if ((hr = write_flush( writer )) != S_OK) return hr; + if ((hr = write_add_element_node( writer, prefix, localname, ns )) != S_OK) return hr; + if ((hr = write_add_endelement_node( writer, writer->current )) != S_OK) return hr; + writer->state = WRITER_STATE_STARTELEMENT; + return S_OK; +}
- if (!(*ret = alloc_utf8_text( NULL, len_old + 37 ))) return E_OUTOFMEMORY; - if (old) memcpy( (*ret)->value.bytes, old->value.bytes, len_old ); - (*ret)->value.length = format_guid( &id->value, (*ret)->value.bytes + len_old ) + len_old; - return S_OK; - } - case WS_XML_TEXT_TYPE_UNIQUE_ID: - { - const WS_XML_UNIQUE_ID_TEXT *id = (const WS_XML_UNIQUE_ID_TEXT *)text; +/************************************************************************** + * WsWriteStartElement [webservices.@] + */ +HRESULT WINAPI WsWriteStartElement( WS_XML_WRITER *handle, const WS_XML_STRING *prefix, + const WS_XML_STRING *localname, const WS_XML_STRING *ns, + WS_ERROR *error ) +{ + struct writer *writer = (struct writer *)handle; + HRESULT hr;
- if (!(*ret = alloc_utf8_text( NULL, len_old + 46 ))) return E_OUTOFMEMORY; - if (old) memcpy( (*ret)->value.bytes, old->value.bytes, len_old ); - (*ret)->value.length = format_urn( &id->value, (*ret)->value.bytes + len_old ) + len_old; - return S_OK; - } - case WS_XML_TEXT_TYPE_DATETIME: - { - const WS_XML_DATETIME_TEXT *dt = (const WS_XML_DATETIME_TEXT *)text; + TRACE( "%p %s %s %s %p\n", handle, debugstr_xmlstr(prefix), debugstr_xmlstr(localname), + debugstr_xmlstr(ns), error ); + if (error) FIXME( "ignoring error parameter\n" );
- if (!(*ret = alloc_utf8_text( NULL, len_old + 34 ))) return E_OUTOFMEMORY; - if (old) memcpy( (*ret)->value.bytes, old->value.bytes, len_old ); - (*ret)->value.length = format_datetime( &dt->value, (*ret)->value.bytes + len_old ) + len_old; - return S_OK; - } - case WS_XML_TEXT_TYPE_QNAME: - { - const WS_XML_QNAME_TEXT *qn = (const WS_XML_QNAME_TEXT *)text; - ULONG len = qn->localName->length; + if (!writer || !localname || !ns) return E_INVALIDARG;
- if (qn->prefix && qn->prefix->length) len += qn->prefix->length + 1; - if (!(*ret = alloc_utf8_text( NULL, len_old + len ))) return E_OUTOFMEMORY; - if (old) memcpy( (*ret)->value.bytes, old->value.bytes, len_old ); - (*ret)->value.length = format_qname( qn->prefix, qn->localName, (*ret)->value.bytes + len_old ) + len_old; - return S_OK; - } - default: - FIXME( "unhandled text type %u\n", text->textType ); - return E_NOTIMPL; + EnterCriticalSection( &writer->cs ); + + if (writer->magic != WRITER_MAGIC) + { + LeaveCriticalSection( &writer->cs ); + return E_INVALIDARG; } + + hr = write_element_node( writer, prefix, localname, ns ); + + LeaveCriticalSection( &writer->cs ); + return hr; }
static HRESULT text_to_text( const WS_XML_TEXT *text, const WS_XML_TEXT *old, ULONG *offset, WS_XML_TEXT **ret ) @@ -2238,16 +2276,14 @@ static HRESULT text_to_text( const WS_XML_TEXT *text, const WS_XML_TEXT *old, UL case WS_XML_TEXT_TYPE_UTF16: { const WS_XML_UTF16_TEXT *utf16 = (const WS_XML_UTF16_TEXT *)text; - const WS_XML_UTF8_TEXT *utf8_old = (const WS_XML_UTF8_TEXT *)old; - WS_XML_UTF8_TEXT *new; - const WCHAR *str = (const WCHAR *)utf16->bytes; - ULONG len = utf16->byteCount / sizeof(WCHAR), len_utf8, len_old = utf8_old ? utf8_old->value.length : 0; + const WS_XML_UTF16_TEXT *utf16_old = (const WS_XML_UTF16_TEXT *)old; + WS_XML_UTF16_TEXT *new; + ULONG len = utf16->byteCount, len_old = utf16_old ? utf16_old->byteCount : 0;
if (utf16->byteCount % sizeof(WCHAR)) return E_INVALIDARG; - len_utf8 = WideCharToMultiByte( CP_UTF8, 0, str, len, NULL, 0, NULL, NULL ); - if (!(new = alloc_utf8_text( NULL, len_old + len_utf8 ))) return E_OUTOFMEMORY; - if (old) memcpy( new->value.bytes, utf8_old->value.bytes, len_old ); - WideCharToMultiByte( CP_UTF8, 0, str, len, (char *)new->value.bytes + len_old, len_utf8, NULL, NULL ); + if (!(new = alloc_utf16_text( NULL, len_old + len ))) return E_OUTOFMEMORY; + if (utf16_old) memcpy( new->bytes, utf16_old->bytes, len_old ); + memcpy( new->bytes + len_old, utf16->bytes, len ); if (offset) *offset = len_old; *ret = &new->text; return S_OK; @@ -2477,6 +2513,15 @@ static enum record_type get_text_record_type( const WS_XML_TEXT *text, BOOL use_ if (text_utf8->value.length <= MAX_UINT16) return RECORD_CHARS16_TEXT_WITH_ENDELEMENT; return RECORD_CHARS32_TEXT_WITH_ENDELEMENT; } + case WS_XML_TEXT_TYPE_UTF16: + { + const WS_XML_UTF16_TEXT *text_utf16 = (const WS_XML_UTF16_TEXT *)text; + int len = text_utf16->byteCount / sizeof(WCHAR); + int len_utf8 = WideCharToMultiByte( CP_UTF8, 0, (const WCHAR *)text_utf16->bytes, len, NULL, 0, NULL, NULL ); + if (len_utf8 <= MAX_UINT8) return RECORD_CHARS8_TEXT_WITH_ENDELEMENT; + if (len_utf8 <= MAX_UINT16) return RECORD_CHARS16_TEXT_WITH_ENDELEMENT; + return RECORD_CHARS32_TEXT_WITH_ENDELEMENT; + } case WS_XML_TEXT_TYPE_BASE64: { const WS_XML_BASE64_TEXT *text_base64 = (const WS_XML_BASE64_TEXT *)text; @@ -2570,24 +2615,50 @@ static HRESULT write_text_bin( struct writer *writer, const WS_XML_TEXT *text, U { case RECORD_CHARS8_TEXT_WITH_ENDELEMENT: { - const WS_XML_UTF8_TEXT *text_utf8 = (const WS_XML_UTF8_TEXT *)text; - UINT8 len = text_utf8->value.length; + const WS_XML_UTF8_TEXT *text_utf8; + WS_XML_UTF8_TEXT *new = NULL; + UINT8 len;
- if ((hr = write_grow_buffer( writer, 1 + sizeof(len) + len )) != S_OK) return hr; + if (text->textType == WS_XML_TEXT_TYPE_UTF8) text_utf8 = (const WS_XML_UTF8_TEXT *)text; + else + { + if ((hr = text_to_utf8text( text, NULL, NULL, &new )) != S_OK) return hr; + text_utf8 = new; + } + len = text_utf8->value.length; + if ((hr = write_grow_buffer( writer, 1 + sizeof(len) + len )) != S_OK) + { + heap_free( new ); + return hr; + } write_char( writer, type ); write_char( writer, len ); write_bytes( writer, text_utf8->value.bytes, len ); + heap_free( new ); return S_OK; } case RECORD_CHARS16_TEXT_WITH_ENDELEMENT: { - const WS_XML_UTF8_TEXT *text_utf8 = (const WS_XML_UTF8_TEXT *)text; - UINT16 len = text_utf8->value.length; + const WS_XML_UTF8_TEXT *text_utf8; + WS_XML_UTF8_TEXT *new = NULL; + UINT16 len;
- if ((hr = write_grow_buffer( writer, 1 + sizeof(len) + len )) != S_OK) return hr; + if (text->textType == WS_XML_TEXT_TYPE_UTF8) text_utf8 = (const WS_XML_UTF8_TEXT *)text; + else + { + if ((hr = text_to_utf8text( text, NULL, NULL, &new )) != S_OK) return hr; + text_utf8 = new; + } + len = text_utf8->value.length; + if ((hr = write_grow_buffer( writer, 1 + sizeof(len) + len )) != S_OK) + { + heap_free( new ); + return hr; + } write_char( writer, type ); write_bytes( writer, (const BYTE *)&len, sizeof(len) ); write_bytes( writer, text_utf8->value.bytes, len ); + heap_free( new ); return S_OK; } case RECORD_BYTES8_TEXT:
-
Hans Leidekker