From: Shaun Ren sren@codeweavers.com
Signed-off-by: Shaun Ren sren@codeweavers.com --- dlls/webservices/error.c | 348 +++++++++++++++++++++++++ dlls/webservices/tests/reader.c | 310 ++++++++++++++++++++++ dlls/webservices/webservices.spec | 6 +- dlls/webservices/webservices_private.h | 2 + include/webservices.h | 39 +++ 5 files changed, 702 insertions(+), 3 deletions(-)
diff --git a/dlls/webservices/error.c b/dlls/webservices/error.c index d188b229ff4..aa1a9744f34 100644 --- a/dlls/webservices/error.c +++ b/dlls/webservices/error.c @@ -47,6 +47,8 @@ struct error ULONG strs_count; ULONG strs_size; /* Maximum length of the strs array */ WS_STRING *strs; + WS_FAULT *fault; + WS_XML_STRING fault_action; };
#define ERROR_MAGIC (('E' << 24) | ('R' << 16) | ('R' << 8) | 'O') @@ -85,6 +87,60 @@ static void free_error( struct error *error ) free( error ); }
+void free_fault_fields( WS_HEAP *heap, WS_FAULT *fault ) +{ + WS_FAULT_CODE *code, *prev_code; + ULONG i; + + code = fault->code; + while ( code ) + { + ws_free( heap, code->value.localName.bytes, code->value.localName.length ); + ws_free( heap, code->value.ns.bytes, code->value.ns.length ); + prev_code = code; + code = code->subCode; + ws_free( heap, prev_code, sizeof(*prev_code) ); + } + + for (i = 0; i < fault->reasonCount; i++) + { + ws_free( heap, fault->reasons[i].text.chars, fault->reasons[i].text.length * sizeof(WCHAR) ); + ws_free( heap, fault->reasons[i].lang.chars, fault->reasons[i].lang.length * sizeof(WCHAR) ); + } + ws_free( heap, fault->reasons, fault->reasonCount * sizeof(*fault->reasons) ); + + ws_free( heap, fault->actor.chars, fault->actor.length * sizeof(WCHAR) ); + ws_free( heap, fault->node.chars, fault->node.length * sizeof(WCHAR) ); + free_xmlbuf((struct xmlbuf *)fault->detail); +} + +static void free_fault( WS_HEAP *heap, WS_FAULT *fault ) +{ + if (!fault) return; + free_fault_fields( heap, fault ); + ws_free( heap, fault, sizeof(*fault) ); +} + +static BOOL copy_xml_string( WS_HEAP *heap, const WS_XML_STRING *src, WS_XML_STRING *dst ) +{ + if (!src->length) return TRUE; + if (!(dst->bytes = ws_alloc( heap, src->length ))) return FALSE; + memcpy( dst->bytes, src->bytes, src->length ); + dst->length = src->length; + return TRUE; +} + +static BOOL copy_string( WS_HEAP *heap, const WS_STRING *src, WS_STRING *dst ) +{ + ULONG size; + if (!src->length) return TRUE; + size = src->length * sizeof(WCHAR); + if (!(dst->chars = ws_alloc( heap, size ))) return FALSE; + memcpy( dst->chars, src->chars, size ); + dst->length = src->length; + return TRUE; +} + /* Grow the strs array to fit an extra element. */ static HRESULT grow_strs_array( struct error *error ) { @@ -115,6 +171,142 @@ static HRESULT grow_strs_array( struct error *error ) return S_OK; }
+static WS_FAULT *dup_fault( WS_HEAP *heap, const WS_FAULT *src ) +{ + WS_FAULT *new_fault; + WS_FAULT_CODE *code, *prev_code, *new_code; + struct xmlbuf *buf, *new_buf; + ULONG i; + BOOL success = FALSE; + + if (!(new_fault = ws_alloc_zero( heap, sizeof(*new_fault) ))) + return NULL; + + prev_code = NULL; + code = src->code; + while ( code ) + { + if (!(new_code = ws_alloc_zero( heap, sizeof(*new_code) )) || + !copy_xml_string( heap, &code->value.localName, &new_code->value.localName ) || + !copy_xml_string( heap, &code->value.ns, &new_code->value.ns )) + goto done; + + if (prev_code) + prev_code->subCode = new_code; + else + new_fault->code = new_code; + prev_code = new_code; + code = code->subCode; + } + + if (src->reasonCount > 0) + { + if (!(new_fault->reasons = ws_alloc_zero( heap, sizeof(*new_fault->reasons) * src->reasonCount ))) + goto done; + new_fault->reasonCount = src->reasonCount; + for (i = 0; i < src->reasonCount; i++) + { + if (!copy_string( heap, &src->reasons[i].text, &new_fault->reasons[i].text ) || + !copy_string( heap, &src->reasons[i].lang, &new_fault->reasons[i].lang )) + goto done; + } + } + + if (!copy_string( heap, &src->actor, &new_fault->actor ) || + !copy_string( heap, &src->node, &new_fault->node )) + goto done; + + buf = (struct xmlbuf *)src->detail; + new_buf = NULL; + if (buf) + { + if (!(new_buf = alloc_xmlbuf( heap, buf->bytes.length, buf->encoding, + buf->charset, buf->dict_static, buf->dict ))) + goto done; + memcpy( new_buf->bytes.bytes, buf->bytes.bytes, buf->bytes.length ); + new_buf->bytes.length = buf->bytes.length; + } + new_fault->detail = (WS_XML_BUFFER *)new_buf; + + success = TRUE; +done: + if (!success) + { + free_fault( heap, new_fault ); + return NULL; + } + return new_fault; +} + +static HRESULT set_fault( struct error *error, const WS_FAULT *value ) +{ + static const WCHAR prefix[] = L"The fault reason was: '"; + static const WCHAR postfix[] = L"'."; + static const ULONG prefix_len = ARRAY_SIZE(prefix) - 1, postfix_len = ARRAY_SIZE(postfix) - 1; + WS_FAULT *fault; + WS_STRING *str; + WCHAR *dst; + ULONG len; + HRESULT hr = S_OK; + + if (!(fault = dup_fault( error->heap, value ))) + return E_OUTOFMEMORY; + + /* FIXME: check if reason lang matches error property langid */ + if (fault->reasonCount > 0) + { + if ((hr = grow_strs_array( error )) != S_OK) goto done; + + str = &error->strs[error->strs_count]; + len = prefix_len + fault->reasons[0].text.length + postfix_len; + if (!(str->chars = ws_alloc( error->heap, len * sizeof(WCHAR) ))) + { + hr = E_OUTOFMEMORY; + goto done; + } + + dst = str->chars; + memcpy( dst, prefix, prefix_len * sizeof(WCHAR) ); + dst += prefix_len; + memcpy( dst, fault->reasons[0].text.chars, fault->reasons[0].text.length * sizeof(WCHAR) ); + dst += fault->reasons[0].text.length; + memcpy( dst, postfix, postfix_len * sizeof(WCHAR) ); + + str->length = len; + error->strs_count++; + } + + free_fault( error->heap, error->fault ); + error->fault = fault; + +done: + if (hr != S_OK) + free_fault( error->heap, fault ); + return hr; +} + +static HRESULT set_action( struct error *error, const WS_XML_STRING *value ) +{ + BYTE *buf; + + if (value->length == 0) + { + ws_free( error->heap, error->fault_action.bytes, error->fault_action.length ); + memset( &error->fault_action, 0, sizeof(error->fault_action) ); + return S_OK; + } + + if (!(buf = ws_alloc( error->heap, value->length ))) + return E_OUTOFMEMORY; + + memcpy( buf, value->bytes, value->length ); + ws_free( error->heap, error->fault_action.bytes, error->fault_action.length ); + error->fault_action.bytes = buf; + error->fault_action.length = value->length; + + return S_OK; +} + /************************************************************************** * WsCreateError [webservices.@] */ @@ -160,6 +352,9 @@ static void reset_error( struct error *error )
error->strs = NULL; error->strs_count = error->strs_size = 0; + error->fault = NULL; + memset( &error->fault_action, 0, sizeof(error->fault_action) ); + WsResetHeap( error->heap, NULL ); }
@@ -359,3 +554,156 @@ done: TRACE( "returning %#lx\n", hr ); return hr; } + +/************************************************************************** + * WsGetFaultErrorDetail [webservices.@] + */ +HRESULT WINAPI WsGetFaultErrorDetail( WS_ERROR *handle, const WS_FAULT_DETAIL_DESCRIPTION *desc, + WS_READ_OPTION option, WS_HEAP *heap, void *value, ULONG size ) +{ + static const WS_XML_STRING detail = {6, (BYTE *)"detail"}; + struct error *error = (struct error *)handle; + WS_XML_READER *reader = NULL; + const WS_XML_NODE *node; + const WS_XML_ELEMENT_NODE *elem; + BOOL nil = FALSE; + HRESULT hr = S_OK; + + TRACE( "%p %p %u %p %p %lu\n", handle, desc, option, heap, value, size ); + + if (!error || !desc || !value) return E_INVALIDARG; + if ((option == WS_READ_REQUIRED_POINTER || + option == WS_READ_OPTIONAL_POINTER || + option == WS_READ_NILLABLE_POINTER) && size != sizeof(void *)) + return E_INVALIDARG; + + EnterCriticalSection( &error->cs ); + + if (error->magic != ERROR_MAGIC) + { + hr = E_INVALIDARG; + goto done; + } + + if (!error->fault || !error->fault->detail) + { + nil = TRUE; + goto done; + } + if ((hr = WsCreateReader( NULL, 0, &reader, NULL )) != S_OK) goto done; + if ((hr = WsSetInputToBuffer( reader, error->fault->detail, NULL, 0, NULL )) != S_OK) goto done; + + if ((hr = WsReadNode( reader, NULL )) != S_OK) goto done; + if ((hr = WsGetReaderNode( reader, &node, NULL )) != S_OK) goto done; + elem = (const WS_XML_ELEMENT_NODE *)node; + if (!(node->nodeType == WS_XML_NODE_TYPE_ELEMENT && + WsXmlStringEquals( elem->localName, &detail, NULL ) == S_OK)) + { + hr = WS_E_INVALID_FORMAT; + goto done; + } + + if (desc->action && error->fault_action.length && + WsXmlStringEquals( desc->action, &error->fault_action, NULL ) != S_OK) + { + nil = TRUE; + goto done; + } + + if ((hr = WsReadNode( reader, NULL )) != S_OK) goto done; + if ((hr = WsReadElement( reader, desc->detailElementDescription, + option, heap, value, size, handle )) != S_OK) + goto done; + +done: + LeaveCriticalSection( &error->cs ); + WsFreeReader( reader ); + + if ((hr != S_OK || nil) && (option == WS_READ_OPTIONAL_POINTER || option == WS_READ_NILLABLE_POINTER)) + *(void **)value = NULL; + if (nil && !(option == WS_READ_OPTIONAL_POINTER || option == WS_READ_NILLABLE_POINTER)) + hr = WS_E_INVALID_FORMAT; + + TRACE( "returning %#lx\n", hr ); + return hr; +} + +/************************************************************************** + * WsGetFaultErrorProperty [webservices.@] + */ +HRESULT WINAPI WsGetFaultErrorProperty( WS_ERROR *handle, WS_FAULT_ERROR_PROPERTY_ID id, + void *buf, ULONG size ) +{ + struct error *error = (struct error *)handle; + HRESULT hr = S_OK; + + TRACE( "%p %u %p %lu\n", handle, id, buf, size ); + + if (!error || !buf) return E_INVALIDARG; + if (id > WS_FAULT_ERROR_PROPERTY_HEADER) return E_INVALIDARG; + else if (id == WS_FAULT_ERROR_PROPERTY_HEADER) + { + FIXME( "WS_FAULT_ERROR_PROPERTY_HEADER not supported\n" ); + return E_NOTIMPL; + } + + EnterCriticalSection( &error->cs ); + + if (error->magic != ERROR_MAGIC) + { + hr = E_INVALIDARG; + goto done; + } + + if (id == WS_FAULT_ERROR_PROPERTY_FAULT && size == sizeof(WS_FAULT *)) + *(WS_FAULT **)buf = error->fault; + else if (id == WS_FAULT_ERROR_PROPERTY_ACTION && size == sizeof(WS_XML_STRING)) + memcpy( buf, &error->fault_action, sizeof(WS_XML_STRING) ); + else + hr = E_INVALIDARG; + +done: + LeaveCriticalSection( &error->cs ); + TRACE( "returning %#lx\n", hr ); + return hr; +} + +/************************************************************************** + * WsSetFaultErrorProperty [webservices.@] + */ +HRESULT WINAPI WsSetFaultErrorProperty( WS_ERROR *handle, WS_FAULT_ERROR_PROPERTY_ID id, + const void *value, ULONG size ) +{ + struct error *error = (struct error *)handle; + HRESULT hr = S_OK; + + TRACE( "%p %u %p %lu\n", handle, id, value, size ); + + if (!error || !value) return E_INVALIDARG; + if (id > WS_FAULT_ERROR_PROPERTY_HEADER) return E_INVALIDARG; + else if (id == WS_FAULT_ERROR_PROPERTY_HEADER) + { + FIXME( "WS_FAULT_ERROR_PROPERTY_HEADER not supported\n" ); + return E_NOTIMPL; + } + + EnterCriticalSection( &error->cs ); + + if (error->magic != ERROR_MAGIC) + { + hr = E_INVALIDARG; + goto done; + } + + if (id == WS_FAULT_ERROR_PROPERTY_FAULT && size == sizeof(WS_FAULT)) + hr = set_fault( error, value ); + else if (id == WS_FAULT_ERROR_PROPERTY_ACTION && size == sizeof(WS_XML_STRING)) + hr = set_action( error, value ); + else + hr = E_INVALIDARG; + +done: + LeaveCriticalSection( &error->cs ); + TRACE( "returning %#lx\n", hr ); + return hr; +} diff --git a/dlls/webservices/tests/reader.c b/dlls/webservices/tests/reader.c index 84a8660d6f1..2ade3c3d4b1 100644 --- a/dlls/webservices/tests/reader.c +++ b/dlls/webservices/tests/reader.c @@ -3894,6 +3894,9 @@ static void test_WsResetError(void) WS_ERROR *error; LANGID langid; WS_STRING str; + WS_FAULT fault; + WS_XML_STRING xmlstr; + WS_FAULT *faultp; HRESULT hr;
hr = WsResetError( NULL ); @@ -3971,6 +3974,34 @@ static void test_WsResetError(void) ok( count == 0, "got %lu\n", count );
WsFreeError( error ); + + memset( &fault, 0, sizeof(fault) ); + xmlstr.bytes = (BYTE *)"str"; + xmlstr.length = 3; + + hr = WsCreateError( NULL, 0, &error ); + ok( hr == S_OK, "got %#lx\n", hr ); + + hr = WsSetFaultErrorProperty( error, WS_FAULT_ERROR_PROPERTY_FAULT, &fault, sizeof(fault) ); + ok( hr == S_OK, "got %#lx\n", hr ); + hr = WsSetFaultErrorProperty( error, WS_FAULT_ERROR_PROPERTY_ACTION, &xmlstr, sizeof(WS_XML_STRING) ); + ok( hr == S_OK, "got %#lx\n", hr ); + + hr = WsResetError( error ); + ok( hr == S_OK, "got %#lx\n", hr ); + + faultp = (WS_FAULT *)0xdeadbeef; + hr = WsGetFaultErrorProperty( error, WS_FAULT_ERROR_PROPERTY_FAULT, &faultp, sizeof(faultp) ); + ok( hr == S_OK, "got %#lx\n", hr ); + ok( faultp == NULL, "faultp != NULL\n" ); + + xmlstr.length = 0xdeadbeef; + xmlstr.bytes = (BYTE *)0xdeadbeef; + hr = WsGetFaultErrorProperty( error, WS_FAULT_ERROR_PROPERTY_ACTION, &xmlstr, sizeof(xmlstr) ); + ok( hr == S_OK, "got %#lx\n", hr ); + ok( xmlstr.length == 0, "got %lu\n", xmlstr.length ); + + WsFreeError( error ); }
static void test_WsGetReaderPosition(void) @@ -7122,6 +7153,283 @@ static void test_WsAddErrorString(void)
WsFreeError( error ); } + +static void test_WsSetFaultErrorProperty(void) +{ + static const WCHAR expected_errorstr[] = L"The fault reason was: 'Some reason'."; + static const char detailxml[] = "<detail><ErrorCode>1030</ErrorCode></detail>"; + static const LANGID langid = MAKELANGID( LANG_ENGLISH, SUBLANG_ENGLISH_US ); + static const WS_XML_STRING action = { 24, (BYTE *)"http://example.com/fault" }; + WS_ERROR_PROPERTY prop; + WS_ERROR *error; + WS_FAULT fault; + WS_FAULT *faultp; + WS_XML_STRING outxmlstr; + WS_STRING outstr; + ULONG count; + WS_HEAP *heap; + WS_XML_READER *reader; + HRESULT hr; + + prop.id = WS_ERROR_PROPERTY_LANGID; + prop.value = (void *)&langid; + prop.valueSize = sizeof(langid); + + hr = WsCreateError( &prop, 1, &error ); + ok( hr == S_OK, "got %#lx\n", hr ); + + hr = WsSetFaultErrorProperty( error, WS_FAULT_ERROR_PROPERTY_FAULT, NULL, sizeof(WS_FAULT) ); + ok( hr == E_INVALIDARG, "got %#lx\n", hr ); + + hr = WsSetFaultErrorProperty( error, WS_FAULT_ERROR_PROPERTY_ACTION, NULL, sizeof(WS_XML_STRING) ); + ok( hr == E_INVALIDARG, "got %#lx\n", hr ); + + memset( &fault, 0, sizeof(fault) ); + + fault.code = calloc( 1, sizeof(WS_FAULT_CODE) ); + fault.code->value.localName.bytes = (BYTE *)"Server"; + fault.code->value.localName.length = 6; + fault.code->subCode = calloc( 1, sizeof(WS_FAULT_CODE) ); + fault.code->subCode->value.localName.bytes = (BYTE *)"SubCode"; + fault.code->subCode->value.localName.length = 7; + + fault.reasons = calloc( 1, sizeof(*fault.reasons) ); + fault.reasonCount = 1; + fault.reasons[0].lang.chars = (WCHAR *) L"en-US"; + fault.reasons[0].lang.length = 5; + fault.reasons[0].text.chars = (WCHAR *) L"Some reason"; + fault.reasons[0].text.length = 11; + + hr = WsSetFaultErrorProperty( error, WS_FAULT_ERROR_PROPERTY_FAULT, &fault, sizeof(WS_FAULT) ); + ok( hr == S_OK, "got %#lx\n", hr ); + + faultp = NULL; + hr = WsGetFaultErrorProperty( error, WS_FAULT_ERROR_PROPERTY_FAULT, &faultp, sizeof(faultp) ); + ok( hr == S_OK, "got %#lx\n", hr ); + ok( faultp != NULL, "faultp not set\n" ); + ok( faultp != &fault, "fault not copied\n" ); + + ok( faultp->code && faultp->code != fault.code, "fault code not copied\n" ); + ok( faultp->code->value.localName.length == 6, "got %lu\n", faultp->code->value.localName.length ); + ok( !memcmp( faultp->code->value.localName.bytes, fault.code->value.localName.bytes, 6 ), + "wrong code localName\n" ); + ok( faultp->code->value.localName.bytes != fault.code->value.localName.bytes, + "fault code localName not copied\n" ); + ok( faultp->code->value.ns.length == 0, "got %lu\n", faultp->code->value.ns.length ); + ok( faultp->code->subCode && faultp->code->subCode != fault.code->subCode, + "fault code subCode not copied\n" ); + ok( faultp->code->subCode->value.localName.length == 7,"got %lu\n", faultp->code->subCode->value.localName.length ); + ok( !memcmp( faultp->code->subCode->value.localName.bytes, fault.code->subCode->value.localName.bytes, 7 ), + "wrong subCode localName\n" ); + ok( faultp->code->subCode->value.localName.bytes != fault.code->subCode->value.localName.bytes, + "fault code subCode localName not copied\n" ); + ok( faultp->code->subCode->value.ns.length == 0, "got %lu\n", faultp->code->subCode->value.ns.length ); + ok( faultp->code->subCode->subCode == NULL, "fault->code->subCode->subCode != NULL\n"); + + ok( faultp->reasons != fault.reasons, "fault reasons not copied\n" ); + ok( faultp->reasonCount == 1, "got %lu\n", faultp->reasonCount ); + ok( faultp->reasons[0].lang.length == 5, "got %lu\n", faultp->reasons[0].text.length ); + ok( !memcmp( faultp->reasons[0].lang.chars, fault.reasons[0].lang.chars, 5 * sizeof(WCHAR) ), + "wrong fault reason lang\n" ); + ok( faultp->reasons[0].lang.chars != fault.reasons[0].lang.chars, + "fault reason lang not copied\n" ); + ok( faultp->reasons[0].text.length == 11, "got %lu\n", faultp->reasons[0].text.length ); + ok( !memcmp( faultp->reasons[0].text.chars, fault.reasons[0].text.chars, 11 * sizeof(WCHAR) ), + "wrong fault reason text\n" ); + ok( faultp->reasons[0].text.chars != fault.reasons[0].text.chars, + "fault reason text not copied\n" ); + + ok( faultp->actor.length == 0, "got %lu\n", faultp->actor.length ); + ok( faultp->node.length == 0, "got %lu\n", faultp->node.length ); + ok( faultp->detail == NULL, "faultp->detail != NULL\n" ); + + count = 0xdeadbeef; + hr = WsGetErrorProperty( error, WS_ERROR_PROPERTY_STRING_COUNT, &count, sizeof(count) ); + ok( hr == S_OK, "got %#lx\n", hr ); + ok( count == 1, "got %lu\n", count ); + + hr = WsGetErrorString( error, 0, &outstr ); + ok( hr == S_OK, "got %#lx\n", hr ); + ok( outstr.length == ARRAY_SIZE(expected_errorstr) - 1, "got %lu\n", outstr.length ); + ok( !memcmp( outstr.chars, expected_errorstr, (ARRAY_SIZE(expected_errorstr) - 1) * sizeof(WCHAR) ), + "wrong error string\n" ); + + outxmlstr.bytes = (BYTE *)0xdeadbeef; + outxmlstr.length = 0xdeadbeef; + hr = WsGetFaultErrorProperty( error, WS_FAULT_ERROR_PROPERTY_ACTION, &outxmlstr, sizeof(outxmlstr) ); + ok( hr == S_OK, "got %#lx\n", hr ); + ok( outxmlstr.length == 0, "got %lu\n", outxmlstr.length ); + + hr = WsSetFaultErrorProperty( error, WS_FAULT_ERROR_PROPERTY_ACTION, &action, sizeof(action) ); + ok( hr == S_OK, "got %#lx\n", hr ); + + outxmlstr.bytes = (BYTE *)0xdeadbeef; + outxmlstr.length = 0xdeadbeef; + hr = WsGetFaultErrorProperty( error, WS_FAULT_ERROR_PROPERTY_ACTION, &outxmlstr, sizeof(outxmlstr) ); + ok( hr == S_OK, "got %#lx\n", hr ); + ok( outxmlstr.length == 24, "got %lu\n", outxmlstr.length ); + ok( !memcmp( outxmlstr.bytes, action.bytes, 24 ), "wrong fault action\n" ); + + hr = WsCreateHeap( 1 << 16, 0, NULL, 0, &heap, NULL ); + ok( hr == S_OK, "got %#lx\n", hr ); + hr = WsCreateReader( NULL, 0, &reader, NULL ); + ok( hr == S_OK, "got %#lx\n", hr ); + hr = set_input( reader, detailxml, strlen(detailxml) ); + ok( hr == S_OK, "got %#lx\n", hr ); + hr = WsReadXmlBuffer( reader, heap, &fault.detail, NULL ); + ok( hr == S_OK, "got %#lx\n", hr ); + + hr = WsSetFaultErrorProperty( error, WS_FAULT_ERROR_PROPERTY_FAULT, &fault, sizeof(WS_FAULT) ); + ok( hr == S_OK, "got %#lx\n", hr ); + + hr = WsGetFaultErrorProperty( error, WS_FAULT_ERROR_PROPERTY_FAULT, &faultp, sizeof(faultp) ); + ok( hr == S_OK, "got %#lx\n", hr ); + ok( faultp != NULL, "faultp not set\n" ); + ok( faultp->detail != NULL, "fault detail not set\n" ); + ok( faultp->detail != fault.detail, "fault detail not copied\n" ); + check_output_buffer( faultp->detail, detailxml, __LINE__ ); + + free( fault.code->subCode ); + free( fault.code ); + free( fault.reasons ); + WsFreeReader( reader ); + WsFreeHeap( heap ); + WsFreeError( error ); +} + +static void test_WsGetFaultErrorDetail(void) +{ + static const char detailxml[] = "<detail><ErrorCode>1030</ErrorCode></detail>"; + static const char badxml[] = "<bad><ErrorCode>1030</ErrorCode></bad>"; + + WS_ERROR *error; + WS_HEAP *heap; + WS_XML_READER *reader; + WS_FAULT fault; + WS_XML_STRING action = { 24, (BYTE *)"http://example.com/fault" }; + WS_XML_STRING action2 = { 25, (BYTE *)"http://example.com/fault2" }; + WS_XML_STRING localname = { 9, (BYTE *)"ErrorCode" }, localname2 = { 9, (BYTE *)"OtherCode" }; + WS_XML_STRING ns = { 0 }; + WS_ELEMENT_DESCRIPTION desc = { &localname, &ns, WS_UINT32_TYPE, NULL }; + WS_ELEMENT_DESCRIPTION desc2 = { &localname2, &ns, WS_UINT32_TYPE, NULL }; + WS_FAULT_DETAIL_DESCRIPTION fault_desc; + UINT32 code; + UINT32 *codep; + HRESULT hr; + + hr = WsCreateError( NULL, 0, &error ); + ok( hr == S_OK, "got %#lx\n", hr ); + + memset( &fault, 0, sizeof(fault) ); + + hr = WsCreateHeap( 1 << 16, 0, NULL, 0, &heap, NULL ); + ok( hr == S_OK, "got %#lx\n", hr ); + hr = WsCreateReader( NULL, 0, &reader, NULL ); + ok( hr == S_OK, "got %#lx\n", hr ); + + hr = set_input( reader, detailxml, strlen(detailxml) ); + ok( hr == S_OK, "got %#lx\n", hr ); + hr = WsReadXmlBuffer( reader, heap, &fault.detail, NULL ); + ok( hr == S_OK, "got %#lx\n", hr ); + hr = WsSetFaultErrorProperty( error, WS_FAULT_ERROR_PROPERTY_FAULT, &fault, sizeof(fault) ); + ok( hr == S_OK, "got %#lx\n", hr ); + + fault_desc.action = NULL; + fault_desc.detailElementDescription = &desc; + + code = 0xdeadbeef; + hr = WsGetFaultErrorDetail( error, &fault_desc, WS_READ_REQUIRED_VALUE, heap, &code, sizeof(code) ); + ok( hr == S_OK, "got %#lx\n", hr ); + ok( code == 1030, "got %u\n", code ); + + codep = (UINT32 *)0xdeadbeef; + hr = WsGetFaultErrorDetail( error, &fault_desc, WS_READ_OPTIONAL_POINTER, heap, &codep, sizeof(codep) ); + ok( hr == S_OK, "got %#lx\n", hr ); + ok( codep != NULL, "codep == NULL\n" ); + ok( *codep == 1030, "got %u\n", *codep ); + + fault_desc.action = &action; + + code = 0xdeadbeef; + hr = WsGetFaultErrorDetail( error, &fault_desc, WS_READ_REQUIRED_VALUE, heap, &code, sizeof(code) ); + ok( hr == S_OK, "got %#lx\n", hr ); + ok( code == 1030, "got %u\n", code ); + + hr = WsSetFaultErrorProperty( error, WS_FAULT_ERROR_PROPERTY_ACTION, &action, sizeof(action) ); + ok( hr == S_OK, "got %#lx\n", hr ); + + fault_desc.action = NULL; + + code = 0xdeadbeef; + hr = WsGetFaultErrorDetail( error, &fault_desc, WS_READ_REQUIRED_VALUE, heap, &code, sizeof(code) ); + ok( hr == S_OK, "got %#lx\n", hr ); + ok( code == 1030, "got %u\n", code ); + + fault_desc.action = &action2; + + hr = WsGetFaultErrorDetail( error, &fault_desc, WS_READ_REQUIRED_VALUE, heap, &code, sizeof(code) ); + ok( hr == WS_E_INVALID_FORMAT, "got %#lx\n", hr ); + + hr = WsGetFaultErrorDetail( error, &fault_desc, WS_READ_REQUIRED_POINTER, heap, &codep, sizeof(codep) ); + ok( hr == WS_E_INVALID_FORMAT, "got %#lx\n", hr ); + + codep = (UINT32 *)0xdeadbeef; + hr = WsGetFaultErrorDetail( error, &fault_desc, WS_READ_OPTIONAL_POINTER, heap, &codep, sizeof(codep) ); + ok( hr == S_OK, "got %#lx\n", hr ); + ok( codep == NULL, "codep != NULL\n" ); + + codep = (UINT32 *)0xdeadbeef; + hr = WsGetFaultErrorDetail( error, &fault_desc, WS_READ_NILLABLE_POINTER, heap, &codep, sizeof(codep) ); + ok( hr == S_OK, "got %#lx\n", hr ); + ok( codep == NULL, "codep != NULL\n" ); + + fault_desc.action = NULL; + fault_desc.detailElementDescription = &desc2; + + hr = WsGetFaultErrorDetail( error, &fault_desc, WS_READ_REQUIRED_VALUE, heap, &code, sizeof(code) ); + ok( hr == WS_E_INVALID_FORMAT, "got %#lx\n", hr ); + + hr = WsGetFaultErrorDetail( error, &fault_desc, WS_READ_REQUIRED_POINTER, heap, &codep, sizeof(codep) ); + ok( hr == WS_E_INVALID_FORMAT, "got %#lx\n", hr ); + + codep = (UINT32 *)0xdeadbeef; + hr = WsGetFaultErrorDetail( error, &fault_desc, WS_READ_OPTIONAL_POINTER, heap, &codep, sizeof(codep) ); + ok( hr == WS_E_INVALID_FORMAT, "got %#lx\n", hr ); + ok( codep == NULL, "codep != NULL\n" ); + + codep = (UINT32 *)0xdeadbeef; + hr = WsGetFaultErrorDetail( error, &fault_desc, WS_READ_NILLABLE_POINTER, heap, &codep, sizeof(codep) ); + ok( hr == WS_E_INVALID_FORMAT, "got %#lx\n", hr ); + ok( codep == NULL, "codep != NULL\n" ); + + hr = set_input( reader, badxml, strlen(badxml) ); + ok( hr == S_OK, "got %#lx\n", hr ); + hr = WsReadXmlBuffer( reader, heap, &fault.detail, NULL ); + ok( hr == S_OK, "got %#lx\n", hr ); + hr = WsSetFaultErrorProperty( error, WS_FAULT_ERROR_PROPERTY_FAULT, &fault, sizeof(fault) ); + ok( hr == S_OK, "got %#lx\n", hr ); + + hr = WsGetFaultErrorDetail( error, &fault_desc, WS_READ_REQUIRED_VALUE, heap, &code, sizeof(code) ); + ok( hr == WS_E_INVALID_FORMAT, "got %#lx\n", hr ); + + hr = WsGetFaultErrorDetail( error, &fault_desc, WS_READ_REQUIRED_POINTER, heap, &codep, sizeof(codep) ); + ok( hr == WS_E_INVALID_FORMAT, "got %#lx\n", hr ); + + codep = (UINT32 *)0xdeadbeef; + hr = WsGetFaultErrorDetail( error, &fault_desc, WS_READ_OPTIONAL_POINTER, heap, &codep, sizeof(codep) ); + ok( hr == WS_E_INVALID_FORMAT, "got %#lx\n", hr ); + ok( codep == NULL, "codep != NULL\n" ); + + codep = (UINT32 *)0xdeadbeef; + hr = WsGetFaultErrorDetail( error, &fault_desc, WS_READ_NILLABLE_POINTER, heap, &codep, sizeof(codep) ); + ok( hr == WS_E_INVALID_FORMAT, "got %#lx\n", hr ); + ok( codep == NULL, "codep != NULL\n" ); + + WsFreeReader( reader ); + WsFreeHeap( heap ); + WsFreeError( error ); +} + START_TEST(reader) { test_WsCreateError(); @@ -7174,4 +7482,6 @@ START_TEST(reader) test_stream_input(); test_description_type(); test_WsAddErrorString(); + test_WsSetFaultErrorProperty(); + test_WsGetFaultErrorDetail(); } diff --git a/dlls/webservices/webservices.spec b/dlls/webservices/webservices.spec index 679d294ec1c..df28d71950a 100644 --- a/dlls/webservices/webservices.spec +++ b/dlls/webservices/webservices.spec @@ -64,8 +64,8 @@ @ stdcall WsGetDictionary(long ptr ptr) @ stdcall WsGetErrorProperty(ptr long ptr long) @ stdcall WsGetErrorString(ptr long ptr) -@ stub WsGetFaultErrorDetail -@ stub WsGetFaultErrorProperty +@ stdcall WsGetFaultErrorDetail(ptr ptr ptr ptr ptr long) +@ stdcall WsGetFaultErrorProperty(ptr long ptr long) @ stdcall WsGetHeader(ptr long long long ptr ptr long ptr) @ stub WsGetHeaderAttributes @ stdcall WsGetHeapProperty(ptr long ptr long ptr) @@ -148,7 +148,7 @@ @ stdcall WsSetChannelProperty(ptr long ptr long ptr) @ stdcall WsSetErrorProperty(ptr long ptr long) @ stub WsSetFaultErrorDetail -@ stub WsSetFaultErrorProperty +@ stdcall WsSetFaultErrorProperty(ptr long ptr long) @ stdcall WsSetHeader(ptr long long long ptr long ptr) @ stdcall WsSetInput(ptr ptr ptr ptr long ptr) @ stdcall WsSetInputToBuffer(ptr ptr ptr long ptr) diff --git a/dlls/webservices/webservices_private.h b/dlls/webservices/webservices_private.h index 373ab6799a9..d7f62c3d8a6 100644 --- a/dlls/webservices/webservices_private.h +++ b/dlls/webservices/webservices_private.h @@ -171,6 +171,8 @@ HRESULT channel_get_reader( WS_CHANNEL *, WS_XML_READER ** ) DECLSPEC_HIDDEN;
HRESULT parse_url( const WS_STRING *, WS_URL_SCHEME_TYPE *, WCHAR **, USHORT * ) DECLSPEC_HIDDEN;
+void free_fault_fields( WS_HEAP *, WS_FAULT * ) DECLSPEC_HIDDEN; + enum record_type { /* 0x00 reserved */ diff --git a/include/webservices.h b/include/webservices.h index 9395ad6f0e3..6657ee84201 100644 --- a/include/webservices.h +++ b/include/webservices.h @@ -1116,6 +1116,41 @@ struct _WS_ENDPOINT_ADDRESS { WS_ENDPOINT_IDENTITY *identity; };
+typedef struct _WS_FAULT_CODE { + WS_XML_QNAME value; + struct _WS_FAULT_CODE *subCode; +} WS_FAULT_CODE; + +typedef struct _WS_FAULT_REASON { + WS_STRING text; + WS_STRING lang; +} WS_FAULT_REASON; + +typedef struct _WS_FAULT { + WS_FAULT_CODE *code; + WS_FAULT_REASON *reasons; + ULONG reasonCount; + WS_STRING actor; + WS_STRING node; + WS_XML_BUFFER *detail; +} WS_FAULT; + +typedef struct _WS_FAULT_DESCRIPTION { + WS_ENVELOPE_VERSION envelopeVersion; +} WS_FAULT_DESCRIPTION; + +typedef struct _WS_FAULT_DETAIL_DESCRIPTION { + WS_XML_STRING *action; + WS_ELEMENT_DESCRIPTION *detailElementDescription; +} WS_FAULT_DETAIL_DESCRIPTION; + +typedef enum { + WS_FAULT_ERROR_PROPERTY_FAULT = 0, + WS_FAULT_ERROR_PROPERTY_ACTION = 1, + WS_FAULT_ERROR_PROPERTY_HEADER = 2 +} WS_FAULT_ERROR_PROPERTY_ID; + + struct _WS_HTTP_POLICY_DESCRIPTION { WS_CHANNEL_PROPERTIES channelProperties; }; @@ -1649,6 +1684,9 @@ HRESULT WINAPI WsGetCustomHeader(WS_MESSAGE*, const WS_ELEMENT_DESCRIPTION*, WS_ HRESULT WINAPI WsGetDictionary(WS_ENCODING, WS_XML_DICTIONARY**, WS_ERROR*); HRESULT WINAPI WsGetErrorProperty(WS_ERROR*, WS_ERROR_PROPERTY_ID, void*, ULONG); HRESULT WINAPI WsGetErrorString(WS_ERROR*, ULONG, WS_STRING*); +HRESULT WINAPI WsGetFaultErrorDetail(WS_ERROR*, const WS_FAULT_DETAIL_DESCRIPTION*, WS_READ_OPTION, + WS_HEAP*, void*, ULONG); +HRESULT WINAPI WsGetFaultErrorProperty(WS_ERROR*, WS_FAULT_ERROR_PROPERTY_ID, void*, ULONG); HRESULT WINAPI WsGetHeader(WS_MESSAGE*, WS_HEADER_TYPE, WS_TYPE, WS_READ_OPTION, WS_HEAP*, void*, ULONG, WS_ERROR*); HRESULT WINAPI WsGetHeapProperty(WS_HEAP*, WS_HEAP_PROPERTY_ID, void*, ULONG, WS_ERROR*); @@ -1731,6 +1769,7 @@ HRESULT WINAPI WsSendReplyMessage(WS_CHANNEL*, WS_MESSAGE*, const WS_MESSAGE_DES const WS_ASYNC_CONTEXT*, WS_ERROR*); HRESULT WINAPI WsSetChannelProperty(WS_CHANNEL*, WS_CHANNEL_PROPERTY_ID, const void*, ULONG, WS_ERROR*); HRESULT WINAPI WsSetErrorProperty(WS_ERROR*, WS_ERROR_PROPERTY_ID, const void*, ULONG); +HRESULT WINAPI WsSetFaultErrorProperty(WS_ERROR*, WS_FAULT_ERROR_PROPERTY_ID, const void*, ULONG); HRESULT WINAPI WsSetHeader(WS_MESSAGE*, WS_HEADER_TYPE, WS_TYPE, WS_WRITE_OPTION, const void*, ULONG, WS_ERROR*); HRESULT WINAPI WsSetInput(WS_XML_READER*, const WS_XML_READER_ENCODING*, const WS_XML_READER_INPUT*,