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[] = {
  36     'u','r','n',':',
  37     's','c','h','e','m','a','s','-','x','m','l','s','o','a','p','-','o','r','g',':',
  38     'w','s',':','2','0','0','5',':','0','4',':',
  39     'd','i','s','c','o','v','e','r','y', 0 };
  40
  41 static const WCHAR actionHello[] = {
  42     'h','t','t','p',':','/','/',
  43     's','c','h','e','m','a','s','.','x','m','l','s','o','a','p','.','o','r','g','/',
  44     'w','s','/','2','0','0','5','/','0','4','/',
  45     'd','i','s','c','o','v','e','r','y','/',
  46     'H','e','l','l','o', 0 };
  47
  48 static const WCHAR addressingNsUri[] = {
  49     'h','t','t','p',':','/','/',
  50     's','c','h','e','m','a','s','.','x','m','l','s','o','a','p','.','o','r','g','/',
  51     'w','s','/','2','0','0','4','/','0','8','/','a','d','d','r','e','s','s','i','n','g', 0 };
  52
  53 static const WCHAR discoveryNsUri[] = {
  54     'h','t','t','p',':','/','/',
  55     's','c','h','e','m','a','s','.','x','m','l','s','o','a','p','.','o','r','g','/',
  56     'w','s','/','2','0','0','5','/','0','4','/','d','i','s','c','o','v','e','r','y', 0 };
  57
  58 static const WCHAR envelopeNsUri[] = {
  59     'h','t','t','p',':','/','/',
  60     'w','w','w','.','w','3','.','o','r','g','/',
  61     '2','0','0','3','/','0','5','/','s','o','a','p','-','e','n','v','e','l','o','p','e', 0 };
  62
  63 static const WCHAR addressingPrefix[] = { 'w','s','a', 0 };
  64 static const WCHAR discoveryPrefix[] = { 'w','s','d', 0 };
  65 static const WCHAR envelopePrefix[] = { 's','o','a','p', 0 };
  66
  67 static char *wide_to_utf8(LPCWSTR wide_string, int *length)
  68 {
  69     char *new_string = NULL;
  70
  71     if (wide_string == NULL)
  72         return NULL;
  73
  74     *length = WideCharToMultiByte(CP_UTF8, 0, wide_string, -1, NULL, 0, NULL, NULL);
  75
  76     if (*length < 0)
  77         return NULL;
  78
  79     new_string = heap_alloc(*length);
  80     WideCharToMultiByte(CP_UTF8, 0, wide_string, -1, new_string, *length, NULL, NULL);
  81
  82     return new_string;
  83 }
  84
  85 static WS_XML_STRING *populate_xml_string(LPCWSTR str)
  86 {
  87     WS_XML_STRING *xml = heap_alloc_zero(sizeof(WS_XML_STRING));
  88     int utf8Length;
  89
  90     if (xml == NULL)
  91         return NULL;
  92
  93     xml->bytes = (BYTE *)wide_to_utf8(str, &utf8Length);
  94
  95     if (xml->bytes == NULL)
  96     {
  97         heap_free(xml);
  98         return NULL;
  99     }
 100
 101     xml->dictionary = NULL;
 102     xml->id = 0;
 103     xml->length = (xml->bytes == NULL) ? 0 : (utf8Length - 1);
 104
 105     return xml;
 106 }
 107
 108 static inline void free_xml_string(WS_XML_STRING *value)
 109 {
 110     if (value == NULL)
 111         return;
 112
 113     if (value->bytes != NULL)
 114         heap_free(value->bytes);
 115
 116     heap_free(value);
 117 }
 118
 119 static BOOL write_xml_element(WSDXML_ELEMENT *element, WS_XML_WRITER *writer)
 120 {
 121     WS_XML_STRING *local_name = NULL, *element_ns = NULL, *ns_prefix = NULL;
 122     WS_XML_UTF16_TEXT utf16_text;
 123     WSDXML_NODE *current_child;
 124     WSDXML_TEXT *node_as_text;
 125     BOOL retVal = FALSE;
 126     int text_len;
 127     HRESULT ret;
 128
 129     if (element == NULL)
 130         return TRUE;
 131
 132     /* Start the element */
 133     local_name = populate_xml_string(element->Name->LocalName);
 134     if (local_name == NULL) goto cleanup;
 135
 136     element_ns = populate_xml_string(element->Name->Space->Uri);
 137     if (element_ns == NULL) goto cleanup;
 138
 139     ns_prefix = populate_xml_string(element->Name->Space->PreferredPrefix);
 140     if (ns_prefix == NULL) goto cleanup;
 141
 142     ret = WsWriteStartElement(writer, ns_prefix, local_name, element_ns, NULL);
 143     if (FAILED(ret)) goto cleanup;
 144
 145     /* TODO: Write attributes */
 146
 147     /* Write child elements */
 148     current_child = element->FirstChild;
 149
 150     while (current_child != NULL)
 151     {
 152         if (current_child->Type == ElementType)
 153         {
 154             if (!write_xml_element((WSDXML_ELEMENT *)current_child, writer)) goto cleanup;
 155         }
 156         else if (current_child->Type == TextType)
 157         {
 158             node_as_text = (WSDXML_TEXT *)current_child;
 159             text_len = lstrlenW(node_as_text->Text);
 160
 161             utf16_text.text.textType = WS_XML_TEXT_TYPE_UTF16;
 162             utf16_text.byteCount = min(WSD_MAX_TEXT_LENGTH, text_len) * sizeof(WCHAR);
 163             utf16_text.bytes = (BYTE *)node_as_text->Text;
 164
 165             ret = WsWriteText(writer, (WS_XML_TEXT *)&utf16_text, NULL);
 166             if (FAILED(ret)) goto cleanup;
 167         }
 168
 169         current_child = current_child->Next;
 170     }
 171
 172     /* End the element */
 173     ret = WsWriteEndElement(writer, NULL);
 174     if (FAILED(ret)) goto cleanup;
 175
 176     retVal = TRUE;
 177
 178 cleanup:
 179     free_xml_string(local_name);
 180     free_xml_string(element_ns);
 181     free_xml_string(ns_prefix);
 182
 183     return retVal;
 184 }
 185
 186 static BOOL create_guid(LPWSTR buffer)
 187 {
 188     const WCHAR formatString[] = { 'u','r','n',':','u','u','i','d',':','%','s', 0 };
 189
 190     WCHAR* uuidString = NULL;
 191     UUID uuid;
 192
 193     if (UuidCreate(&uuid) != RPC_S_OK)
 194         return FALSE;
 195
 196     UuidToStringW(&uuid, (RPC_WSTR*)&uuidString);
 197
 198     if (uuidString == NULL)
 199         return FALSE;
 200
 201     wsprintfW(buffer, formatString, uuidString);
 202     RpcStringFreeW((RPC_WSTR*)&uuidString);
 203
 204     return TRUE;
 205 }
 206
 207 static void populate_soap_header(WSD_SOAP_HEADER *header, LPCWSTR to, LPCWSTR action, LPCWSTR message_id,
 208     WSD_APP_SEQUENCE *sequence, const WSDXML_ELEMENT *any_headers)
 209 {
 210     ZeroMemory(header, sizeof(WSD_SOAP_HEADER));
 211
 212     header->To = to;
 213     header->Action = action;
 214     header->MessageID = message_id;
 215     header->AppSequence = sequence;
 216     header->AnyHeaders = (WSDXML_ELEMENT *)any_headers;
 217
 218     /* TODO: Implement RelatesTo, ReplyTo, From, FaultTo */
 219 }
 220
 221 static WSDXML_ELEMENT *create_soap_header_xml_elements(IWSDXMLContext *xml_context, WSD_SOAP_HEADER *header)
 222 {
 223     /* TODO: Implement header generation */
 224     return NULL;
 225 }
 226
 227 static HRESULT create_soap_envelope(IWSDXMLContext *xml_context, WSD_SOAP_HEADER *header, WSDXML_ELEMENT *body_element,
 228     WS_HEAP **heap, char **output_xml, ULONG *xml_length, struct list *discovered_namespaces)
 229 {
 230     WS_XML_STRING *actual_envelope_prefix = NULL, *envelope_uri_xmlstr = NULL;
 231     WSDXML_NAMESPACE *addressing_ns = NULL, *discovery_ns = NULL, *envelope_ns = NULL;
 232     WSDXML_ELEMENT *header_element = NULL;
 233     WS_XML_BUFFER *buffer = NULL;
 234     WS_XML_WRITER *writer = NULL;
 235     WS_XML_STRING envelope;
 236     HRESULT ret = E_OUTOFMEMORY;
 237     static BYTE envelopeString[] = "Envelope";
 238
 239     /* Create the necessary XML prefixes */
 240     if (FAILED(IWSDXMLContext_AddNamespace(xml_context, addressingNsUri, addressingPrefix, &addressing_ns))) goto cleanup;
 241
 242     if (FAILED(IWSDXMLContext_AddNamespace(xml_context, discoveryNsUri, discoveryPrefix, &discovery_ns))) goto cleanup;
 243
 244     if (FAILED(IWSDXMLContext_AddNamespace(xml_context, envelopeNsUri, envelopePrefix, &envelope_ns))) goto cleanup;
 245
 246     envelope.bytes = envelopeString;
 247     envelope.length = sizeof(envelopeString) - 1;
 248     envelope.dictionary = NULL;
 249     envelope.id = 0;
 250
 251     actual_envelope_prefix = populate_xml_string(envelope_ns->PreferredPrefix);
 252     envelope_uri_xmlstr = populate_xml_string(envelope_ns->Uri);
 253
 254     if ((actual_envelope_prefix == NULL) || (envelope_uri_xmlstr == NULL)) goto cleanup;
 255
 256     /* Now try to create the appropriate WebServices buffers, etc */
 257     ret = WsCreateHeap(16384, 4096, NULL, 0, heap, NULL);
 258     if (FAILED(ret)) goto cleanup;
 259
 260     ret = WsCreateXmlBuffer(*heap, NULL, 0, &buffer, NULL);
 261     if (FAILED(ret)) goto cleanup;
 262
 263     ret = WsCreateWriter(NULL, 0, &writer, NULL);
 264     if (FAILED(ret)) goto cleanup;
 265
 266     ret = WsSetOutputToBuffer(writer, buffer, NULL, 0, NULL);
 267     if (FAILED(ret)) goto cleanup;
 268
 269     /* Create the header XML elements */
 270     header_element = create_soap_header_xml_elements(xml_context, header);
 271     if (header_element == NULL) goto cleanup;
 272
 273     /* <s:Envelope> */
 274     ret = WsWriteStartElement(writer, actual_envelope_prefix, &envelope, envelope_uri_xmlstr, NULL);
 275     if (FAILED(ret)) goto cleanup;
 276
 277     /* Write the header */
 278     if (!write_xml_element(header_element, writer)) goto cleanup;
 279
 280     ret = WsWriteEndElement(writer, NULL);
 281     if (FAILED(ret)) goto cleanup;
 282
 283     /* </s:Envelope> */
 284
 285     /* Generate the bytes of the document */
 286     ret = WsWriteXmlBufferToBytes(writer, buffer, NULL, NULL, 0, *heap, (void**)output_xml, xml_length, NULL);
 287     if (FAILED(ret)) goto cleanup;
 288
 289 cleanup:
 290     WSDFreeLinkedMemory(addressing_ns);
 291     WSDFreeLinkedMemory(discovery_ns);
 292     WSDFreeLinkedMemory(envelope_ns);
 293
 294     WSDXMLCleanupElement(header_element);
 295
 296     free_xml_string(actual_envelope_prefix);
 297     free_xml_string(envelope_uri_xmlstr);
 298
 299     if (writer != NULL)
 300         WsFreeWriter(writer);
 301
 302     /* Don't free the heap unless the operation has failed */
 303     if ((FAILED(ret)) && (*heap != NULL))
 304     {
 305         WsFreeHeap(*heap);
 306         *heap = NULL;
 307     }
 308
 309     return ret;
 310 }
 311
 312 static HRESULT write_and_send_message(IWSDiscoveryPublisherImpl *impl, WSD_SOAP_HEADER *header, WSDXML_ELEMENT *body_element,
 313     struct list *discovered_namespaces, IWSDUdpAddress *remote_address, int max_initial_delay)
 314 {
 315     static const char xml_header[] = "<?xml version=\"1.0\" encoding=\"utf-8\"?>";
 316     ULONG xml_length = 0, xml_header_len = sizeof(xml_header) - 1;
 317     WS_HEAP *heap = NULL;
 318     char *xml = NULL;
 319     char *full_xml;
 320     HRESULT ret;
 321
 322     ret = create_soap_envelope(impl->xmlContext, header, NULL, &heap, &xml, &xml_length, NULL);
 323     if (ret != S_OK) return ret;
 324
 325     /* Prefix the XML header */
 326     full_xml = heap_alloc(xml_length + xml_header_len + 1);
 327
 328     if (full_xml == NULL)
 329     {
 330         WsFreeHeap(heap);
 331         return E_OUTOFMEMORY;
 332     }
 333
 334     memcpy(full_xml, xml_header, xml_header_len);
 335     memcpy(full_xml + xml_header_len, xml, xml_length);
 336     full_xml[xml_length + xml_header_len] = 0;
 337
 338     if (remote_address == NULL)
 339     {
 340         /* Send the message via UDP multicast */
 341         ret = send_udp_multicast(impl, full_xml, xml_length + xml_header_len + 1, max_initial_delay) ? S_OK : E_FAIL;
 342     }
 343     else
 344     {
 345         /* TODO: Send the message via UDP unicast */
 346         FIXME("TODO: Send the message via UDP unicast\n");
 347     }
 348
 349     heap_free(full_xml);
 350     WsFreeHeap(heap);
 351
 352     return ret;
 353 }
 354
 355 HRESULT send_hello_message(IWSDiscoveryPublisherImpl *impl, LPCWSTR id, ULONGLONG metadata_ver, ULONGLONG instance_id,
 356     ULONGLONG msg_num, LPCWSTR session_id, const WSD_NAME_LIST *types_list, const WSD_URI_LIST *scopes_list,
 357     const WSD_URI_LIST *xaddrs_list, const WSDXML_ELEMENT *hdr_any, const WSDXML_ELEMENT *ref_param_any,
 358     const WSDXML_ELEMENT *endpoint_ref_any, const WSDXML_ELEMENT *any)
 359 {
 360     WSD_SOAP_HEADER soapHeader;
 361     WSD_APP_SEQUENCE sequence;
 362     WCHAR message_id[64];
 363     HRESULT ret = E_OUTOFMEMORY;
 364
 365     sequence.InstanceId = instance_id;
 366     sequence.MessageNumber = msg_num;
 367     sequence.SequenceId = session_id;
 368
 369     if (!create_guid(message_id)) goto cleanup;
 370
 371     populate_soap_header(&soapHeader, discoveryTo, actionHello, message_id, &sequence, hdr_any);
 372
 373     /* TODO: Populate message body */
 374
 375     /* Write and send the message */
 376     ret = write_and_send_message(impl, &soapHeader, NULL, NULL, NULL, APP_MAX_DELAY);
 377
 378 cleanup:
 379     return ret;
 380 }