dlls/wsdapi/soap.c

   1 /*
   2  * Web Services on Devices
   3  *
   4  * Copyright 2017-2018 Owen Rudge for CodeWeavers
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include <stdarg.h>
  22 #include <limits.h>
  23
  24 #define COBJMACROS
  25
  26 #include "wsdapi_internal.h"
  27 #include "wine/debug.h"
  28 #include "wine/heap.h"
  29 #include "webservices.h"
  30
  31 WINE_DEFAULT_DEBUG_CHANNEL(wsdapi);
  32
  33 #define APP_MAX_DELAY                       500
  34
  35 static const WCHAR *discoveryTo = L"urn:schemas-xmlsoap-org:ws:2005:04:discovery";
  36
  37 static const WCHAR *actionProbe = L"http://schemas.xmlsoap.org/ws/2005/04/discovery/Probe";
  38
  39 static const WCHAR *addressingNsUri = L"http://schemas.xmlsoap.org/ws/2004/08/addressing";
  40 static const WCHAR *discoveryNsUri = L"http://schemas.xmlsoap.org/ws/2005/04/discovery";
  41 static const WCHAR *envelopeNsUri = L"http://www.w3.org/2003/05/soap-envelope";
  42
  43 static const WCHAR *addressingPrefix = L"wsa";
  44 static const WCHAR *discoveryPrefix = L"wsd";
  45 static const WCHAR *envelopePrefix = L"soap";
  46 static const WCHAR *headerString = L"Header";
  47 static const WCHAR *actionString = L"Action";
  48 static const WCHAR *messageIdString = L"MessageID";
  49 static const WCHAR *toString = L"To";
  50 static const WCHAR *relatesToString = L"RelatesTo";
  51 static const WCHAR *appSequenceString = L"AppSequence";
  52 static const WCHAR *instanceIdString = L"InstanceId";
  53 static const WCHAR *messageNumberString = L"MessageNumber";
  54 static const WCHAR *sequenceIdString = L"SequenceId";
  55 static const WCHAR *bodyString = L"Body";
  56 static const WCHAR *helloString = L"Hello";
  57 static const WCHAR *probeString = L"Probe";
  58 static const WCHAR *probeMatchString = L"ProbeMatch";
  59 static const WCHAR *probeMatchesString = L"ProbeMatches";
  60 static const WCHAR *byeString = L"Bye";
  61 static const WCHAR *endpointReferenceString = L"EndpointReference";
  62 static const WCHAR *addressString = L"Address";
  63 static const WCHAR *referenceParametersString = L"ReferenceParameters";
  64 static const WCHAR *typesString = L"Types";
  65 static const WCHAR *scopesString = L"Scopes";
  66 static const WCHAR *xAddrsString = L"XAddrs";
  67 static const WCHAR *metadataVersionString = L"MetadataVersion";
  68
  69 struct discovered_namespace
  70 {
  71     struct list entry;
  72     LPCWSTR prefix;
  73     LPCWSTR uri;
  74 };
  75
  76 static LPWSTR utf8_to_wide(void *parent, const char *utf8_str, int length)
  77 {
  78     int utf8_str_len = 0, chars_needed = 0, bytes_needed = 0;
  79     LPWSTR new_str = NULL;
  80
  81     if (utf8_str == NULL) return NULL;
  82
  83     utf8_str_len = (length < 0) ? lstrlenA(utf8_str) : length;
  84     chars_needed = MultiByteToWideChar(CP_UTF8, 0, utf8_str, utf8_str_len, NULL, 0);
  85
  86     if (chars_needed <= 0) return NULL;
  87
  88     bytes_needed = sizeof(WCHAR) * (chars_needed + 1);
  89     new_str = WSDAllocateLinkedMemory(parent, bytes_needed);
  90
  91     MultiByteToWideChar(CP_UTF8, 0, utf8_str, utf8_str_len, new_str, chars_needed);
  92     new_str[chars_needed] = 0;
  93
  94     return new_str;
  95 }
  96
  97 static char *wide_to_utf8(LPCWSTR wide_string, int *length)
  98 {
  99     char *new_string = NULL;
 100
 101     if (wide_string == NULL)
 102         return NULL;
 103
 104     *length = WideCharToMultiByte(CP_UTF8, 0, wide_string, -1, NULL, 0, NULL, NULL);
 105
 106     if (*length < 0)
 107         return NULL;
 108
 109     new_string = heap_alloc(*length);
 110     WideCharToMultiByte(CP_UTF8, 0, wide_string, -1, new_string, *length, NULL, NULL);
 111
 112     return new_string;
 113 }
 114
 115 static WS_XML_STRING *populate_xml_string(LPCWSTR str)
 116 {
 117     WS_XML_STRING *xml = heap_alloc_zero(sizeof(WS_XML_STRING));
 118     int utf8Length;
 119
 120     if (xml == NULL)
 121         return NULL;
 122
 123     xml->bytes = (BYTE *)wide_to_utf8(str, &utf8Length);
 124
 125     if (xml->bytes == NULL)
 126     {
 127         heap_free(xml);
 128         return NULL;
 129     }
 130
 131     xml->dictionary = NULL;
 132     xml->id = 0;
 133     xml->length = (xml->bytes == NULL) ? 0 : (utf8Length - 1);
 134
 135     return xml;
 136 }
 137
 138 static inline void free_xml_string(WS_XML_STRING *value)
 139 {
 140     if (value == NULL)
 141         return;
 142
 143     heap_free(value->bytes);
 144
 145     heap_free(value);
 146 }
 147
 148 static HRESULT write_xml_attribute(WSDXML_ATTRIBUTE *attribute, WS_XML_WRITER *writer)
 149 {
 150     WS_XML_STRING *local_name = NULL, *element_ns = NULL, *ns_prefix = NULL;
 151     WS_XML_UTF16_TEXT utf16_text;
 152     HRESULT ret = E_OUTOFMEMORY;
 153     int text_len;
 154
 155     if (attribute == NULL)
 156         return S_OK;
 157
 158     /* Start the attribute */
 159     local_name = populate_xml_string(attribute->Name->LocalName);
 160     if (local_name == NULL) goto cleanup;
 161
 162     if (attribute->Name->Space == NULL)
 163     {
 164         element_ns = populate_xml_string(L"");
 165         if (element_ns == NULL) goto cleanup;
 166
 167         ns_prefix = NULL;
 168     }
 169     else
 170     {
 171         element_ns = populate_xml_string(attribute->Name->Space->Uri);
 172         if (element_ns == NULL) goto cleanup;
 173
 174         ns_prefix = populate_xml_string(attribute->Name->Space->PreferredPrefix);
 175         if (ns_prefix == NULL) goto cleanup;
 176     }
 177
 178     ret = WsWriteStartAttribute(writer, ns_prefix, local_name, element_ns, FALSE, NULL);
 179     if (FAILED(ret)) goto cleanup;
 180
 181     text_len = lstrlenW(attribute->Value);
 182
 183     utf16_text.text.textType = WS_XML_TEXT_TYPE_UTF16;
 184     utf16_text.bytes = (BYTE *)attribute->Value;
 185     utf16_text.byteCount = min(WSD_MAX_TEXT_LENGTH, text_len) * sizeof(WCHAR);
 186
 187     ret = WsWriteText(writer, (WS_XML_TEXT *)&utf16_text, NULL);
 188     if (FAILED(ret)) goto cleanup;
 189
 190     ret = WsWriteEndAttribute(writer, NULL);
 191     if (FAILED(ret)) goto cleanup;
 192
 193 cleanup:
 194     free_xml_string(local_name);
 195     free_xml_string(element_ns);
 196     free_xml_string(ns_prefix);
 197
 198     return ret;
 199 }
 200
 201 static HRESULT write_xml_element(WSDXML_ELEMENT *element, WS_XML_WRITER *writer)
 202 {
 203     WS_XML_STRING *local_name = NULL, *element_ns = NULL, *ns_prefix = NULL;
 204     WSDXML_ATTRIBUTE *current_attribute;
 205     WS_XML_UTF16_TEXT utf16_text;
 206     WSDXML_NODE *current_child;
 207     WSDXML_TEXT *node_as_text;
 208     int text_len;
 209     HRESULT ret = E_OUTOFMEMORY;
 210
 211     if (element == NULL)
 212         return S_OK;
 213
 214     /* Start the element */
 215     local_name = populate_xml_string(element->Name->LocalName);
 216     if (local_name == NULL) goto cleanup;
 217
 218     element_ns = populate_xml_string(element->Name->Space->Uri);
 219     if (element_ns == NULL) goto cleanup;
 220
 221     ns_prefix = populate_xml_string(element->Name->Space->PreferredPrefix);
 222     if (ns_prefix == NULL) goto cleanup;
 223
 224     ret = WsWriteStartElement(writer, ns_prefix, local_name, element_ns, NULL);
 225     if (FAILED(ret)) goto cleanup;
 226
 227     /* Write attributes */
 228     current_attribute = element->FirstAttribute;
 229
 230     while (current_attribute != NULL)
 231     {
 232         ret = write_xml_attribute(current_attribute, writer);
 233         if (FAILED(ret)) goto cleanup;
 234         current_attribute = current_attribute->Next;
 235     }
 236
 237     /* Write child elements */
 238     current_child = element->FirstChild;
 239
 240     while (current_child != NULL)
 241     {
 242         if (current_child->Type == ElementType)
 243         {
 244             ret = write_xml_element((WSDXML_ELEMENT *)current_child, writer);
 245             if (FAILED(ret)) goto cleanup;
 246         }
 247         else if (current_child->Type == TextType)
 248         {
 249             node_as_text = (WSDXML_TEXT *)current_child;
 250             text_len = lstrlenW(node_as_text->Text);
 251
 252             utf16_text.text.textType = WS_XML_TEXT_TYPE_UTF16;
 253             utf16_text.byteCount = min(WSD_MAX_TEXT_LENGTH, text_len) * sizeof(WCHAR);
 254             utf16_text.bytes = (BYTE *)node_as_text->Text;
 255
 256             ret = WsWriteText(writer, (WS_XML_TEXT *)&utf16_text, NULL);
 257             if (FAILED(ret)) goto cleanup;
 258         }
 259
 260         current_child = current_child->Next;
 261     }
 262
 263     /* End the element */
 264     ret = WsWriteEndElement(writer, NULL);
 265
 266 cleanup:
 267     free_xml_string(local_name);
 268     free_xml_string(element_ns);
 269     free_xml_string(ns_prefix);
 270
 271     return ret;
 272 }
 273
 274 static HRESULT add_child_element(IWSDXMLContext *xml_context, WSDXML_ELEMENT *parent, LPCWSTR ns_uri,
 275     LPCWSTR name, LPCWSTR text, WSDXML_ELEMENT **out)
 276 {
 277     WSDXML_ELEMENT *element_obj;
 278     WSDXML_NAME *name_obj;
 279     HRESULT ret;
 280
 281     ret = IWSDXMLContext_AddNameToNamespace(xml_context, ns_uri, name, &name_obj);
 282     if (FAILED(ret)) return ret;
 283
 284     ret = WSDXMLBuildAnyForSingleElement(name_obj, text, &element_obj);
 285     WSDFreeLinkedMemory(name_obj);
 286
 287     if (FAILED(ret)) return ret;
 288
 289     /* Add the element as a child - this will link the element's memory allocation to the parent's */
 290     ret = WSDXMLAddChild(parent, element_obj);
 291
 292     if (FAILED(ret))
 293     {
 294         WSDFreeLinkedMemory(element_obj);
 295         return ret;
 296     }
 297
 298     if (out != NULL) *out = element_obj;
 299     return ret;
 300 }
 301
 302 HRESULT register_namespaces(IWSDXMLContext *xml_context)
 303 {
 304     HRESULT ret;
 305
 306     ret = IWSDXMLContext_AddNamespace(xml_context, addressingNsUri, addressingPrefix, NULL);
 307     if (FAILED(ret)) return ret;
 308
 309     ret = IWSDXMLContext_AddNamespace(xml_context, discoveryNsUri, discoveryPrefix, NULL);
 310     if (FAILED(ret)) return ret;
 311
 312     return IWSDXMLContext_AddNamespace(xml_context, envelopeNsUri, envelopePrefix, NULL);
 313 }
 314
 315 static BOOL create_guid(LPWSTR buffer)
 316 {
 317     WCHAR* uuidString = NULL;
 318     UUID uuid;
 319
 320     if (UuidCreate(&uuid) != RPC_S_OK)
 321         return FALSE;
 322
 323     UuidToStringW(&uuid, (RPC_WSTR*)&uuidString);
 324
 325     if (uuidString == NULL)
 326         return FALSE;
 327
 328     wsprintfW(buffer, L"urn:uuid:%s", uuidString);
 329     RpcStringFreeW((RPC_WSTR*)&uuidString);
 330
 331     return TRUE;
 332 }
 333
 334 static void populate_soap_header(WSD_SOAP_HEADER *header, LPCWSTR to, LPCWSTR action, LPCWSTR message_id,
 335     WSD_APP_SEQUENCE *sequence, const WSDXML_ELEMENT *any_headers)
 336 {
 337     ZeroMemory(header, sizeof(WSD_SOAP_HEADER));
 338
 339     header->To = to;
 340     header->Action = action;
 341     header->MessageID = message_id;
 342     header->AppSequence = sequence;
 343     header->AnyHeaders = (WSDXML_ELEMENT *)any_headers;
 344
 345     /* TODO: Implement RelatesTo, ReplyTo, From, FaultTo */
 346 }
 347
 348 #define MAX_ULONGLONG_STRING_SIZE    25
 349
 350 static LPWSTR ulonglong_to_string(void *parent, ULONGLONG value)
 351 {
 352     LPWSTR ret;
 353
 354     ret = WSDAllocateLinkedMemory(parent, MAX_ULONGLONG_STRING_SIZE * sizeof(WCHAR));
 355
 356     if (ret == NULL)
 357         return NULL;
 358
 359     wsprintfW(ret, L"%I64u", value);
 360     return ret;
 361 }
 362
 363 static WSDXML_ATTRIBUTE *add_attribute(IWSDXMLContext *xml_context, WSDXML_ELEMENT *parent, LPCWSTR ns_uri, LPCWSTR name)
 364 {
 365     WSDXML_ATTRIBUTE *attribute, *cur_attrib;
 366     WSDXML_NAME *name_obj = NULL;
 367
 368     if (ns_uri == NULL)
 369     {
 370         name_obj = WSDAllocateLinkedMemory(NULL, sizeof(WSDXML_NAME));
 371         name_obj->LocalName = duplicate_string(name_obj, name);
 372         name_obj->Space = NULL;
 373     }
 374     else
 375     {
 376         if (FAILED(IWSDXMLContext_AddNameToNamespace(xml_context, ns_uri, name, &name_obj)))
 377             return NULL;
 378     }
 379
 380     attribute = WSDAllocateLinkedMemory(parent, sizeof(WSDXML_ATTRIBUTE));
 381
 382     if (attribute == NULL)
 383     {
 384         WSDFreeLinkedMemory(name_obj);
 385         return NULL;
 386     }
 387
 388     attribute->Element = parent;
 389     attribute->Name = name_obj;
 390     attribute->Next = NULL;
 391     attribute->Value = NULL;
 392
 393     if (name_obj != NULL)
 394         WSDAttachLinkedMemory(attribute, name_obj);
 395
 396     if (parent->FirstAttribute == NULL)
 397     {
 398         /* Make this the first attribute of the parent */
 399         parent->FirstAttribute = attribute;
 400     }
 401     else
 402     {
 403         /* Find the last attribute and add this as the next one */
 404         cur_attrib = parent->FirstAttribute;
 405
 406         while (cur_attrib->Next != NULL)
 407         {
 408             cur_attrib = cur_attrib->Next;
 409         }
 410
 411         cur_attrib->Next = attribute;
 412     }
 413
 414     return attribute;
 415 }
 416
 417 static void remove_attribute(WSDXML_ELEMENT *parent, WSDXML_ATTRIBUTE *attribute)
 418 {
 419     WSDXML_ATTRIBUTE *cur_attrib;
 420
 421     /* Find the last attribute and add this as the next one */
 422     cur_attrib = parent->FirstAttribute;
 423
 424     if (cur_attrib == attribute)
 425         parent->FirstAttribute = cur_attrib->Next;
 426     else
 427     {
 428         while (cur_attrib != NULL)
 429         {
 430             /* Is our attribute the next attribute? */
 431             if (cur_attrib->Next == attribute)
 432             {
 433                 /* Remove it from the list */
 434                 cur_attrib->Next = attribute->Next;
 435                 break;
 436             }
 437
 438             cur_attrib = cur_attrib->Next;
 439         }
 440     }
 441
 442     WSDFreeLinkedMemory(attribute);
 443 }
 444
 445 static HRESULT add_ulonglong_attribute(IWSDXMLContext *xml_context, WSDXML_ELEMENT *parent, LPCWSTR ns_uri, LPCWSTR name,
 446     ULONGLONG value)
 447 {
 448     WSDXML_ATTRIBUTE *attribute = add_attribute(xml_context, parent, ns_uri, name);
 449
 450     if (attribute == NULL)
 451         return E_FAIL;
 452
 453     attribute->Value = ulonglong_to_string(attribute, value);
 454
 455     if (attribute->Value == NULL)
 456     {
 457         remove_attribute(parent, attribute);
 458         return E_FAIL;
 459     }
 460
 461     return S_OK;
 462 }
 463
 464 static HRESULT add_string_attribute(IWSDXMLContext *xml_context, WSDXML_ELEMENT *parent, LPCWSTR ns_uri, LPCWSTR name,
 465     LPCWSTR value)
 466 {
 467     WSDXML_ATTRIBUTE *attribute = add_attribute(xml_context, parent, ns_uri, name);
 468
 469     if (attribute == NULL)
 470         return E_FAIL;
 471
 472     attribute->Value = duplicate_string(attribute, value);
 473
 474     if (attribute->Value == NULL)
 475     {
 476         remove_attribute(parent, attribute);
 477         return E_FAIL;
 478     }
 479
 480     return S_OK;
 481 }
 482
 483 static BOOL add_discovered_namespace(struct list *namespaces, WSDXML_NAMESPACE *discovered_ns)
 484 {
 485     struct discovered_namespace *ns;
 486
 487     LIST_FOR_EACH_ENTRY(ns, namespaces, struct discovered_namespace, entry)
 488     {
 489         if (lstrcmpW(ns->uri, discovered_ns->Uri) == 0)
 490             return TRUE; /* Already added */
 491     }
 492
 493     ns = WSDAllocateLinkedMemory(namespaces, sizeof(struct discovered_namespace));
 494
 495     if (ns == NULL)
 496         return FALSE;
 497
 498     ns->prefix = duplicate_string(ns, discovered_ns->PreferredPrefix);
 499     ns->uri = duplicate_string(ns, discovered_ns->Uri);
 500
 501     if ((ns->prefix == NULL) || (ns->uri == NULL))
 502         return FALSE;
 503
 504     list_add_tail(namespaces, &ns->entry);
 505     return TRUE;
 506 }
 507
 508 static HRESULT build_types_list(LPWSTR buffer, size_t buffer_size, const WSD_NAME_LIST *list, struct list *namespaces)
 509 {
 510     LPWSTR current_buf_pos = buffer;
 511     size_t memory_needed = 0;
 512     const WSD_NAME_LIST *cur = list;
 513
 514     do
 515     {
 516         /* Calculate space needed, including NULL character, colon and potential trailing space */
 517         memory_needed = sizeof(WCHAR) * (lstrlenW(cur->Element->LocalName) +
 518             lstrlenW(cur->Element->Space->PreferredPrefix) + 3);
 519
 520         if (current_buf_pos + memory_needed > buffer + buffer_size)
 521             return E_INVALIDARG;
 522
 523         if (cur != list)
 524             *current_buf_pos++ = ' ';
 525
 526         current_buf_pos += wsprintfW(current_buf_pos, L"%s:%s", cur->Element->Space->PreferredPrefix,
 527             cur->Element->LocalName);
 528
 529         /* Record the namespace in the discovered namespaces list */
 530         if (!add_discovered_namespace(namespaces, cur->Element->Space))
 531             return E_FAIL;
 532
 533         cur = cur->Next;
 534     } while (cur != NULL);
 535
 536     return S_OK;
 537 }
 538
 539 static HRESULT build_uri_list(LPWSTR buffer, size_t buffer_size, const WSD_URI_LIST *list)
 540 {
 541     size_t memory_needed = 0, string_len = 0;
 542     const WSD_URI_LIST *cur = list;
 543     LPWSTR cur_buf_pos = buffer;
 544
 545     do
 546     {
 547         /* Calculate space needed, including trailing space */
 548         string_len = lstrlenW(cur->Element);
 549         memory_needed = (string_len + 1) * sizeof(WCHAR);
 550
 551         if (cur_buf_pos + memory_needed > buffer + buffer_size)
 552             return E_INVALIDARG;
 553
 554         if (cur != list)
 555             *cur_buf_pos++ = ' ';
 556
 557         memcpy(cur_buf_pos, cur->Element, memory_needed);
 558         cur_buf_pos += string_len;
 559
 560         cur = cur->Next;
 561     } while (cur != NULL);
 562
 563     return S_OK;
 564 }
 565
 566 static HRESULT duplicate_element(WSDXML_ELEMENT *parent, const WSDXML_ELEMENT *node, struct list *namespaces)
 567 {
 568     WSDXML_ATTRIBUTE *cur_attribute, *new_attribute, *last_attribute = NULL;
 569     WSDXML_ELEMENT *new_element;
 570     WSDXML_TEXT *text_node;
 571     WSDXML_NODE *cur_node;
 572     HRESULT ret;
 573
 574     /* First record the namespace in the discovered namespaces list */
 575     if (!add_discovered_namespace(namespaces, node->Name->Space))
 576         return E_FAIL;
 577
 578     ret = WSDXMLBuildAnyForSingleElement(node->Name, NULL, &new_element);
 579     if (FAILED(ret)) return ret;
 580
 581     /* Duplicate the nodes */
 582     cur_node = node->FirstChild;
 583
 584     while (cur_node != NULL)
 585     {
 586         if (cur_node->Type == ElementType)
 587         {
 588             ret = duplicate_element(new_element, (WSDXML_ELEMENT *)cur_node, namespaces);
 589             if (FAILED(ret)) goto cleanup;
 590         }
 591         else if (cur_node->Type == TextType)
 592         {
 593             text_node = WSDAllocateLinkedMemory(new_element, sizeof(WSDXML_TEXT));
 594             if (text_node == NULL) goto failed;
 595
 596             text_node->Node.Parent = NULL;
 597             text_node->Node.Next = NULL;
 598             text_node->Node.Type = TextType;
 599             text_node->Text = duplicate_string(text_node, ((WSDXML_TEXT *)cur_node)->Text);
 600
 601             if (text_node->Text == NULL) goto failed;
 602
 603             ret = WSDXMLAddChild(new_element, (WSDXML_ELEMENT *)text_node);
 604             if (FAILED(ret)) goto cleanup;
 605         }
 606
 607         cur_node = cur_node->Next;
 608     }
 609
 610     /* Duplicate the attributes */
 611     cur_attribute = node->FirstAttribute;
 612
 613     while (cur_attribute != NULL)
 614     {
 615         if ((cur_attribute->Name->Space != NULL) && (!add_discovered_namespace(namespaces, cur_attribute->Name->Space)))
 616             goto failed;
 617
 618         new_attribute = WSDAllocateLinkedMemory(new_element, sizeof(WSDXML_ATTRIBUTE));
 619         if (new_attribute == NULL) goto failed;
 620
 621         new_attribute->Element = new_element;
 622         new_attribute->Name = duplicate_name(new_attribute, cur_attribute->Name);
 623         new_attribute->Value = duplicate_string(new_attribute, cur_attribute->Value);
 624         new_attribute->Next = NULL;
 625
 626         if ((new_attribute->Name == NULL) || (new_attribute->Value == NULL)) goto failed;
 627
 628         if (last_attribute == NULL)
 629             new_element->FirstAttribute = new_attribute;
 630         else
 631             last_attribute->Next = new_attribute;
 632
 633         last_attribute = new_attribute;
 634         cur_attribute = cur_attribute->Next;
 635     }
 636
 637     ret = WSDXMLAddChild(parent, new_element);
 638     if (FAILED(ret)) goto cleanup;
 639
 640     return ret;
 641
 642 failed:
 643     ret = E_FAIL;
 644
 645 cleanup:
 646     WSDXMLCleanupElement(new_element);
 647     return ret;
 648 }
 649
 650 static HRESULT create_soap_header_xml_elements(IWSDXMLContext *xml_context, WSD_SOAP_HEADER *header,
 651     struct list *discovered_namespaces, WSDXML_ELEMENT **out_element)
 652 {
 653     WSDXML_ELEMENT *header_element = NULL, *app_sequence_element = NULL, *temp_element;
 654     WSDXML_NAME *header_name = NULL;
 655     HRESULT ret;
 656
 657     /* <s:Header> */
 658     ret = IWSDXMLContext_AddNameToNamespace(xml_context, envelopeNsUri, headerString, &header_name);
 659     if (FAILED(ret)) goto cleanup;
 660
 661     ret = WSDXMLBuildAnyForSingleElement(header_name, NULL, &header_element);
 662     if (FAILED(ret)) goto cleanup;
 663
 664     WSDFreeLinkedMemory(header_name);
 665
 666     /* <a:Action> */
 667     ret = add_child_element(xml_context, header_element, addressingNsUri, actionString, header->Action, &temp_element);
 668     if (FAILED(ret)) goto cleanup;
 669
 670     /* <a:MessageId> */
 671     ret = add_child_element(xml_context, header_element, addressingNsUri, messageIdString, header->MessageID, &temp_element);
 672     if (FAILED(ret)) goto cleanup;
 673
 674     /* <a:To> */
 675     ret = add_child_element(xml_context, header_element, addressingNsUri, toString, header->To, &temp_element);
 676     if (FAILED(ret)) goto cleanup;
 677
 678     /* <a:RelatesTo> */
 679     if (header->RelatesTo.MessageID != NULL)
 680     {
 681         ret = add_child_element(xml_context, header_element, addressingNsUri, relatesToString,
 682             header->RelatesTo.MessageID, &temp_element);
 683         if (FAILED(ret)) goto cleanup;
 684     }
 685
 686     /* <d:AppSequence> */
 687     ret = add_child_element(xml_context, header_element, discoveryNsUri, appSequenceString, L"", &app_sequence_element);
 688     if (FAILED(ret)) goto cleanup;
 689
 690     /* InstanceId attribute */
 691     ret = add_ulonglong_attribute(xml_context, app_sequence_element, NULL, instanceIdString, min(UINT_MAX,
 692         header->AppSequence->InstanceId));
 693     if (FAILED(ret)) goto cleanup;
 694
 695     /* SequenceID attribute */
 696     if (header->AppSequence->SequenceId != NULL)
 697     {
 698         ret = add_string_attribute(xml_context, app_sequence_element, NULL, sequenceIdString, header->AppSequence->SequenceId);
 699         if (FAILED(ret)) goto cleanup;
 700     }
 701
 702     /* MessageNumber attribute */
 703     ret = add_ulonglong_attribute(xml_context, app_sequence_element, NULL, messageNumberString, min(UINT_MAX,
 704         header->AppSequence->MessageNumber));
 705     if (FAILED(ret)) goto cleanup;
 706
 707     /* </d:AppSequence> */
 708
 709     /* Write any headers */
 710     if (header->AnyHeaders != NULL)
 711     {
 712         ret = duplicate_element(header_element, header->AnyHeaders, discovered_namespaces);
 713         if (FAILED(ret)) goto cleanup;
 714     }
 715
 716     /* </s:Header> */
 717
 718     *out_element = header_element;
 719     return ret;
 720
 721 cleanup:
 722     if (header_name != NULL) WSDFreeLinkedMemory(header_name);
 723     WSDXMLCleanupElement(header_element);
 724
 725     return ret;
 726 }
 727
 728 static HRESULT create_soap_envelope(IWSDXMLContext *xml_context, WSD_SOAP_HEADER *header, WSDXML_ELEMENT *body_element,
 729     WS_HEAP **heap, char **output_xml, ULONG *xml_length, struct list *discovered_namespaces)
 730 {
 731     WS_XML_STRING *actual_envelope_prefix = NULL, *envelope_uri_xmlstr = NULL, *tmp_prefix = NULL, *tmp_uri = NULL;
 732     WSDXML_NAMESPACE *addressing_ns = NULL, *discovery_ns = NULL, *envelope_ns = NULL;
 733     WSDXML_ELEMENT *header_element = NULL;
 734     struct discovered_namespace *ns;
 735     WS_XML_BUFFER *buffer = NULL;
 736     WS_XML_WRITER *writer = NULL;
 737     WS_XML_STRING envelope;
 738     HRESULT ret = E_OUTOFMEMORY;
 739     static BYTE envelopeString[] = "Envelope";
 740
 741     /* Create the necessary XML prefixes */
 742     if (FAILED(IWSDXMLContext_AddNamespace(xml_context, addressingNsUri, addressingPrefix, &addressing_ns))) goto cleanup;
 743     if (!add_discovered_namespace(discovered_namespaces, addressing_ns)) goto cleanup;
 744
 745     if (FAILED(IWSDXMLContext_AddNamespace(xml_context, discoveryNsUri, discoveryPrefix, &discovery_ns))) goto cleanup;
 746     if (!add_discovered_namespace(discovered_namespaces, discovery_ns)) goto cleanup;
 747
 748     if (FAILED(IWSDXMLContext_AddNamespace(xml_context, envelopeNsUri, envelopePrefix, &envelope_ns))) goto cleanup;
 749     if (!add_discovered_namespace(discovered_namespaces, envelope_ns)) goto cleanup;
 750
 751     envelope.bytes = envelopeString;
 752     envelope.length = sizeof(envelopeString) - 1;
 753     envelope.dictionary = NULL;
 754     envelope.id = 0;
 755
 756     actual_envelope_prefix = populate_xml_string(envelope_ns->PreferredPrefix);
 757     envelope_uri_xmlstr = populate_xml_string(envelope_ns->Uri);
 758
 759     if ((actual_envelope_prefix == NULL) || (envelope_uri_xmlstr == NULL)) goto cleanup;
 760
 761     /* Now try to create the appropriate WebServices buffers, etc */
 762     ret = WsCreateHeap(16384, 4096, NULL, 0, heap, NULL);
 763     if (FAILED(ret)) goto cleanup;
 764
 765     ret = WsCreateXmlBuffer(*heap, NULL, 0, &buffer, NULL);
 766     if (FAILED(ret)) goto cleanup;
 767
 768     ret = WsCreateWriter(NULL, 0, &writer, NULL);
 769     if (FAILED(ret)) goto cleanup;
 770
 771     ret = WsSetOutputToBuffer(writer, buffer, NULL, 0, NULL);
 772     if (FAILED(ret)) goto cleanup;
 773
 774     /* Create the header XML elements */
 775     ret = create_soap_header_xml_elements(xml_context, header, discovered_namespaces, &header_element);
 776     if (FAILED(ret)) goto cleanup;
 777
 778     /* <s:Envelope> */
 779     ret = WsWriteStartElement(writer, actual_envelope_prefix, &envelope, envelope_uri_xmlstr, NULL);
 780     if (FAILED(ret)) goto cleanup;
 781
 782     LIST_FOR_EACH_ENTRY(ns, discovered_namespaces, struct discovered_namespace, entry)
 783     {
 784         tmp_prefix = populate_xml_string(ns->prefix);
 785         tmp_uri = populate_xml_string(ns->uri);
 786
 787         if ((tmp_prefix == NULL) || (tmp_uri == NULL)) goto cleanup;
 788
 789         ret = WsWriteXmlnsAttribute(writer, tmp_prefix, tmp_uri, FALSE, NULL);
 790         if (FAILED(ret)) goto cleanup;
 791
 792         free_xml_string(tmp_prefix);
 793         free_xml_string(tmp_uri);
 794     }
 795
 796     tmp_prefix = NULL;
 797     tmp_uri = NULL;
 798
 799     /* Write the header */
 800     ret = write_xml_element(header_element, writer);
 801     if (FAILED(ret)) goto cleanup;
 802
 803     /* Write the body */
 804     ret = write_xml_element(body_element, writer);
 805     if (FAILED(ret)) goto cleanup;
 806
 807     ret = WsWriteEndElement(writer, NULL);
 808     if (FAILED(ret)) goto cleanup;
 809
 810     /* </s:Envelope> */
 811
 812     /* Generate the bytes of the document */
 813     ret = WsWriteXmlBufferToBytes(writer, buffer, NULL, NULL, 0, *heap, (void**)output_xml, xml_length, NULL);
 814     if (FAILED(ret)) goto cleanup;
 815
 816 cleanup:
 817     WSDFreeLinkedMemory(addressing_ns);
 818     WSDFreeLinkedMemory(discovery_ns);
 819     WSDFreeLinkedMemory(envelope_ns);
 820
 821     WSDXMLCleanupElement(header_element);
 822
 823     free_xml_string(actual_envelope_prefix);
 824     free_xml_string(envelope_uri_xmlstr);
 825
 826     if (writer != NULL)
 827         WsFreeWriter(writer);
 828
 829     /* Don't free the heap unless the operation has failed */
 830     if ((FAILED(ret)) && (*heap != NULL))
 831     {
 832         WsFreeHeap(*heap);
 833         *heap = NULL;
 834     }
 835
 836     return ret;
 837 }
 838
 839 static HRESULT write_and_send_message(IWSDiscoveryPublisherImpl *impl, WSD_SOAP_HEADER *header, WSDXML_ELEMENT *body_element,
 840     struct list *discovered_namespaces, IWSDUdpAddress *remote_address, int max_initial_delay)
 841 {
 842     static const char xml_header[] = "<?xml version=\"1.0\" encoding=\"utf-8\"?>";
 843     ULONG xml_length = 0, xml_header_len = sizeof(xml_header) - 1;
 844     WS_HEAP *heap = NULL;
 845     char *xml = NULL;
 846     char *full_xml;
 847     HRESULT ret;
 848
 849     ret = create_soap_envelope(impl->xmlContext, header, body_element, &heap, &xml, &xml_length, discovered_namespaces);
 850     if (ret != S_OK) return ret;
 851
 852     /* Prefix the XML header */
 853     full_xml = heap_alloc(xml_length + xml_header_len + 1);
 854
 855     if (full_xml == NULL)
 856     {
 857         WsFreeHeap(heap);
 858         return E_OUTOFMEMORY;
 859     }
 860
 861     memcpy(full_xml, xml_header, xml_header_len);
 862     memcpy(full_xml + xml_header_len, xml, xml_length);
 863     full_xml[xml_length + xml_header_len] = 0;
 864
 865     if (remote_address == NULL)
 866     {
 867         /* Send the message via UDP multicast */
 868         ret = send_udp_multicast(impl, full_xml, xml_length + xml_header_len, max_initial_delay) ? S_OK : E_FAIL;
 869     }
 870     else
 871     {
 872         /* Send the message via UDP unicast */
 873         ret = send_udp_unicast(full_xml, xml_length + xml_header_len, remote_address, max_initial_delay);
 874     }
 875
 876     heap_free(full_xml);
 877     WsFreeHeap(heap);
 878
 879     return ret;
 880 }
 881
 882 HRESULT send_hello_message(IWSDiscoveryPublisherImpl *impl, LPCWSTR id, ULONGLONG metadata_ver, ULONGLONG instance_id,
 883     ULONGLONG msg_num, LPCWSTR session_id, const WSD_NAME_LIST *types_list, const WSD_URI_LIST *scopes_list,
 884     const WSD_URI_LIST *xaddrs_list, const WSDXML_ELEMENT *hdr_any, const WSDXML_ELEMENT *ref_param_any,
 885     const WSDXML_ELEMENT *endpoint_ref_any, const WSDXML_ELEMENT *any)
 886 {
 887     WSDXML_ELEMENT *body_element = NULL, *hello_element, *endpoint_reference_element, *ref_params_element;
 888     struct list *discoveredNamespaces = NULL;
 889     WSDXML_NAME *body_name = NULL;
 890     WSD_SOAP_HEADER soapHeader;
 891     WSD_APP_SEQUENCE sequence;
 892     WCHAR message_id[64];
 893     HRESULT ret = E_OUTOFMEMORY;
 894     LPWSTR buffer;
 895
 896     sequence.InstanceId = instance_id;
 897     sequence.MessageNumber = msg_num;
 898     sequence.SequenceId = session_id;
 899
 900     if (!create_guid(message_id)) goto failed;
 901
 902     discoveredNamespaces = WSDAllocateLinkedMemory(NULL, sizeof(struct list));
 903     if (!discoveredNamespaces) goto failed;
 904
 905     list_init(discoveredNamespaces);
 906
 907     populate_soap_header(&soapHeader, discoveryTo, L"http://schemas.xmlsoap.org/ws/2005/04/discovery/Hello", message_id, &sequence, hdr_any);
 908
 909     ret = IWSDXMLContext_AddNameToNamespace(impl->xmlContext, envelopeNsUri, bodyString, &body_name);
 910     if (FAILED(ret)) goto cleanup;
 911
 912     /* <soap:Body>, <wsd:Hello> */
 913     ret = WSDXMLBuildAnyForSingleElement(body_name, NULL, &body_element);
 914     if (FAILED(ret)) goto cleanup;
 915
 916     ret = add_child_element(impl->xmlContext, body_element, discoveryNsUri, helloString, NULL, &hello_element);
 917     if (FAILED(ret)) goto cleanup;
 918
 919     /* <wsa:EndpointReference>, <wsa:Address> */
 920     ret = add_child_element(impl->xmlContext, hello_element, addressingNsUri, endpointReferenceString, NULL,
 921         &endpoint_reference_element);
 922     if (FAILED(ret)) goto cleanup;
 923
 924     ret = add_child_element(impl->xmlContext, endpoint_reference_element, addressingNsUri, addressString, id, NULL);
 925     if (FAILED(ret)) goto cleanup;
 926
 927     /* Write any reference parameters */
 928     if (ref_param_any != NULL)
 929     {
 930         ret = add_child_element(impl->xmlContext, endpoint_reference_element, addressingNsUri, referenceParametersString,
 931             NULL, &ref_params_element);
 932         if (FAILED(ret)) goto cleanup;
 933
 934         ret = duplicate_element(ref_params_element, ref_param_any, discoveredNamespaces);
 935         if (FAILED(ret)) goto cleanup;
 936     }
 937
 938     /* Write any endpoint reference headers */
 939     if (endpoint_ref_any != NULL)
 940     {
 941         ret = duplicate_element(endpoint_reference_element, endpoint_ref_any, discoveredNamespaces);
 942         if (FAILED(ret)) goto cleanup;
 943     }
 944
 945     /* <wsd:Types> */
 946     if (types_list != NULL)
 947     {
 948         buffer = WSDAllocateLinkedMemory(hello_element, WSD_MAX_TEXT_LENGTH * sizeof(WCHAR));
 949         if (buffer == NULL) goto failed;
 950
 951         ret = build_types_list(buffer, WSD_MAX_TEXT_LENGTH * sizeof(WCHAR), types_list, discoveredNamespaces);
 952         if (FAILED(ret)) goto cleanup;
 953
 954         ret = add_child_element(impl->xmlContext, hello_element, discoveryNsUri, typesString, buffer, NULL);
 955         if (FAILED(ret)) goto cleanup;
 956     }
 957
 958     /* <wsd:Scopes> */
 959     if (scopes_list != NULL)
 960     {
 961         buffer = WSDAllocateLinkedMemory(hello_element, WSD_MAX_TEXT_LENGTH * sizeof(WCHAR));
 962         if (buffer == NULL) goto failed;
 963
 964         ret = build_uri_list(buffer, WSD_MAX_TEXT_LENGTH * sizeof(WCHAR), scopes_list);
 965         if (FAILED(ret)) goto cleanup;
 966
 967         ret = add_child_element(impl->xmlContext, hello_element, discoveryNsUri, scopesString, buffer, NULL);
 968         if (FAILED(ret)) goto cleanup;
 969     }
 970
 971     /* <wsd:XAddrs> */
 972     if (xaddrs_list != NULL)
 973     {
 974         buffer = WSDAllocateLinkedMemory(hello_element, WSD_MAX_TEXT_LENGTH * sizeof(WCHAR));
 975         if (buffer == NULL) goto failed;
 976
 977         ret = build_uri_list(buffer, WSD_MAX_TEXT_LENGTH * sizeof(WCHAR), xaddrs_list);
 978         if (FAILED(ret)) goto cleanup;
 979
 980         ret = add_child_element(impl->xmlContext, hello_element, discoveryNsUri, xAddrsString, buffer, NULL);
 981         if (FAILED(ret)) goto cleanup;
 982     }
 983
 984     /* <wsd:MetadataVersion> */
 985     ret = add_child_element(impl->xmlContext, hello_element, discoveryNsUri, metadataVersionString,
 986         ulonglong_to_string(hello_element, min(UINT_MAX, metadata_ver)), NULL);
 987
 988     if (FAILED(ret)) goto cleanup;
 989
 990     /* Write any body elements */
 991     if (any != NULL)
 992     {
 993         ret = duplicate_element(hello_element, any, discoveredNamespaces);
 994         if (FAILED(ret)) goto cleanup;
 995     }
 996
 997     /* Write and send the message */
 998     ret = write_and_send_message(impl, &soapHeader, body_element, discoveredNamespaces, NULL, APP_MAX_DELAY);
 999     goto cleanup;
1000
1001 failed:
1002     ret = E_OUTOFMEMORY;
1003
1004 cleanup:
1005     WSDFreeLinkedMemory(body_name);
1006     WSDFreeLinkedMemory(body_element);
1007     WSDFreeLinkedMemory(discoveredNamespaces);
1008
1009     return ret;
1010 }
1011
1012 HRESULT send_bye_message(IWSDiscoveryPublisherImpl *impl, LPCWSTR id, ULONGLONG instance_id, ULONGLONG msg_num,
1013     LPCWSTR session_id, const WSDXML_ELEMENT *any)
1014 {
1015     WSDXML_ELEMENT *body_element = NULL, *bye_element, *endpoint_reference_element;
1016     struct list *discovered_namespaces = NULL;
1017     WSDXML_NAME *body_name = NULL;
1018     WSD_SOAP_HEADER soap_header;
1019     WSD_APP_SEQUENCE sequence;
1020     WCHAR message_id[64];
1021     HRESULT ret = E_OUTOFMEMORY;
1022
1023     sequence.InstanceId = instance_id;
1024     sequence.MessageNumber = msg_num;
1025     sequence.SequenceId = session_id;
1026
1027     if (!create_guid(message_id)) goto failed;
1028
1029     discovered_namespaces = WSDAllocateLinkedMemory(NULL, sizeof(struct list));
1030     if (!discovered_namespaces) goto failed;
1031
1032     list_init(discovered_namespaces);
1033
1034     populate_soap_header(&soap_header, discoveryTo, L"http://schemas.xmlsoap.org/ws/2005/04/discovery/Bye", message_id, &sequence, NULL);
1035
1036     ret = IWSDXMLContext_AddNameToNamespace(impl->xmlContext, envelopeNsUri, bodyString, &body_name);
1037     if (FAILED(ret)) goto cleanup;
1038
1039     /* <soap:Body>, <wsd:Bye> */
1040     ret = WSDXMLBuildAnyForSingleElement(body_name, NULL, &body_element);
1041     if (FAILED(ret)) goto cleanup;
1042
1043     ret = add_child_element(impl->xmlContext, body_element, discoveryNsUri, byeString, NULL, &bye_element);
1044     if (FAILED(ret)) goto cleanup;
1045
1046     /* <wsa:EndpointReference>, <wsa:Address> */
1047     ret = add_child_element(impl->xmlContext, bye_element, addressingNsUri, endpointReferenceString, NULL,
1048         &endpoint_reference_element);
1049     if (FAILED(ret)) goto cleanup;
1050
1051     ret = add_child_element(impl->xmlContext, endpoint_reference_element, addressingNsUri, addressString, id, NULL);
1052     if (FAILED(ret)) goto cleanup;
1053
1054     /* Write any body elements */
1055     if (any != NULL)
1056     {
1057         ret = duplicate_element(bye_element, any, discovered_namespaces);
1058         if (FAILED(ret)) goto cleanup;
1059     }
1060
1061     /* Write and send the message */
1062     ret = write_and_send_message(impl, &soap_header, body_element, discovered_namespaces, NULL, 0);
1063     goto cleanup;
1064
1065 failed:
1066     ret = E_OUTOFMEMORY;
1067
1068 cleanup:
1069     WSDFreeLinkedMemory(body_name);
1070     WSDFreeLinkedMemory(body_element);
1071     WSDFreeLinkedMemory(discovered_namespaces);
1072
1073     return ret;
1074 }
1075
1076 HRESULT send_probe_matches_message(IWSDiscoveryPublisherImpl *impl, const WSD_SOAP_MESSAGE *probe_msg,
1077     IWSDMessageParameters *message_params, LPCWSTR id, ULONGLONG metadata_ver, ULONGLONG instance_id,
1078     ULONGLONG msg_num, LPCWSTR session_id, const WSD_NAME_LIST *types_list, const WSD_URI_LIST *scopes_list,
1079     const WSD_URI_LIST *xaddrs_list, const WSDXML_ELEMENT *header_any, const WSDXML_ELEMENT *ref_param_any,
1080     const WSDXML_ELEMENT *endpoint_ref_any, const WSDXML_ELEMENT *any)
1081 {
1082     WSDXML_ELEMENT *body_element = NULL, *probe_matches_element, *probe_match_element, *endpoint_ref_element;
1083     WSDXML_ELEMENT *ref_params_element = NULL;
1084     struct list *discovered_namespaces = NULL;
1085     IWSDUdpAddress *remote_udp_addr = NULL;
1086     IWSDAddress *remote_addr = NULL;
1087     WSDXML_NAME *body_name = NULL;
1088     WSD_SOAP_HEADER soap_header;
1089     WSD_APP_SEQUENCE sequence;
1090     WCHAR msg_id[64];
1091     LPWSTR buffer;
1092     HRESULT ret;
1093
1094     ret = IWSDMessageParameters_GetRemoteAddress(message_params, &remote_addr);
1095
1096     if (FAILED(ret))
1097     {
1098         WARN("Unable to retrieve remote address from IWSDMessageParameters\n");
1099         return ret;
1100     }
1101
1102     ret = IWSDAddress_QueryInterface(remote_addr, &IID_IWSDUdpAddress, (LPVOID *) &remote_udp_addr);
1103
1104     if (FAILED(ret))
1105     {
1106         WARN("Remote address is not a UDP address\n");
1107         goto cleanup;
1108     }
1109
1110     sequence.InstanceId = instance_id;
1111     sequence.MessageNumber = msg_num;
1112     sequence.SequenceId = session_id;
1113
1114     if (!create_guid(msg_id)) goto failed;
1115
1116     discovered_namespaces = WSDAllocateLinkedMemory(NULL, sizeof(struct list));
1117     if (!discovered_namespaces) goto failed;
1118
1119     list_init(discovered_namespaces);
1120
1121     populate_soap_header(&soap_header, L"http://schemas.xmlsoap.org/ws/2004/08/addressing/role/anonymous",
1122         L"http://schemas.xmlsoap.org/ws/2005/04/discovery/ProbeMatches", msg_id, &sequence, header_any);
1123     soap_header.RelatesTo.MessageID = probe_msg->Header.MessageID;
1124
1125     ret = IWSDXMLContext_AddNameToNamespace(impl->xmlContext, envelopeNsUri, bodyString, &body_name);
1126     if (FAILED(ret)) goto cleanup;
1127
1128     /* <soap:Body>, <wsd:ProbeMatches> */
1129     ret = WSDXMLBuildAnyForSingleElement(body_name, NULL, &body_element);
1130     if (FAILED(ret)) goto cleanup;
1131
1132     ret = add_child_element(impl->xmlContext, body_element, discoveryNsUri, probeMatchesString, NULL,
1133         &probe_matches_element);
1134     if (FAILED(ret)) goto cleanup;
1135
1136     /* <wsd:ProbeMatch> */
1137     ret = add_child_element(impl->xmlContext, probe_matches_element, discoveryNsUri, probeMatchString, NULL,
1138         &probe_match_element);
1139     if (FAILED(ret)) goto cleanup;
1140
1141     /* <wsa:EndpointReference>, <wsa:Address> */
1142     ret = add_child_element(impl->xmlContext, probe_match_element, addressingNsUri, endpointReferenceString, NULL,
1143         &endpoint_ref_element);
1144     if (FAILED(ret)) goto cleanup;
1145
1146     ret = add_child_element(impl->xmlContext, endpoint_ref_element, addressingNsUri, addressString, id, NULL);
1147     if (FAILED(ret)) goto cleanup;
1148
1149     /* Write any reference parameters */
1150     if (ref_param_any != NULL)
1151     {
1152         ret = add_child_element(impl->xmlContext, endpoint_ref_element, addressingNsUri, referenceParametersString,
1153             NULL, &ref_params_element);
1154         if (FAILED(ret)) goto cleanup;
1155
1156         ret = duplicate_element(ref_params_element, ref_param_any, discovered_namespaces);
1157         if (FAILED(ret)) goto cleanup;
1158     }
1159
1160     /* Write any endpoint reference headers */
1161     if (endpoint_ref_any != NULL)
1162     {
1163         ret = duplicate_element(endpoint_ref_element, endpoint_ref_any, discovered_namespaces);
1164         if (FAILED(ret)) goto cleanup;
1165     }
1166
1167     /* <wsd:Types> */
1168     if (types_list != NULL)
1169     {
1170         buffer = WSDAllocateLinkedMemory(probe_match_element, WSD_MAX_TEXT_LENGTH * sizeof(WCHAR));
1171         if (buffer == NULL) goto failed;
1172
1173         ret = build_types_list(buffer, WSD_MAX_TEXT_LENGTH * sizeof(WCHAR), types_list, discovered_namespaces);
1174         if (FAILED(ret)) goto cleanup;
1175
1176         ret = add_child_element(impl->xmlContext, probe_match_element, discoveryNsUri, typesString, buffer, NULL);
1177         if (FAILED(ret)) goto cleanup;
1178     }
1179
1180     /* <wsd:Scopes> */
1181     if (scopes_list != NULL)
1182     {
1183         buffer = WSDAllocateLinkedMemory(probe_match_element, WSD_MAX_TEXT_LENGTH * sizeof(WCHAR));
1184         if (buffer == NULL) goto failed;
1185
1186         ret = build_uri_list(buffer, WSD_MAX_TEXT_LENGTH * sizeof(WCHAR), scopes_list);
1187         if (FAILED(ret)) goto cleanup;
1188
1189         ret = add_child_element(impl->xmlContext, probe_match_element, discoveryNsUri, scopesString, buffer, NULL);
1190         if (FAILED(ret)) goto cleanup;
1191     }
1192
1193     /* <wsd:XAddrs> */
1194     if (xaddrs_list != NULL)
1195     {
1196         buffer = WSDAllocateLinkedMemory(probe_match_element, WSD_MAX_TEXT_LENGTH * sizeof(WCHAR));
1197         if (buffer == NULL) goto failed;
1198
1199         ret = build_uri_list(buffer, WSD_MAX_TEXT_LENGTH * sizeof(WCHAR), xaddrs_list);
1200         if (FAILED(ret)) goto cleanup;
1201
1202         ret = add_child_element(impl->xmlContext, probe_match_element, discoveryNsUri, xAddrsString, buffer, NULL);
1203         if (FAILED(ret)) goto cleanup;
1204     }
1205
1206     /* <wsd:MetadataVersion> */
1207     ret = add_child_element(impl->xmlContext, probe_match_element, discoveryNsUri, metadataVersionString,
1208         ulonglong_to_string(probe_match_element, min(UINT_MAX, metadata_ver)), NULL);
1209     if (FAILED(ret)) goto cleanup;
1210
1211     /* Write any body elements */
1212     if (any != NULL)
1213     {
1214         ret = duplicate_element(probe_match_element, any, discovered_namespaces);
1215         if (FAILED(ret)) goto cleanup;
1216     }
1217
1218     /* Write and send the message */
1219     ret = write_and_send_message(impl, &soap_header, body_element, discovered_namespaces, remote_udp_addr, APP_MAX_DELAY);
1220     goto cleanup;
1221
1222 failed:
1223     ret = E_FAIL;
1224
1225 cleanup:
1226     WSDFreeLinkedMemory(body_name);
1227     WSDFreeLinkedMemory(body_element);
1228     WSDFreeLinkedMemory(discovered_namespaces);
1229
1230     if (remote_udp_addr != NULL) IWSDUdpAddress_Release(remote_udp_addr);
1231     if (remote_addr != NULL) IWSDAddress_Release(remote_addr);
1232
1233     return ret;
1234 }
1235
1236 static LPWSTR xml_text_to_wide_string(void *parent_memory, WS_XML_TEXT *text)
1237 {
1238     if (text->textType == WS_XML_TEXT_TYPE_UTF8)
1239     {
1240         WS_XML_UTF8_TEXT *utf8_text = (WS_XML_UTF8_TEXT *) text;
1241         return utf8_to_wide(parent_memory, (const char *) utf8_text->value.bytes, utf8_text->value.length);
1242     }
1243     else if (text->textType == WS_XML_TEXT_TYPE_UTF16)
1244     {
1245         WS_XML_UTF16_TEXT *utf_16_text = (WS_XML_UTF16_TEXT *) text;
1246         return duplicate_string(parent_memory, (LPCWSTR) utf_16_text->bytes);
1247     }
1248
1249     FIXME("Support for text type %d not implemented.\n", text->textType);
1250     return NULL;
1251 }
1252
1253 static inline BOOL read_isspace(unsigned int ch)
1254 {
1255     return ch == ' ' || ch == '\t' || ch == '\r' || ch == '\n';
1256 }
1257
1258 static HRESULT str_to_uint64(const unsigned char *str, ULONG len, UINT64 max, UINT64 *ret)
1259 {
1260     const unsigned char *ptr = str;
1261
1262     *ret = 0;
1263     while (len && read_isspace(*ptr)) { ptr++; len--; }
1264     while (len && read_isspace(ptr[len - 1])) { len--; }
1265     if (!len) return WS_E_INVALID_FORMAT;
1266
1267     while (len--)
1268     {
1269         unsigned int val;
1270
1271         if (!isdigit(*ptr)) return WS_E_INVALID_FORMAT;
1272         val = *ptr - '0';
1273
1274         if ((*ret > max / 10 || *ret * 10 > max - val)) return WS_E_NUMERIC_OVERFLOW;
1275         *ret = *ret * 10 + val;
1276         ptr++;
1277     }
1278
1279     return S_OK;
1280 }
1281
1282 #define MAX_UINT64  (((UINT64)0xffffffff << 32) | 0xffffffff)
1283
1284 static HRESULT wide_text_to_ulonglong(LPCWSTR text, ULONGLONG *value)
1285 {
1286     char *utf8_text;
1287     int utf8_length;
1288     HRESULT ret;
1289
1290     utf8_text = wide_to_utf8(text, &utf8_length);
1291
1292     if (utf8_text == NULL) return E_OUTOFMEMORY;
1293     if (utf8_length == 1) return E_FAIL;
1294
1295     ret = str_to_uint64((const unsigned char *) utf8_text, utf8_length - 1, MAX_UINT64, value);
1296     heap_free(utf8_text);
1297
1298     return ret;
1299 }
1300
1301 static HRESULT move_to_element(WS_XML_READER *reader, const char *element_name, WS_XML_STRING *uri)
1302 {
1303     WS_XML_STRING envelope;
1304     BOOL found = FALSE;
1305     HRESULT ret;
1306
1307     envelope.bytes = (BYTE *) element_name;
1308     envelope.length = strlen(element_name);
1309     envelope.dictionary = NULL;
1310     envelope.id = 0;
1311
1312     ret = WsReadToStartElement(reader, &envelope, uri, &found, NULL);
1313     if (FAILED(ret)) return ret;
1314
1315     return found ? ret : E_FAIL;
1316 }
1317
1318 static void trim_trailing_slash(LPWSTR uri)
1319 {
1320     /* Trim trailing slash from URI */
1321     int uri_len = lstrlenW(uri);
1322     if (uri_len > 0 && uri[uri_len - 1] == '/') uri[uri_len - 1] = 0;
1323 }
1324
1325 static HRESULT ws_element_to_wsdxml_element(WS_XML_READER *reader, IWSDXMLContext *context, WSDXML_ELEMENT *parent_element)
1326 {
1327     WSDXML_ATTRIBUTE *cur_wsd_attrib = NULL, *new_wsd_attrib = NULL;
1328     const WS_XML_ELEMENT_NODE *element_node = NULL;
1329     WSDXML_ELEMENT *cur_element = parent_element;
1330     const WS_XML_TEXT_NODE *text_node = NULL;
1331     LPWSTR uri = NULL, element_name = NULL;
1332     WS_XML_STRING *ns_string = NULL;
1333     WS_XML_ATTRIBUTE *attrib = NULL;
1334     WSDXML_ELEMENT *element = NULL;
1335     const WS_XML_NODE *node = NULL;
1336     WSDXML_NAME *name = NULL;
1337     WSDXML_TEXT *text = NULL;
1338     HRESULT ret;
1339     int i;
1340
1341     for (;;)
1342     {
1343         if (cur_element == NULL) break;
1344
1345         ret = WsReadNode(reader, NULL);
1346         if (FAILED(ret)) goto cleanup;
1347
1348         ret = WsGetReaderNode(reader, &node, NULL);
1349         if (FAILED(ret)) goto cleanup;
1350
1351         switch (node->nodeType)
1352         {
1353             case WS_XML_NODE_TYPE_ELEMENT:
1354                 element_node = (const WS_XML_ELEMENT_NODE *) node;
1355
1356                 uri = utf8_to_wide(NULL, (const char *) element_node->ns->bytes, element_node->ns->length);
1357                 if (uri == NULL) goto outofmemory;
1358
1359                 /* Link element_name to uri so they will be freed at the same time */
1360                 element_name = utf8_to_wide(uri, (const char *) element_node->localName->bytes,
1361                     element_node->localName->length);
1362                 if (element_name == NULL) goto outofmemory;
1363
1364                 trim_trailing_slash(uri);
1365
1366                 ret = IWSDXMLContext_AddNameToNamespace(context, uri, element_name, &name);
1367                 if (FAILED(ret)) goto cleanup;
1368
1369                 WSDFreeLinkedMemory(uri);
1370                 uri = NULL;
1371
1372                 ret = WSDXMLBuildAnyForSingleElement(name, NULL, &element);
1373                 if (FAILED(ret)) goto cleanup;
1374                 WSDXMLAddChild(cur_element, element);
1375
1376                 WSDFreeLinkedMemory(name);
1377                 name = NULL;
1378
1379                 cur_wsd_attrib = NULL;
1380
1381                 /* Add attributes */
1382                 for (i = 0; i < element_node->attributeCount; i++)
1383                 {
1384                     attrib = element_node->attributes[i];
1385                     if (attrib->isXmlNs) continue;
1386
1387                     new_wsd_attrib = WSDAllocateLinkedMemory(element, sizeof(WSDXML_ATTRIBUTE));
1388                     if (new_wsd_attrib == NULL) goto outofmemory;
1389
1390                     ns_string = attrib->ns;
1391                     if (ns_string->length == 0) ns_string = element_node->ns;
1392
1393                     uri = utf8_to_wide(NULL, (const char *) ns_string->bytes, ns_string->length);
1394                     if (uri == NULL) goto outofmemory;
1395
1396                     trim_trailing_slash(uri);
1397
1398                     /* Link element_name to uri so they will be freed at the same time */
1399                     element_name = utf8_to_wide(uri, (const char *) attrib->localName->bytes, attrib->localName->length);
1400                     if (element_name == NULL) goto outofmemory;
1401
1402                     ret = IWSDXMLContext_AddNameToNamespace(context, uri, element_name, &name);
1403                     if (FAILED(ret)) goto cleanup;
1404
1405                     WSDFreeLinkedMemory(uri);
1406                     uri = NULL;
1407
1408                     new_wsd_attrib->Value = xml_text_to_wide_string(new_wsd_attrib, attrib->value);
1409                     if (new_wsd_attrib->Value == NULL) goto outofmemory;
1410
1411                     new_wsd_attrib->Name = name;
1412                     new_wsd_attrib->Element = cur_element;
1413                     new_wsd_attrib->Next = NULL;
1414
1415                     WSDAttachLinkedMemory(new_wsd_attrib, name);
1416                     name = NULL;
1417
1418                     if (cur_wsd_attrib == NULL)
1419                         element->FirstAttribute = new_wsd_attrib;
1420                     else
1421                         cur_wsd_attrib->Next = new_wsd_attrib;
1422
1423                     cur_wsd_attrib = new_wsd_attrib;
1424                 }
1425
1426                 cur_element = element;
1427                 break;
1428
1429             case WS_XML_NODE_TYPE_TEXT:
1430                 text_node = (const WS_XML_TEXT_NODE *) node;
1431
1432                 if (cur_element == NULL)
1433                 {
1434                     WARN("No parent element open but encountered text element!\n");
1435                     continue;
1436                 }
1437
1438                 if (cur_element->FirstChild != NULL)
1439                 {
1440                     WARN("Text node encountered but parent already has child!\n");
1441                     continue;
1442                 }
1443
1444                 text = WSDAllocateLinkedMemory(element, sizeof(WSDXML_TEXT));
1445                 if (text == NULL) goto outofmemory;
1446
1447                 text->Node.Parent = element;
1448                 text->Node.Next = NULL;
1449                 text->Node.Type = TextType;
1450                 text->Text = xml_text_to_wide_string(text, text_node->text);
1451
1452                 if (text->Text == NULL)
1453                 {
1454                     WARN("Text node returned null string.\n");
1455                     WSDFreeLinkedMemory(text);
1456                     continue;
1457                 }
1458
1459                 cur_element->FirstChild = (WSDXML_NODE *) text;
1460                 break;
1461
1462             case WS_XML_NODE_TYPE_END_ELEMENT:
1463                 /* Go up a level to the parent element */
1464                 cur_element = cur_element->Node.Parent;
1465                 break;
1466
1467             default:
1468                 break;
1469         }
1470     }
1471
1472     return S_OK;
1473
1474 outofmemory:
1475     ret = E_OUTOFMEMORY;
1476
1477 cleanup:
1478     /* Free uri and element_name if applicable */
1479     WSDFreeLinkedMemory(uri);
1480     WSDFreeLinkedMemory(name);
1481     return ret;
1482 }
1483
1484 static WSDXML_ELEMENT *find_element(WSDXML_ELEMENT *parent, LPCWSTR name, LPCWSTR ns_uri)
1485 {
1486     WSDXML_ELEMENT *cur = (WSDXML_ELEMENT *) parent->FirstChild;
1487
1488     while (cur != NULL)
1489     {
1490         if ((lstrcmpW(cur->Name->LocalName, name) == 0) && (lstrcmpW(cur->Name->Space->Uri, ns_uri) == 0))
1491             return cur;
1492
1493         cur = (WSDXML_ELEMENT *) cur->Node.Next;
1494     }
1495
1496     return NULL;
1497 }
1498
1499 static void remove_element(WSDXML_ELEMENT *element)
1500 {
1501     WSDXML_NODE *cur;
1502
1503     if (element == NULL)
1504         return;
1505
1506     if (element->Node.Parent->FirstChild == (WSDXML_NODE *) element)
1507         element->Node.Parent->FirstChild = element->Node.Next;
1508     else
1509     {
1510         cur = element->Node.Parent->FirstChild;
1511
1512         while (cur != NULL)
1513         {
1514             if (cur->Next == (WSDXML_NODE *) element)
1515             {
1516                 cur->Next = element->Node.Next;
1517                 break;
1518             }
1519
1520             cur = cur->Next;
1521         }
1522     }
1523
1524     WSDDetachLinkedMemory(element);
1525     WSDFreeLinkedMemory(element);
1526 }
1527
1528 static WSD_NAME_LIST *build_types_list_from_string(IWSDXMLContext *context, LPCWSTR buffer, void *parent)
1529 {
1530     WSD_NAME_LIST *list = NULL, *cur_list = NULL, *prev_list = NULL;
1531     LPWSTR name_start = NULL, temp_buffer = NULL;
1532     LPCWSTR prefix_start = buffer;
1533     WSDXML_NAMESPACE *ns;
1534     WSDXML_NAME *name;
1535     int buffer_len, i;
1536
1537     if (buffer == NULL)
1538         return NULL;
1539
1540     temp_buffer = duplicate_string(parent, buffer);
1541     if (temp_buffer == NULL) goto cleanup;
1542
1543     buffer_len = lstrlenW(temp_buffer);
1544
1545     list = WSDAllocateLinkedMemory(parent, sizeof(WSD_NAME_LIST));
1546     if (list == NULL) goto cleanup;
1547
1548     ZeroMemory(list, sizeof(WSD_NAME_LIST));
1549     prefix_start = temp_buffer;
1550
1551     for (i = 0; i < buffer_len; i++)
1552     {
1553         if (temp_buffer[i] == ':')
1554         {
1555             temp_buffer[i] = 0;
1556             name_start = &temp_buffer[i + 1];
1557         }
1558         else if ((temp_buffer[i] == ' ') || (i == buffer_len - 1))
1559         {
1560             WSDXML_NAMESPACE *known_ns;
1561
1562             if (temp_buffer[i] == ' ')
1563                 temp_buffer[i] = 0;
1564
1565             if (cur_list == NULL)
1566                 cur_list = list;
1567             else
1568             {
1569                 cur_list = WSDAllocateLinkedMemory(parent, sizeof(WSD_NAME_LIST));
1570                 if (cur_list == NULL) goto cleanup;
1571
1572                 prev_list->Next = cur_list;
1573             }
1574
1575             name = WSDAllocateLinkedMemory(cur_list, sizeof(WSDXML_NAME));
1576             if (name == NULL) goto cleanup;
1577
1578             ns = WSDAllocateLinkedMemory(cur_list, sizeof(WSDXML_NAMESPACE));
1579             if (ns == NULL) goto cleanup;
1580
1581             ZeroMemory(ns, sizeof(WSDXML_NAMESPACE));
1582             ns->PreferredPrefix = duplicate_string(ns, prefix_start);
1583
1584             known_ns = xml_context_find_namespace_by_prefix(context, ns->PreferredPrefix);
1585
1586             if (known_ns != NULL)
1587                 ns->Uri = duplicate_string(ns, known_ns->Uri);
1588
1589             name->Space = ns;
1590             name->LocalName = duplicate_string(name, name_start);
1591
1592             cur_list->Element = name;
1593             prefix_start = &temp_buffer[i + 1];
1594             name_start = NULL;
1595         }
1596     }
1597
1598     WSDFreeLinkedMemory(temp_buffer);
1599     return list;
1600
1601 cleanup:
1602     WSDFreeLinkedMemory(list);
1603     WSDFreeLinkedMemory(temp_buffer);
1604
1605     return NULL;
1606 }
1607
1608 static WSDXML_TYPE *generate_type(LPCWSTR uri, void *parent)
1609 {
1610     WSDXML_TYPE *type = WSDAllocateLinkedMemory(parent, sizeof(WSDXML_TYPE));
1611
1612     if (type == NULL)
1613         return NULL;
1614
1615     type->Uri = duplicate_string(parent, uri);
1616     type->Table = NULL;
1617
1618     return type;
1619 }
1620
1621 static BOOL is_duplicate_message(IWSDiscoveryPublisherImpl *impl, LPCWSTR id)
1622 {
1623     struct message_id *msg_id, *msg_id_cursor;
1624     BOOL ret = FALSE;
1625     int len;
1626
1627     EnterCriticalSection(&impl->message_ids_critical_section);
1628
1629     LIST_FOR_EACH_ENTRY_SAFE(msg_id, msg_id_cursor, &impl->message_ids, struct message_id, entry)
1630     {
1631         if (lstrcmpW(msg_id->id, id) == 0)
1632         {
1633             ret = TRUE;
1634             goto end;
1635         }
1636     }
1637
1638     msg_id = heap_alloc(sizeof(*msg_id));
1639     if (!msg_id) goto end;
1640
1641     len = (lstrlenW(id) + 1) * sizeof(WCHAR);
1642     msg_id->id = heap_alloc(len);
1643
1644     if (!msg_id->id)
1645     {
1646         heap_free(msg_id);
1647         goto end;
1648     }
1649
1650     memcpy(msg_id->id, id, len);
1651     list_add_tail(&impl->message_ids, &msg_id->entry);
1652
1653 end:
1654     LeaveCriticalSection(&impl->message_ids_critical_section);
1655     return ret;
1656 }
1657
1658 HRESULT read_message(IWSDiscoveryPublisherImpl *impl, const char *xml, int xml_length, WSD_SOAP_MESSAGE **out_msg, int *msg_type)
1659 {
1660     WSDXML_ELEMENT *envelope = NULL, *header_element, *appsequence_element, *body_element;
1661     WS_XML_READER_TEXT_ENCODING encoding;
1662     WS_XML_ELEMENT_NODE *envelope_node;
1663     WSD_SOAP_MESSAGE *soap_msg = NULL;
1664     WS_XML_READER_BUFFER_INPUT input;
1665     WS_XML_ATTRIBUTE *attrib = NULL;
1666     IWSDXMLContext *context = NULL;
1667     WS_XML_STRING *soap_uri = NULL;
1668     const WS_XML_NODE *node;
1669     WS_XML_READER *reader = NULL;
1670     LPCWSTR value = NULL;
1671     LPWSTR uri, prefix;
1672     WS_HEAP *heap = NULL;
1673     HRESULT ret;
1674     int i;
1675
1676     *msg_type = MSGTYPE_UNKNOWN;
1677
1678     ret = WsCreateHeap(16384, 4096, NULL, 0, &heap, NULL);
1679     if (FAILED(ret)) goto cleanup;
1680
1681     ret = WsCreateReader(NULL, 0, &reader, NULL);
1682     if (FAILED(ret)) goto cleanup;
1683
1684     encoding.encoding.encodingType = WS_XML_READER_ENCODING_TYPE_TEXT;
1685     encoding.charSet = WS_CHARSET_AUTO;
1686
1687     input.input.inputType = WS_XML_READER_INPUT_TYPE_BUFFER;
1688     input.encodedData = (char *) xml;
1689     input.encodedDataSize = xml_length;
1690
1691     ret = WsSetInput(reader, (WS_XML_READER_ENCODING *) &encoding, (WS_XML_READER_INPUT *) &input, NULL, 0, NULL);
1692     if (FAILED(ret)) goto cleanup;
1693
1694     soap_uri = populate_xml_string(envelopeNsUri);
1695     if (soap_uri == NULL) goto outofmemory;
1696
1697     ret = move_to_element(reader, "Envelope", soap_uri);
1698     if (FAILED(ret)) goto cleanup;
1699
1700     ret = WsGetReaderNode(reader, &node, NULL);
1701     if (FAILED(ret)) goto cleanup;
1702
1703     if (node->nodeType != WS_XML_NODE_TYPE_ELEMENT)
1704     {
1705         WARN("Unexpected node type (%d)\n", node->nodeType);
1706         ret = E_FAIL;
1707         goto cleanup;
1708     }
1709
1710     envelope_node = (WS_XML_ELEMENT_NODE *) node;
1711
1712     ret = WSDXMLCreateContext(&context);
1713     if (FAILED(ret)) goto cleanup;
1714
1715     /* Find XML namespaces from the envelope element's attributes */
1716     for (i = 0; i < envelope_node->attributeCount; i++)
1717     {
1718         attrib = envelope_node->attributes[i];
1719
1720         if (attrib->isXmlNs)
1721         {
1722             uri = utf8_to_wide(NULL, (const char *) attrib->ns->bytes, attrib->ns->length);
1723             if (uri == NULL) continue;
1724
1725             trim_trailing_slash(uri);
1726
1727             prefix = utf8_to_wide(uri, (const char *) attrib->localName->bytes, attrib->localName->length);
1728
1729             if (prefix == NULL)
1730             {
1731                 WSDFreeLinkedMemory(uri);
1732                 continue;
1733             }
1734
1735             IWSDXMLContext_AddNamespace(context, uri, prefix, NULL);
1736             WSDFreeLinkedMemory(uri);
1737         }
1738     }
1739
1740     /* Create the SOAP message to return to the caller */
1741     soap_msg = WSDAllocateLinkedMemory(NULL, sizeof(WSD_SOAP_MESSAGE));
1742     if (soap_msg == NULL) goto outofmemory;
1743
1744     ZeroMemory(soap_msg, sizeof(WSD_SOAP_MESSAGE));
1745
1746     envelope = WSDAllocateLinkedMemory(soap_msg, sizeof(WSDXML_ELEMENT));
1747     if (envelope == NULL) goto outofmemory;
1748
1749     ZeroMemory(envelope, sizeof(WSDXML_ELEMENT));
1750
1751     ret = ws_element_to_wsdxml_element(reader, context, envelope);
1752     if (FAILED(ret)) goto cleanup;
1753
1754     /* Find the header element */
1755     header_element = find_element(envelope, headerString, envelopeNsUri);
1756
1757     if (header_element == NULL)
1758     {
1759         WARN("Unable to find header element in received SOAP message\n");
1760         ret = E_FAIL;
1761         goto cleanup;
1762     }
1763
1764     ret = WSDXMLGetValueFromAny(addressingNsUri, actionString, (WSDXML_ELEMENT *) header_element->FirstChild, &value);
1765     if (FAILED(ret)) goto cleanup;
1766     soap_msg->Header.Action = duplicate_string(soap_msg, value);
1767     if (soap_msg->Header.Action == NULL) goto outofmemory;
1768
1769     ret = WSDXMLGetValueFromAny(addressingNsUri, toString, (WSDXML_ELEMENT *) header_element->FirstChild, &value);
1770     if (FAILED(ret)) goto cleanup;
1771     soap_msg->Header.To = duplicate_string(soap_msg, value);
1772     if (soap_msg->Header.To == NULL) goto outofmemory;
1773
1774     ret = WSDXMLGetValueFromAny(addressingNsUri, messageIdString, (WSDXML_ELEMENT *) header_element->FirstChild, &value);
1775     if (FAILED(ret)) goto cleanup;
1776
1777     /* Detect duplicate messages */
1778     if (is_duplicate_message(impl, value))
1779     {
1780         ret = E_FAIL;
1781         goto cleanup;
1782     }
1783
1784     soap_msg->Header.MessageID = duplicate_string(soap_msg, value);
1785     if (soap_msg->Header.MessageID == NULL) goto outofmemory;
1786
1787     /* Look for optional AppSequence element */
1788     appsequence_element = find_element(header_element, appSequenceString, discoveryNsUri);
1789
1790     if (appsequence_element != NULL)
1791     {
1792         WSDXML_ATTRIBUTE *current_attrib;
1793
1794         soap_msg->Header.AppSequence = WSDAllocateLinkedMemory(soap_msg, sizeof(WSD_APP_SEQUENCE));
1795         if (soap_msg->Header.AppSequence == NULL) goto outofmemory;
1796
1797         ZeroMemory(soap_msg->Header.AppSequence, sizeof(WSD_APP_SEQUENCE));
1798
1799         current_attrib = appsequence_element->FirstAttribute;
1800
1801         while (current_attrib != NULL)
1802         {
1803             if (lstrcmpW(current_attrib->Name->Space->Uri, discoveryNsUri) != 0)
1804             {
1805                 current_attrib = current_attrib->Next;
1806                 continue;
1807             }
1808
1809             if (lstrcmpW(current_attrib->Name->LocalName, instanceIdString) == 0)
1810             {
1811                 ret = wide_text_to_ulonglong(current_attrib->Value, &soap_msg->Header.AppSequence->InstanceId);
1812                 if (FAILED(ret)) goto cleanup;
1813             }
1814             else if (lstrcmpW(current_attrib->Name->LocalName, messageNumberString) == 0)
1815             {
1816                 ret = wide_text_to_ulonglong(current_attrib->Value, &soap_msg->Header.AppSequence->MessageNumber);
1817                 if (FAILED(ret)) goto cleanup;
1818             }
1819             else if (lstrcmpW(current_attrib->Name->LocalName, sequenceIdString) == 0)
1820             {
1821                 soap_msg->Header.AppSequence->SequenceId = duplicate_string(soap_msg, current_attrib->Value);
1822                 if (soap_msg->Header.AppSequence->SequenceId == NULL) goto outofmemory;
1823             }
1824
1825             current_attrib = current_attrib->Next;
1826         }
1827     }
1828
1829     /* Now detach and free known headers to leave the "any" elements */
1830     remove_element(find_element(header_element, actionString, addressingNsUri));
1831     remove_element(find_element(header_element, toString, addressingNsUri));
1832     remove_element(find_element(header_element, messageIdString, addressingNsUri));
1833     remove_element(find_element(header_element, appSequenceString, discoveryNsUri));
1834
1835     soap_msg->Header.AnyHeaders = (WSDXML_ELEMENT *) header_element->FirstChild;
1836
1837     if (soap_msg->Header.AnyHeaders != NULL)
1838         soap_msg->Header.AnyHeaders->Node.Parent = NULL;
1839
1840     /* Find the body element */
1841     body_element = find_element(envelope, bodyString, envelopeNsUri);
1842
1843     if (body_element == NULL)
1844     {
1845         WARN("Unable to find body element in received SOAP message\n");
1846         ret = E_FAIL;
1847         goto cleanup;
1848     }
1849
1850     /* Now figure out which message we've been sent */
1851     if (lstrcmpW(soap_msg->Header.Action, actionProbe) == 0)
1852     {
1853         WSDXML_ELEMENT *probe_element;
1854         WSD_PROBE *probe = NULL;
1855
1856         probe_element = find_element(body_element, probeString, discoveryNsUri);
1857         if (probe_element == NULL) goto cleanup;
1858
1859         probe = WSDAllocateLinkedMemory(soap_msg, sizeof(WSD_PROBE));
1860         if (probe == NULL) goto cleanup;
1861
1862         ZeroMemory(probe, sizeof(WSD_PROBE));
1863
1864         /* Check for the "types" element */
1865         ret = WSDXMLGetValueFromAny(discoveryNsUri, typesString, (WSDXML_ELEMENT *) probe_element->FirstChild, &value);
1866
1867         if (FAILED(ret))
1868         {
1869             WARN("Unable to find Types element in received Probe message\n");
1870             goto cleanup;
1871         }
1872
1873         probe->Types = build_types_list_from_string(context, value, probe);
1874
1875         /* Now detach and free known headers to leave the "any" elements */
1876         remove_element(find_element(probe_element, typesString, discoveryNsUri));
1877         remove_element(find_element(probe_element, scopesString, discoveryNsUri));
1878
1879         probe->Any = (WSDXML_ELEMENT *) probe_element->FirstChild;
1880
1881         if (probe->Any != NULL)
1882             probe->Any->Node.Parent = NULL;
1883
1884         soap_msg->Body = probe;
1885         soap_msg->BodyType = generate_type(actionProbe, soap_msg);
1886         if (soap_msg->BodyType == NULL) goto cleanup;
1887
1888         *out_msg = soap_msg;
1889         soap_msg = NULL; /* caller will clean this up */
1890         *msg_type = MSGTYPE_PROBE;
1891     }
1892
1893     goto cleanup;
1894
1895 outofmemory:
1896     ret = E_OUTOFMEMORY;
1897
1898 cleanup:
1899     free_xml_string(soap_uri);
1900     WSDFreeLinkedMemory(soap_msg);
1901     if (context != NULL) IWSDXMLContext_Release(context);
1902     if (reader != NULL) WsFreeReader(reader);
1903     if (heap != NULL) WsFreeHeap(heap);
1904
1905     return ret;
1906 }