dlls/webservices/msg.c

   1 /*
   2  * Copyright 2016 Hans Leidekker for CodeWeavers
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 #include <stdarg.h>
  20
  21 #include "windef.h"
  22 #include "winbase.h"
  23 #include "winuser.h"
  24 #include "rpc.h"
  25 #include "webservices.h"
  26
  27 #include "wine/debug.h"
  28 #include "wine/list.h"
  29 #include "webservices_private.h"
  30
  31 WINE_DEFAULT_DEBUG_CHANNEL(webservices);
  32
  33 static const char ns_env_1_1[] = "http://schemas.xmlsoap.org/soap/envelope/";
  34 static const char ns_env_1_2[] = "http://www.w3.org/2003/05/soap-envelope";
  35 static const char ns_addr_0_9[] = "http://schemas.xmlsoap.org/ws/2004/08/addressing";
  36 static const char ns_addr_1_0[] = "http://www.w3.org/2005/08/addressing";
  37
  38 static const struct prop_desc msg_props[] =
  39 {
  40     { sizeof(WS_MESSAGE_STATE), TRUE },         /* WS_MESSAGE_PROPERTY_STATE */
  41     { sizeof(WS_HEAP *), TRUE },                /* WS_MESSAGE_PROPERTY_HEAP */
  42     { sizeof(WS_ENVELOPE_VERSION), TRUE },      /* WS_MESSAGE_PROPERTY_ENVELOPE_VERSION */
  43     { sizeof(WS_ADDRESSING_VERSION), TRUE },    /* WS_MESSAGE_PROPERTY_ADDRESSING_VERSION */
  44     { sizeof(WS_XML_BUFFER *), TRUE },          /* WS_MESSAGE_PROPERTY_HEADER_BUFFER */
  45     { sizeof(WS_XML_NODE_POSITION *), TRUE },   /* WS_MESSAGE_PROPERTY_HEADER_POSITION */
  46     { sizeof(WS_XML_READER *), TRUE },          /* WS_MESSAGE_PROPERTY_BODY_READER */
  47     { sizeof(WS_XML_WRITER *), TRUE },          /* WS_MESSAGE_PROPERTY_BODY_WRITER */
  48     { sizeof(BOOL), TRUE },                     /* WS_MESSAGE_PROPERTY_IS_ADDRESSED */
  49 };
  50
  51 struct msg
  52 {
  53     WS_MESSAGE_INITIALIZATION init;
  54     WS_MESSAGE_STATE          state;
  55     GUID                      id;
  56     WS_ENVELOPE_VERSION       version_env;
  57     WS_ADDRESSING_VERSION     version_addr;
  58     BOOL                      is_addressed;
  59     WS_STRING                 addr;
  60     WS_HEAP                  *heap;
  61     WS_XML_BUFFER            *buf;
  62     WS_XML_WRITER            *writer;
  63     WS_XML_WRITER            *writer_body;
  64     ULONG                     prop_count;
  65     struct prop               prop[sizeof(msg_props)/sizeof(msg_props[0])];
  66 };
  67
  68 static struct msg *alloc_msg(void)
  69 {
  70     static const ULONG count = sizeof(msg_props)/sizeof(msg_props[0]);
  71     struct msg *ret;
  72     ULONG size = sizeof(*ret) + prop_size( msg_props, count );
  73
  74     if (!(ret = heap_alloc_zero( size ))) return NULL;
  75     ret->state = WS_MESSAGE_STATE_EMPTY;
  76     prop_init( msg_props, count, ret->prop, &ret[1] );
  77     ret->prop_count = count;
  78     return ret;
  79 }
  80
  81 static void free_msg( struct msg *msg )
  82 {
  83     if (!msg) return;
  84     WsFreeWriter( msg->writer );
  85     WsFreeHeap( msg->heap );
  86     heap_free( msg->addr.chars );
  87     heap_free( msg );
  88 }
  89
  90 #define HEAP_MAX_SIZE (1 << 16)
  91
  92 static HRESULT create_msg( WS_ENVELOPE_VERSION env_version, WS_ADDRESSING_VERSION addr_version,
  93                            const WS_MESSAGE_PROPERTY *properties, ULONG count, WS_MESSAGE **handle )
  94 {
  95     struct msg *msg;
  96     HRESULT hr;
  97     ULONG i;
  98
  99     if (!(msg = alloc_msg())) return E_OUTOFMEMORY;
 100
 101     for (i = 0; i < count; i++)
 102     {
 103         if (properties[i].id == WS_MESSAGE_PROPERTY_ENVELOPE_VERSION ||
 104             properties[i].id == WS_MESSAGE_PROPERTY_ADDRESSING_VERSION)
 105         {
 106             free_msg( msg );
 107             return E_INVALIDARG;
 108         }
 109         hr = prop_set( msg->prop, msg->prop_count, properties[i].id, properties[i].value,
 110                        properties[i].valueSize );
 111         if (hr != S_OK)
 112         {
 113             free_msg( msg );
 114             return hr;
 115         }
 116     }
 117
 118     if ((hr = WsCreateHeap( HEAP_MAX_SIZE, 0, NULL, 0, &msg->heap, NULL )) != S_OK)
 119     {
 120         free_msg( msg );
 121         return hr;
 122     }
 123     if ((hr = WsCreateXmlBuffer( msg->heap, NULL, 0, &msg->buf, NULL )) != S_OK)
 124     {
 125         free_msg( msg );
 126         return hr;
 127     }
 128
 129     UuidCreate( &msg->id );
 130     msg->version_env  = env_version;
 131     msg->version_addr = addr_version;
 132
 133     *handle = (WS_MESSAGE *)msg;
 134     return S_OK;
 135 }
 136
 137 /**************************************************************************
 138  *          WsCreateMessage             [webservices.@]
 139  */
 140 HRESULT WINAPI WsCreateMessage( WS_ENVELOPE_VERSION env_version, WS_ADDRESSING_VERSION addr_version,
 141                                 const WS_MESSAGE_PROPERTY *properties, ULONG count, WS_MESSAGE **handle,
 142                                 WS_ERROR *error )
 143 {
 144     TRACE( "%u %u %p %u %p %p\n", env_version, addr_version, properties, count, handle, error );
 145     if (error) FIXME( "ignoring error parameter\n" );
 146
 147     if (!handle || !env_version || !addr_version) return E_INVALIDARG;
 148     return create_msg( env_version, addr_version, properties, count, handle );
 149 }
 150
 151 /**************************************************************************
 152  *          WsCreateMessageForChannel           [webservices.@]
 153  */
 154 HRESULT WINAPI WsCreateMessageForChannel( WS_CHANNEL *channel_handle, const WS_MESSAGE_PROPERTY *properties,
 155                                           ULONG count, WS_MESSAGE **handle, WS_ERROR *error )
 156 {
 157     WS_ENVELOPE_VERSION version_env;
 158     WS_ADDRESSING_VERSION version_addr;
 159     HRESULT hr;
 160
 161     TRACE( "%p %p %u %p %p\n", channel_handle, properties, count, handle, error );
 162     if (error) FIXME( "ignoring error parameter\n" );
 163
 164     if (!channel_handle || !handle) return E_INVALIDARG;
 165
 166     if ((hr = WsGetChannelProperty( channel_handle, WS_CHANNEL_PROPERTY_ENVELOPE_VERSION, &version_env,
 167                                     sizeof(version_env), NULL )) != S_OK || !version_env)
 168         version_env = WS_ENVELOPE_VERSION_SOAP_1_2;
 169
 170     if ((hr = WsGetChannelProperty( channel_handle, WS_CHANNEL_PROPERTY_ADDRESSING_VERSION, &version_addr,
 171                                     sizeof(version_addr), NULL )) != S_OK || !version_addr)
 172         version_addr = WS_ADDRESSING_VERSION_1_0;
 173
 174     return create_msg( version_env, version_addr, properties, count, handle );
 175 }
 176
 177 /**************************************************************************
 178  *          WsInitializeMessage         [webservices.@]
 179  */
 180 HRESULT WINAPI WsInitializeMessage( WS_MESSAGE *handle, WS_MESSAGE_INITIALIZATION init,
 181                                     WS_MESSAGE *src_handle, WS_ERROR *error )
 182 {
 183     struct msg *msg = (struct msg *)handle;
 184
 185     TRACE( "%p %u %p %p\n", handle, init, src_handle, error );
 186     if (error) FIXME( "ignoring error parameter\n" );
 187     if (src_handle)
 188     {
 189         FIXME( "src message not supported\n" );
 190         return E_NOTIMPL;
 191     }
 192
 193     if (!handle || init > WS_FAULT_MESSAGE) return E_INVALIDARG;
 194     if (msg->state >= WS_MESSAGE_STATE_INITIALIZED) return WS_E_INVALID_OPERATION;
 195
 196     msg->init  = init;
 197     msg->state = WS_MESSAGE_STATE_INITIALIZED;
 198     return S_OK;
 199 }
 200
 201 /**************************************************************************
 202  *          WsFreeMessage               [webservices.@]
 203  */
 204 void WINAPI WsFreeMessage( WS_MESSAGE *handle )
 205 {
 206     struct msg *msg = (struct msg *)handle;
 207
 208     TRACE( "%p\n", handle );
 209     free_msg( msg );
 210 }
 211
 212 /**************************************************************************
 213  *          WsGetMessageProperty                [webservices.@]
 214  */
 215 HRESULT WINAPI WsGetMessageProperty( WS_MESSAGE *handle, WS_MESSAGE_PROPERTY_ID id, void *buf,
 216                                      ULONG size, WS_ERROR *error )
 217 {
 218     struct msg *msg = (struct msg *)handle;
 219
 220     TRACE( "%p %u %p %u %p\n", handle, id, buf, size, error );
 221     if (error) FIXME( "ignoring error parameter\n" );
 222
 223     if (!handle) return E_INVALIDARG;
 224
 225     switch (id)
 226     {
 227     case WS_MESSAGE_PROPERTY_STATE:
 228         if (!buf || size != sizeof(msg->state)) return E_INVALIDARG;
 229         *(WS_MESSAGE_STATE *)buf = msg->state;
 230         return S_OK;
 231
 232     case WS_MESSAGE_PROPERTY_HEAP:
 233         if (!buf || size != sizeof(msg->heap)) return E_INVALIDARG;
 234         *(WS_HEAP **)buf = msg->heap;
 235         return S_OK;
 236
 237     case WS_MESSAGE_PROPERTY_ENVELOPE_VERSION:
 238         if (!buf || size != sizeof(msg->version_env)) return E_INVALIDARG;
 239         *(WS_ENVELOPE_VERSION *)buf = msg->version_env;
 240         return S_OK;
 241
 242     case WS_MESSAGE_PROPERTY_ADDRESSING_VERSION:
 243         if (!buf || size != sizeof(msg->version_addr)) return E_INVALIDARG;
 244         *(WS_ADDRESSING_VERSION *)buf = msg->version_addr;
 245         return S_OK;
 246
 247     case WS_MESSAGE_PROPERTY_HEADER_BUFFER:
 248         if (!buf || size != sizeof(msg->buf)) return E_INVALIDARG;
 249         *(WS_XML_BUFFER **)buf = msg->buf;
 250         return S_OK;
 251
 252     case WS_MESSAGE_PROPERTY_IS_ADDRESSED:
 253         if (msg->state < WS_MESSAGE_STATE_INITIALIZED) return WS_E_INVALID_OPERATION;
 254         *(BOOL *)buf = msg->is_addressed;
 255         return S_OK;
 256
 257     default:
 258         return prop_get( msg->prop, msg->prop_count, id, buf, size );
 259     }
 260 }
 261
 262 /**************************************************************************
 263  *          WsSetMessageProperty                [webservices.@]
 264  */
 265 HRESULT WINAPI WsSetMessageProperty( WS_MESSAGE *handle, WS_MESSAGE_PROPERTY_ID id, const void *value,
 266                                      ULONG size, WS_ERROR *error )
 267 {
 268     struct msg *msg = (struct msg *)handle;
 269
 270     TRACE( "%p %u %p %u\n", handle, id, value, size );
 271     if (error) FIXME( "ignoring error parameter\n" );
 272
 273     if (!handle) return E_INVALIDARG;
 274
 275     switch (id)
 276     {
 277     case WS_MESSAGE_PROPERTY_STATE:
 278     case WS_MESSAGE_PROPERTY_ENVELOPE_VERSION:
 279     case WS_MESSAGE_PROPERTY_ADDRESSING_VERSION:
 280     case WS_MESSAGE_PROPERTY_IS_ADDRESSED:
 281         if (msg->state < WS_MESSAGE_STATE_INITIALIZED) return WS_E_INVALID_OPERATION;
 282         return E_INVALIDARG;
 283
 284     default:
 285         break;
 286     }
 287     return prop_set( msg->prop, msg->prop_count, id, value, size );
 288 }
 289
 290 /**************************************************************************
 291  *          WsAddressMessage            [webservices.@]
 292  */
 293 HRESULT WINAPI WsAddressMessage( WS_MESSAGE *handle, const WS_ENDPOINT_ADDRESS *addr, WS_ERROR *error )
 294 {
 295     struct msg *msg = (struct msg *)handle;
 296
 297     TRACE( "%p %p %p\n", handle, addr, error );
 298     if (error) FIXME( "ignoring error parameter\n" );
 299     if (addr && (addr->headers || addr->extensions || addr->identity))
 300     {
 301         FIXME( "headers, extensions or identity not supported\n" );
 302         return E_NOTIMPL;
 303     }
 304
 305     if (!handle) return E_INVALIDARG;
 306     if (msg->state < WS_MESSAGE_STATE_INITIALIZED || msg->is_addressed) return WS_E_INVALID_OPERATION;
 307
 308     if (addr && addr->url.length)
 309     {
 310         if (!(msg->addr.chars = heap_alloc( addr->url.length * sizeof(WCHAR) ))) return E_OUTOFMEMORY;
 311         memcpy( msg->addr.chars, addr->url.chars, addr->url.length * sizeof(WCHAR) );
 312         msg->addr.length = addr->url.length;
 313     }
 314
 315     msg->is_addressed = TRUE;
 316     return S_OK;
 317 }
 318
 319 static HRESULT get_env_namespace( WS_ENVELOPE_VERSION ver, WS_XML_STRING *str )
 320 {
 321     switch (ver)
 322     {
 323     case WS_ENVELOPE_VERSION_SOAP_1_1:
 324         str->bytes  = (BYTE *)ns_env_1_1;
 325         str->length = sizeof(ns_env_1_1)/sizeof(ns_env_1_1[0]) - 1;
 326         return S_OK;
 327
 328     case WS_ENVELOPE_VERSION_SOAP_1_2:
 329         str->bytes  = (BYTE *)ns_env_1_2;
 330         str->length = sizeof(ns_env_1_2)/sizeof(ns_env_1_2[0]) - 1;
 331         return S_OK;
 332
 333     default:
 334         ERR( "unhandled envelope version %u\n", ver );
 335         return E_NOTIMPL;
 336     }
 337 }
 338
 339 static HRESULT get_addr_namespace( WS_ADDRESSING_VERSION ver, WS_XML_STRING *str )
 340 {
 341     switch (ver)
 342     {
 343     case WS_ADDRESSING_VERSION_0_9:
 344         str->bytes  = (BYTE *)ns_addr_0_9;
 345         str->length = sizeof(ns_addr_0_9)/sizeof(ns_addr_0_9[0]) - 1;
 346         return S_OK;
 347
 348     case WS_ADDRESSING_VERSION_1_0:
 349         str->bytes  = (BYTE *)ns_addr_1_0;
 350         str->length = sizeof(ns_addr_1_0)/sizeof(ns_addr_1_0[0]) - 1;
 351         return S_OK;
 352
 353     default:
 354         ERR( "unhandled adressing version %u\n", ver );
 355         return E_NOTIMPL;
 356     }
 357 }
 358
 359 static HRESULT write_envelope_start( struct msg *msg, WS_XML_WRITER *writer )
 360 {
 361     static const char anonymous[] = "http://schemas.xmlsoap.org/ws/2004/08/addressing/role/anonymous";
 362     WS_XML_STRING prefix_s = {1, (BYTE *)"s"}, prefix_a = {1, (BYTE *)"a"}, body = {4, (BYTE *)"Body"};
 363     WS_XML_STRING envelope = {8, (BYTE *)"Envelope"}, header = {6, (BYTE *)"Header"};
 364     WS_XML_STRING msgid = {9, (BYTE *)"MessageID"}, replyto = {7, (BYTE *)"ReplyTo"};
 365     WS_XML_STRING address = {7, (BYTE *)"Address"}, ns_env, ns_addr;
 366     WS_XML_UTF8_TEXT urn, addr;
 367     HRESULT hr;
 368
 369     if ((hr = get_env_namespace( msg->version_env, &ns_env )) != S_OK) return hr;
 370     if ((hr = get_addr_namespace( msg->version_addr, &ns_addr )) != S_OK) return hr;
 371
 372     if ((hr = WsWriteStartElement( writer, &prefix_s, &envelope, &ns_env, NULL )) != S_OK) return hr;
 373     if ((hr = WsWriteXmlnsAttribute( writer, &prefix_a, &ns_addr, FALSE, NULL )) != S_OK) return hr;
 374     if ((hr = WsWriteStartElement( writer, &prefix_s, &header, &ns_env, NULL )) != S_OK) return hr;
 375     if ((hr = WsWriteStartElement( writer, &prefix_a, &msgid, &ns_addr, NULL )) != S_OK) return hr;
 376
 377     urn.text.textType = WS_XML_TEXT_TYPE_UNIQUE_ID;
 378     memcpy( &urn.value, &msg->id, sizeof(msg->id) );
 379     if ((hr = WsWriteText( writer, &urn.text, NULL )) != S_OK) return hr;
 380
 381     if ((hr = WsWriteEndElement( writer, NULL )) != S_OK) return hr; /* </a:MessageID> */
 382     if (msg->version_addr == WS_ADDRESSING_VERSION_0_9)
 383     {
 384         if ((hr = WsWriteStartElement( writer, &prefix_a, &replyto, &ns_addr, NULL )) != S_OK) return hr;
 385         if ((hr = WsWriteStartElement( writer, &prefix_a, &address, &ns_addr, NULL )) != S_OK) return hr;
 386
 387         addr.text.textType = WS_XML_TEXT_TYPE_UTF8;
 388         addr.value.bytes   = (BYTE *)anonymous;
 389         addr.value.length  = sizeof(anonymous) - 1;
 390         if ((hr = WsWriteText( writer, &addr.text, NULL )) != S_OK) return hr;
 391         if ((hr = WsWriteEndElement( writer, NULL )) != S_OK) return hr; /* </a:Address> */
 392         if ((hr = WsWriteEndElement( writer, NULL )) != S_OK) return hr; /* </a:ReplyTo> */
 393     }
 394
 395     if ((hr = WsWriteEndElement( writer, NULL )) != S_OK) return hr; /* </s:Header> */
 396     return WsWriteStartElement( writer, &prefix_s, &body, &ns_env, NULL ); /* <s:Body> */
 397 }
 398
 399 static HRESULT write_envelope_end( struct msg *msg, WS_XML_WRITER *writer )
 400 {
 401     HRESULT hr;
 402     if ((hr = WsWriteEndElement( writer, NULL )) != S_OK) return hr; /* </s:Body> */
 403     return WsWriteEndElement( writer, NULL ); /* </s:Envelope> */
 404 }
 405
 406 /**************************************************************************
 407  *          WsWriteEnvelopeStart                [webservices.@]
 408  */
 409 HRESULT WINAPI WsWriteEnvelopeStart( WS_MESSAGE *handle, WS_XML_WRITER *writer,
 410                                      WS_MESSAGE_DONE_CALLBACK cb, void *state, WS_ERROR *error )
 411 {
 412     struct msg *msg = (struct msg *)handle;
 413     HRESULT hr;
 414
 415     TRACE( "%p %p %p %p %p\n", handle, writer, cb, state, error );
 416     if (error) FIXME( "ignoring error parameter\n" );
 417     if (cb)
 418     {
 419         FIXME( "callback not supported\n" );
 420         return E_NOTIMPL;
 421     }
 422
 423     if (!handle) return E_INVALIDARG;
 424     if (msg->state != WS_MESSAGE_STATE_INITIALIZED) return WS_E_INVALID_OPERATION;
 425
 426     if ((hr = WsCreateWriter( NULL, 0, &msg->writer, NULL )) != S_OK) return hr;
 427     if ((hr = WsSetOutputToBuffer( msg->writer, msg->buf, NULL, 0, NULL )) != S_OK) return hr;
 428     if ((hr = write_envelope_start( msg, msg->writer )) != S_OK) return hr;
 429     if ((hr = write_envelope_start( msg, writer )) != S_OK) return hr;
 430     if ((hr = write_envelope_end( msg, msg->writer )) != S_OK) return hr;
 431
 432     msg->writer_body = writer;
 433     msg->state       = WS_MESSAGE_STATE_WRITING;
 434     return S_OK;
 435 }
 436
 437 /**************************************************************************
 438  *          WsWriteEnvelopeEnd          [webservices.@]
 439  */
 440 HRESULT WINAPI WsWriteEnvelopeEnd( WS_MESSAGE *handle, WS_ERROR *error )
 441 {
 442     struct msg *msg = (struct msg *)handle;
 443     HRESULT hr;
 444
 445     TRACE( "%p %p\n", handle, error );
 446     if (error) FIXME( "ignoring error parameter\n" );
 447
 448     if (!handle) return E_INVALIDARG;
 449     if (msg->state != WS_MESSAGE_STATE_WRITING) return WS_E_INVALID_OPERATION;
 450
 451     if ((hr = write_envelope_end( msg, msg->writer_body )) != S_OK) return hr;
 452
 453     msg->state = WS_MESSAGE_STATE_DONE;
 454     return S_OK;
 455 }
 456
 457 /**************************************************************************
 458  *          WsWriteBody         [webservices.@]
 459  */
 460 HRESULT WINAPI WsWriteBody( WS_MESSAGE *handle, const WS_ELEMENT_DESCRIPTION *desc, WS_WRITE_OPTION option,
 461                             const void *value, ULONG size, WS_ERROR *error )
 462 {
 463     struct msg *msg = (struct msg *)handle;
 464     HRESULT hr;
 465
 466     TRACE( "%p %p %08x %p %u %p\n", handle, desc, option, value, size, error );
 467     if (error) FIXME( "ignoring error parameter\n" );
 468
 469     if (!handle || !desc) return E_INVALIDARG;
 470     if (msg->state != WS_MESSAGE_STATE_WRITING) return WS_E_INVALID_OPERATION;
 471
 472     if (desc->elementLocalName &&
 473         (hr = WsWriteStartElement( msg->writer_body, NULL, desc->elementLocalName, desc->elementNs,
 474                                    NULL )) != S_OK) return hr;
 475
 476     if ((hr = WsWriteType( msg->writer_body, WS_ANY_ELEMENT_TYPE_MAPPING, desc->type, desc->typeDescription,
 477                            option, value, size, NULL )) != S_OK) return hr;
 478
 479     if (desc->elementLocalName) hr = WsWriteEndElement( msg->writer_body, NULL );
 480     return hr;
 481 }