/**************************************************************************
* WsWriteEnvelopeStart [webservices.@]
*/
HRESULT WINAPI WsWriteEnvelopeStart( WS_MESSAGE *handle, WS_XML_WRITER *writer,
WS_MESSAGE_DONE_CALLBACK cb, void *state, WS_ERROR *error )
{
struct msg *msg = (struct msg *)handle;
HRESULT hr;
TRACE( "%p %p %p %p %p\n", handle, writer, cb, state, error );
if (error) FIXME( "ignoring error parameter\n" );
if (cb)
{
FIXME( "callback not supported\n" );
return E_NOTIMPL;
}
if (!handle) return E_INVALIDARG;
if (msg->state != WS_MESSAGE_STATE_INITIALIZED) return WS_E_INVALID_OPERATION;
if ((hr = WsCreateWriter( NULL, 0, &msg->writer, NULL )) != S_OK) return hr;
if ((hr = WsSetOutputToBuffer( msg->writer, msg->buf, NULL, 0, NULL )) != S_OK) return hr;
if ((hr = write_envelope_start( msg, msg->writer )) != S_OK) return hr;
if ((hr = write_envelope_start( msg, writer )) != S_OK) return hr;
if ((hr = write_envelope_end( msg, msg->writer )) != S_OK) return hr;
msg->writer_body = writer;
msg->state = WS_MESSAGE_STATE_WRITING;
return S_OK;
}
// Main entry point
int __cdecl wmain()
{
HRESULT hr = S_OK;
WS_ERROR* error = NULL;
WS_XML_BUFFER* xmlBuffer = NULL;
WS_HEAP* heap = NULL;
WS_XML_READER* xmlReader = NULL;
WS_XML_WRITER* xmlWriter = NULL;
PayloadBaseType* baseType = NULL;
Payload1Type* payload1Type = NULL;
static const WS_XML_STRING dataElement = WS_XML_STRING_VALUE("data");
static const WS_XML_STRING emptyNamespace = WS_XML_STRING_VALUE("");
// Create an error object for storing rich error information
hr = WsCreateError(
NULL,
0,
&error);
if (FAILED(hr))
{
goto Exit;
}
// Create a heap to store deserialized data
hr = WsCreateHeap(
/*maxSize*/ 4096,
/*trimSize*/ 512,
NULL,
0,
&heap,
error);
if (FAILED(hr))
{
goto Exit;
}
// Create an XML reader
hr = WsCreateReader(
NULL,
0,
&xmlReader,
error);
if (FAILED(hr))
{
goto Exit;
}
// Create an XML writer
hr = WsCreateWriter(
NULL,
0,
&xmlWriter,
error);
if (FAILED(hr))
{
goto Exit;
}
// Create an XML buffer on the specified heap
hr = WsCreateXmlBuffer(
heap,
NULL,
0,
&xmlBuffer,
error);
if (FAILED(hr))
{
goto Exit;
}
// Set the writer to output to the XML buffer
hr = WsSetOutputToBuffer(
xmlWriter,
xmlBuffer,
NULL,
0,
error);
if (FAILED(hr))
{
goto Exit;
}
// Create a wrapper element for the two embedded elements
hr = WsWriteStartElement(
xmlWriter,
NULL,
&dataElement,
&emptyNamespace,
error);
if (FAILED(hr))
{
goto Exit;
}
baseType = new(std::nothrow) PayloadBaseType();
if (baseType == NULL)
{
goto Exit;
}
baseType->Id = 1;
payload1Type = new(std::nothrow) Payload1Type();
if (payload1Type == NULL)
{
goto Exit;
}
payload1Type->Id = 2;
payload1Type->BoolValue = FALSE;
payload1Type->StringValue = L"hello world";
// Write the base type using the element description of the base type.
// An xsi:type attribute will be added to the XML document for the element
// indicating this is the base type.
hr = WsWriteElement(
xmlWriter,
&DerivedType_xsd.globalElements.PayloadBase,
WS_WRITE_REQUIRED_VALUE,
baseType,
sizeof(PayloadBaseType),
error);
if (FAILED(hr))
{
goto Exit;
}
// Write the derived type using the element description of the base type.
// An xsi:type attribute will be added to the XML document for the element
// indicating this is the derived type.
hr = WsWriteElement(
xmlWriter,
&DerivedType_xsd.globalElements.PayloadBase,
WS_WRITE_REQUIRED_VALUE,
payload1Type,
sizeof(Payload1Type),
error);
if (FAILED(hr))
{
goto Exit;
}
hr = WsWriteEndElement(
xmlWriter,
error);
if (FAILED(hr))
{
goto Exit;
}
// Flush writer so all XML content is put in the buffer
hr = WsFlushWriter(xmlWriter, 0, NULL, error);
if (FAILED(hr))
{
goto Exit;
}
// Set the reader input to current position of XML buffer
hr = WsSetInputToBuffer(xmlReader, xmlBuffer, NULL, 0, error);
if (FAILED(hr))
{
goto Exit;
}
// Read pass the wrapper element
hr = WsReadToStartElement(
xmlReader,
&dataElement,
&emptyNamespace,
NULL,
error);
if (FAILED(hr))
{
goto Exit;
}
hr = WsReadStartElement(
xmlReader,
error);
if (FAILED(hr))
{
goto Exit;
}
PayloadBaseType* outBaseType = NULL;
// Read the first element using element description for the base
// type. The type of returning structure is that of that base type.
hr = WsReadElement(
xmlReader,
&DerivedType_xsd.globalElements.PayloadBase,
WS_READ_REQUIRED_POINTER,
heap,
&outBaseType,
sizeof(PayloadBaseType*),
error);
if (FAILED(hr))
{
goto Exit;
}
PrintPayloadType(outBaseType);
// Read the second element using element description for the base
// type. The type of returning structure is that of the derived type.
hr = WsReadElement(
xmlReader,
&DerivedType_xsd.globalElements.PayloadBase,
WS_READ_REQUIRED_POINTER,
heap,
&outBaseType,
sizeof(PayloadBaseType*),
error);
if (FAILED(hr))
{
goto Exit;
}
PrintPayloadType(outBaseType);
hr = WsReadEndElement(
xmlReader,
error);
if (FAILED(hr))
{
goto Exit;
}
Exit:
if (FAILED(hr))
{
// Print out the error
PrintError(hr, error);
}
delete baseType;
delete payload1Type;
if (xmlReader != NULL)
{
WsFreeReader(xmlReader);
}
if (xmlWriter != NULL)
{
WsFreeWriter(xmlWriter);
}
if (error != NULL)
{
WsFreeError(error);
}
if (heap != NULL)
{
WsFreeHeap(heap);
}
fflush(stdout);
return SUCCEEDED(hr) ? 0 : -1;
}
// Main entry point
int __cdecl wmain()
{
HRESULT hr = S_OK;
WS_ERROR* error = NULL;
WS_HEAP* heap = NULL;
WS_XML_BUFFER* buffer = NULL;
WS_XML_WRITER* writer = NULL;
WS_XML_READER* reader = NULL;
void* xml = NULL;
ULONG xmlLength = 0;
WS_XML_NODE_POSITION securityEndElementPosition;
static const WS_XML_STRING soapNs = WS_XML_STRING_VALUE("http://schemas.xmlsoap.org/soap/envelope/");
static const WS_XML_STRING wsseNs = WS_XML_STRING_VALUE("http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd");
static const WS_XML_STRING envelope = WS_XML_STRING_VALUE("Envelope");
static const WS_XML_STRING header = WS_XML_STRING_VALUE("Header");
static const WS_XML_STRING security = WS_XML_STRING_VALUE("Security");
static const WS_XML_STRING dsNs = WS_XML_STRING_VALUE("http://www.w3.org/2000/09/xmldsig#");
static const WS_XML_STRING signature = WS_XML_STRING_VALUE("Signature");
// Create an error object for storing rich error information
hr = WsCreateError(
NULL,
0,
&error);
if (FAILED(hr))
{
goto Exit;
}
// Create a heap to store deserialized data
hr = WsCreateHeap(
/*maxSize*/ 2048,
/*trimSize*/ 512,
NULL,
0,
&heap,
error);
if (FAILED(hr))
{
goto Exit;
}
// Create an XML writer
hr = WsCreateWriter(
NULL,
0,
&writer,
error);
if (FAILED(hr))
{
goto Exit;
}
// Create an XML reader
hr = WsCreateReader(
NULL,
0,
&reader,
error);
if (FAILED(hr))
{
goto Exit;
}
// Create an XML buffer on the specified heap
hr = WsCreateXmlBuffer(
heap,
NULL,
0,
&buffer,
error);
if (FAILED(hr))
{
goto Exit;
}
// Set the writer to output to the XML buffer
hr = WsSetOutputToBuffer(
writer,
buffer,
NULL,
0,
error);
if (FAILED(hr))
{
goto Exit;
}
// Write the envelope element
hr = WsWriteStartElement(writer, NULL, &envelope, &soapNs, error);
if (FAILED(hr))
{
goto Exit;
}
// Write the header element
hr = WsWriteStartElement(writer, NULL, &header, &soapNs, error);
if (FAILED(hr))
{
goto Exit;
}
// Write the security element
hr = WsWriteStartElement(writer, NULL, &security, &wsseNs, error);
if (FAILED(hr))
{
goto Exit;
}
// Force the security element start tag to be written so the position obtained
// is "after" the security element
hr = WsWriteEndStartElement(writer, error);
if (FAILED(hr))
{
goto Exit;
}
hr = WsGetWriterPosition(writer, &securityEndElementPosition, error);
if (FAILED(hr))
{
goto Exit;
}
// Close the security element
hr = WsWriteEndElement(writer, error);
if (FAILED(hr))
{
goto Exit;
}
// Close the header element
hr = WsWriteEndElement(writer, error);
if (FAILED(hr))
{
goto Exit;
}
// Close the envelope element
hr = WsWriteEndElement(writer, error);
if (FAILED(hr))
{
goto Exit;
}
// Move the write back
hr = WsSetWriterPosition(writer, &securityEndElementPosition, error);
if (FAILED(hr))
{
goto Exit;
}
// Write the "signature" element
hr = WsWriteStartElement(writer, NULL, &signature, &dsNs, error);
if (FAILED(hr))
{
goto Exit;
}
// Close the signature element
hr = WsWriteEndElement(writer, error);
if (FAILED(hr))
{
goto Exit;
}
// Generate the bytes of the document
ULONG indent = 4;
WS_XML_WRITER_PROPERTY properties[1];
properties[0].id = WS_XML_WRITER_PROPERTY_INDENT;
properties[0].value = &indent;
properties[0].valueSize = sizeof(indent);
hr = WsWriteXmlBufferToBytes(writer, buffer, NULL, properties, WsCountOf(properties), heap, &xml, &xmlLength, error);
if (FAILED(hr))
{
goto Exit;
}
printf("%.*s\n", xmlLength, (char*)xml);
Exit:
if (FAILED(hr))
{
// Print out the error
PrintError(hr, error);
}
if (writer != NULL)
{
WsFreeWriter(writer);
}
if (reader != NULL)
{
WsFreeReader(reader);
}
if (heap != NULL)
{
WsFreeHeap(heap);
}
if (error != NULL)
{
WsFreeError(error);
}
fflush(stdout);
return SUCCEEDED(hr) ? 0 : -1;
}