dlls/wsdapi/tests/discovery.c

   1 /*
   2  * Web Services on Devices
   3  * Discovery tests
   4  *
   5  * Copyright 2017-2018 Owen Rudge for CodeWeavers
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21
  22 #define COBJMACROS
  23
  24 #include <winsock2.h>
  25 #include <ws2tcpip.h>
  26 #include <windows.h>
  27
  28 #include "wine/test.h"
  29 #include "wine/heap.h"
  30 #include "initguid.h"
  31 #include "objbase.h"
  32 #include "wsdapi.h"
  33 #include <netfw.h>
  34 #include <iphlpapi.h>
  35 #include <stdio.h>
  36
  37 #define SEND_ADDRESS_IPV4   "239.255.255.250"
  38 #define SEND_ADDRESS_IPV6   "FF02::C"
  39 #define SEND_PORT           "3702"
  40
  41 static const char *publisherId = "urn:uuid:3AE5617D-790F-408A-9374-359A77F924A3";
  42 static const char *sequenceId = "urn:uuid:b14de351-72fc-4453-96f9-e58b0c9faf38";
  43
  44 static const char testProbeMessage[] = "<?xml version=\"1.0\" encoding=\"utf-8\"?>"
  45     "<soap:Envelope xmlns:soap=\"http://www.w3.org/2003/05/soap-envelope\" "
  46     "xmlns:wsa=\"http://schemas.xmlsoap.org/ws/2004/08/addressing\" "
  47     "xmlns:wsd=\"http://schemas.xmlsoap.org/ws/2005/04/discovery\" "
  48     "xmlns:grog=\"http://more.tests/\"><soap:Header><wsa:To>urn:schemas-xmlsoap-org:ws:2005:04:discovery</wsa:To>"
  49     "<wsa:Action>http://schemas.xmlsoap.org/ws/2005/04/discovery/Probe</wsa:Action>"
  50     "<wsa:MessageID>urn:uuid:%s</wsa:MessageID>"
  51     "<grog:Perry>ExtraInfo</grog:Perry></soap:Header>"
  52     "<soap:Body><wsd:Probe><wsd:Types>grog:Cider</wsd:Types><grog:Lager>MoreInfo</grog:Lager></wsd:Probe></soap:Body></soap:Envelope>";
  53
  54 static const WCHAR discoveryTo[] = {
  55     'u','r','n',':',
  56     's','c','h','e','m','a','s','-','x','m','l','s','o','a','p','-','o','r','g',':',
  57     'w','s',':','2','0','0','5',':','0','4',':',
  58     'd','i','s','c','o','v','e','r','y', 0 };
  59
  60 static const WCHAR actionProbe[] = {
  61     'h','t','t','p',':','/','/',
  62     's','c','h','e','m','a','s','.','x','m','l','s','o','a','p','.','o','r','g','/',
  63     'w','s','/','2','0','0','5','/','0','4','/',
  64     'd','i','s','c','o','v','e','r','y','/',
  65     'P','r','o','b','e', 0 };
  66
  67 static const WCHAR uri_more_tests[] = { 'h','t','t','p',':','/','/','m','o','r','e','.','t','e','s','t','s','/', 0 };
  68 static const WCHAR uri_more_tests_no_slash[] = { 'h','t','t','p',':','/','/','m','o','r','e','.','t','e','s','t','s', 0 };
  69 static const WCHAR prefix_grog[] = { 'g','r','o','g', 0 };
  70 static const WCHAR name_cider[] = { 'C','i','d','e','r', 0 };
  71
  72 static HANDLE probe_event = NULL;
  73 static UUID probe_message_id;
  74
  75 #define MAX_CACHED_MESSAGES     5
  76 #define MAX_LISTENING_THREADS  20
  77
  78 typedef struct messageStorage {
  79     BOOL                  running;
  80     CRITICAL_SECTION      criticalSection;
  81     char*                 messages[MAX_CACHED_MESSAGES];
  82     int                   messageCount;
  83     HANDLE                threadHandles[MAX_LISTENING_THREADS];
  84     int                   numThreadHandles;
  85 } messageStorage;
  86
  87 static LPWSTR utf8_to_wide(const char *utf8String)
  88 {
  89     int sizeNeeded = 0, utf8StringLength = 0, memLength = 0;
  90     LPWSTR newString = NULL;
  91
  92     if (utf8String == NULL) return NULL;
  93     utf8StringLength = lstrlenA(utf8String);
  94
  95     sizeNeeded = MultiByteToWideChar(CP_UTF8, 0, utf8String, utf8StringLength, NULL, 0);
  96     if (sizeNeeded <= 0) return NULL;
  97
  98     memLength = sizeof(WCHAR) * (sizeNeeded + 1);
  99     newString = heap_alloc_zero(memLength);
 100
 101     MultiByteToWideChar(CP_UTF8, 0, utf8String, utf8StringLength, newString, sizeNeeded);
 102     return newString;
 103 }
 104
 105 static int join_multicast_group(SOCKET s, struct addrinfo *group, struct addrinfo *iface)
 106 {
 107     int level, optname, optlen;
 108     struct ipv6_mreq mreqv6;
 109     struct ip_mreq mreqv4;
 110     char *optval;
 111
 112     if (group->ai_family == AF_INET6)
 113     {
 114         level = IPPROTO_IPV6;
 115         optname = IPV6_ADD_MEMBERSHIP;
 116         optval = (char *)&mreqv6;
 117         optlen = sizeof(mreqv6);
 118
 119         mreqv6.ipv6mr_multiaddr = ((SOCKADDR_IN6 *)group->ai_addr)->sin6_addr;
 120         mreqv6.ipv6mr_interface = ((SOCKADDR_IN6 *)iface->ai_addr)->sin6_scope_id;
 121     }
 122     else
 123     {
 124         level = IPPROTO_IP;
 125         optname = IP_ADD_MEMBERSHIP;
 126         optval = (char *)&mreqv4;
 127         optlen = sizeof(mreqv4);
 128
 129         mreqv4.imr_multiaddr.s_addr = ((SOCKADDR_IN *)group->ai_addr)->sin_addr.s_addr;
 130         mreqv4.imr_interface.s_addr = ((SOCKADDR_IN *)iface->ai_addr)->sin_addr.s_addr;
 131     }
 132
 133     return setsockopt(s, level, optname, optval, optlen);
 134 }
 135
 136 static int set_send_interface(SOCKET s, struct addrinfo *iface)
 137 {
 138     int level, optname, optlen;
 139     char *optval = NULL;
 140
 141     if (iface->ai_family == AF_INET6)
 142     {
 143         level = IPPROTO_IPV6;
 144         optname = IPV6_MULTICAST_IF;
 145         optval = (char *) &((SOCKADDR_IN6 *)iface->ai_addr)->sin6_scope_id;
 146         optlen = sizeof(((SOCKADDR_IN6 *)iface->ai_addr)->sin6_scope_id);
 147     }
 148     else
 149     {
 150         level = IPPROTO_IP;
 151         optname = IP_MULTICAST_IF;
 152         optval = (char *) &((SOCKADDR_IN *)iface->ai_addr)->sin_addr.s_addr;
 153         optlen = sizeof(((SOCKADDR_IN *)iface->ai_addr)->sin_addr.s_addr);
 154     }
 155
 156     return setsockopt(s, level, optname, optval, optlen);
 157 }
 158
 159 static struct addrinfo *resolve_address(const char *address, const char *port, int family, int type, int protocol)
 160 {
 161     struct addrinfo hints, *result = NULL;
 162
 163     ZeroMemory(&hints, sizeof(hints));
 164
 165     hints.ai_flags = AI_PASSIVE;
 166     hints.ai_family = family;
 167     hints.ai_socktype = type;
 168     hints.ai_protocol = protocol;
 169
 170     return getaddrinfo(address, port, &hints, &result) == 0 ? result : NULL;
 171 }
 172
 173 typedef struct listenerThreadParams
 174 {
 175     messageStorage *msgStorage;
 176     SOCKET listeningSocket;
 177 } listenerThreadParams;
 178
 179 #define RECEIVE_BUFFER_SIZE        65536
 180
 181 static DWORD WINAPI listening_thread(LPVOID lpParam)
 182 {
 183     listenerThreadParams *parameter = (listenerThreadParams *)lpParam;
 184     messageStorage *msgStorage = parameter->msgStorage;
 185     int bytesReceived;
 186     char *buffer;
 187
 188     buffer = heap_alloc(RECEIVE_BUFFER_SIZE);
 189
 190     while (parameter->msgStorage->running)
 191     {
 192         ZeroMemory(buffer, RECEIVE_BUFFER_SIZE);
 193         bytesReceived = recv(parameter->listeningSocket, buffer, RECEIVE_BUFFER_SIZE, 0);
 194
 195         if (bytesReceived == SOCKET_ERROR)
 196         {
 197             if (WSAGetLastError() != WSAETIMEDOUT)
 198                 return 0;
 199         }
 200         else
 201         {
 202             EnterCriticalSection(&msgStorage->criticalSection);
 203
 204             if (msgStorage->messageCount < MAX_CACHED_MESSAGES)
 205             {
 206                 msgStorage->messages[msgStorage->messageCount] = heap_alloc(bytesReceived);
 207
 208                 if (msgStorage->messages[msgStorage->messageCount] != NULL)
 209                 {
 210                     memcpy(msgStorage->messages[msgStorage->messageCount], buffer, bytesReceived);
 211                     msgStorage->messageCount++;
 212                 }
 213             }
 214
 215             LeaveCriticalSection(&msgStorage->criticalSection);
 216
 217             if (msgStorage->messageCount >= MAX_CACHED_MESSAGES)
 218             {
 219                 /* Stop all threads */
 220                 msgStorage->running = FALSE;
 221                 break;
 222             }
 223         }
 224     }
 225
 226     closesocket(parameter->listeningSocket);
 227
 228     heap_free(buffer);
 229     heap_free(parameter);
 230
 231     return 0;
 232 }
 233
 234 static void start_listening(messageStorage *msgStorage, const char *multicastAddress, const char *bindAddress)
 235 {
 236     struct addrinfo *multicastAddr = NULL, *bindAddr = NULL, *interfaceAddr = NULL;
 237     listenerThreadParams *parameter = NULL;
 238     const DWORD receiveTimeout = 500;
 239     const UINT reuseAddr = 1;
 240     HANDLE hThread;
 241     SOCKET s = 0;
 242
 243     /* Resolve the multicast address */
 244     multicastAddr = resolve_address(multicastAddress, SEND_PORT, AF_UNSPEC, SOCK_DGRAM, IPPROTO_UDP);
 245     if (multicastAddr == NULL) goto cleanup;
 246
 247     /* Resolve the binding address */
 248     bindAddr = resolve_address(bindAddress, SEND_PORT, multicastAddr->ai_family, multicastAddr->ai_socktype, multicastAddr->ai_protocol);
 249     if (bindAddr == NULL) goto cleanup;
 250
 251     /* Resolve the multicast interface */
 252     interfaceAddr = resolve_address(bindAddress, "0", multicastAddr->ai_family, multicastAddr->ai_socktype, multicastAddr->ai_protocol);
 253     if (interfaceAddr == NULL) goto cleanup;
 254
 255     /* Create the socket */
 256     s = socket(multicastAddr->ai_family, multicastAddr->ai_socktype, multicastAddr->ai_protocol);
 257     if (s == INVALID_SOCKET) goto cleanup;
 258
 259     /* Ensure the socket can be reused */
 260     if (setsockopt(s, SOL_SOCKET, SO_REUSEADDR, (const char *)&reuseAddr, sizeof(reuseAddr)) == SOCKET_ERROR) goto cleanup;
 261
 262     /* Bind the socket to the local interface so we can receive data */
 263     if (bind(s, bindAddr->ai_addr, bindAddr->ai_addrlen) == SOCKET_ERROR) goto cleanup;
 264
 265     /* Join the multicast group */
 266     if (join_multicast_group(s, multicastAddr, interfaceAddr) == SOCKET_ERROR) goto cleanup;
 267
 268     /* Set the outgoing interface */
 269     if (set_send_interface(s, interfaceAddr) == SOCKET_ERROR) goto cleanup;
 270
 271     /* For IPv6, ensure the scope ID is zero */
 272     if (multicastAddr->ai_family == AF_INET6)
 273         ((SOCKADDR_IN6 *)multicastAddr->ai_addr)->sin6_scope_id = 0;
 274
 275     /* Set a 500ms receive timeout */
 276     if (setsockopt(s, SOL_SOCKET, SO_RCVTIMEO, (const char *)&receiveTimeout, sizeof(receiveTimeout)) == SOCKET_ERROR) goto cleanup;
 277
 278     /* Allocate memory for thread parameters */
 279     parameter = heap_alloc(sizeof(listenerThreadParams));
 280
 281     parameter->msgStorage = msgStorage;
 282     parameter->listeningSocket = s;
 283
 284     hThread = CreateThread(NULL, 0, listening_thread, parameter, 0, NULL);
 285     if (hThread == NULL) goto cleanup;
 286
 287     msgStorage->threadHandles[msgStorage->numThreadHandles] = hThread;
 288     msgStorage->numThreadHandles++;
 289
 290     goto cleanup_addresses;
 291
 292 cleanup:
 293     closesocket(s);
 294     heap_free(parameter);
 295
 296 cleanup_addresses:
 297     freeaddrinfo(multicastAddr);
 298     freeaddrinfo(bindAddr);
 299     freeaddrinfo(interfaceAddr);
 300 }
 301
 302 static BOOL start_listening_on_all_addresses(messageStorage *msgStorage, ULONG family)
 303 {
 304     IP_ADAPTER_ADDRESSES *adapterAddresses = NULL, *adapterAddress;
 305     ULONG bufferSize = 0;
 306     LPSOCKADDR sockaddr;
 307     DWORD addressLength;
 308     char address[64];
 309     BOOL ret = FALSE;
 310     ULONG retVal;
 311
 312     retVal = GetAdaptersAddresses(family, 0, NULL, NULL, &bufferSize); /* family should be AF_INET or AF_INET6 */
 313     if (retVal != ERROR_BUFFER_OVERFLOW) goto cleanup;
 314
 315     /* Get size of buffer for adapters */
 316     adapterAddresses = (IP_ADAPTER_ADDRESSES *)heap_alloc(bufferSize);
 317     if (adapterAddresses == NULL) goto cleanup;
 318
 319     /* Get list of adapters */
 320     retVal = GetAdaptersAddresses(family, 0, NULL, adapterAddresses, &bufferSize);
 321     if (retVal != ERROR_SUCCESS) goto cleanup;
 322
 323     for (adapterAddress = adapterAddresses; adapterAddress != NULL; adapterAddress = adapterAddress->Next)
 324     {
 325         if (msgStorage->numThreadHandles >= MAX_LISTENING_THREADS)
 326         {
 327             ret = TRUE;
 328             goto cleanup;
 329         }
 330
 331         if (adapterAddress->FirstUnicastAddress == NULL) continue;
 332
 333         sockaddr = adapterAddress->FirstUnicastAddress->Address.lpSockaddr;
 334         addressLength = sizeof(address);
 335         WSAAddressToStringA(sockaddr, adapterAddress->FirstUnicastAddress->Address.iSockaddrLength, NULL, address, &addressLength);
 336
 337         start_listening(msgStorage, adapterAddress->FirstUnicastAddress->Address.lpSockaddr->sa_family == AF_INET ? SEND_ADDRESS_IPV4 : SEND_ADDRESS_IPV6, address);
 338     }
 339
 340     ret = TRUE;
 341
 342 cleanup:
 343     heap_free(adapterAddresses);
 344     return ret;
 345 }
 346
 347 static BOOL send_udp_multicast_of_type(const char *data, int length, ULONG family)
 348 {
 349     IP_ADAPTER_ADDRESSES *adapter_addresses = NULL, *adapter_addr;
 350     static const struct in6_addr i_addr_zero;
 351     struct addrinfo *multi_address;
 352     ULONG bufferSize = 0;
 353     LPSOCKADDR sockaddr;
 354     BOOL ret = FALSE;
 355     const char ttl = 8;
 356     ULONG retval;
 357     SOCKET s;
 358
 359    /* Resolve the multicast address */
 360     if (family == AF_INET6)
 361         multi_address = resolve_address(SEND_ADDRESS_IPV6, SEND_PORT, AF_INET6, SOCK_DGRAM, IPPROTO_UDP);
 362     else
 363         multi_address = resolve_address(SEND_ADDRESS_IPV4, SEND_PORT, AF_INET, SOCK_DGRAM, IPPROTO_UDP);
 364
 365     if (multi_address == NULL)
 366         return FALSE;
 367
 368     /* Get size of buffer for adapters */
 369     retval = GetAdaptersAddresses(family, 0, NULL, NULL, &bufferSize);
 370     if (retval != ERROR_BUFFER_OVERFLOW) goto cleanup;
 371
 372     adapter_addresses = (IP_ADAPTER_ADDRESSES *) heap_alloc(bufferSize);
 373     if (adapter_addresses == NULL) goto cleanup;
 374
 375     /* Get list of adapters */
 376     retval = GetAdaptersAddresses(family, 0, NULL, adapter_addresses, &bufferSize);
 377     if (retval != ERROR_SUCCESS) goto cleanup;
 378
 379     for (adapter_addr = adapter_addresses; adapter_addr != NULL; adapter_addr = adapter_addr->Next)
 380     {
 381         if (adapter_addr->FirstUnicastAddress == NULL) continue;
 382
 383         sockaddr = adapter_addr->FirstUnicastAddress->Address.lpSockaddr;
 384
 385         /* Create a socket and bind to the adapter address */
 386         s = socket(family, SOCK_DGRAM, IPPROTO_UDP);
 387         if (s == INVALID_SOCKET) continue;
 388
 389         if (bind(s, sockaddr, adapter_addr->FirstUnicastAddress->Address.iSockaddrLength) == SOCKET_ERROR)
 390         {
 391             closesocket(s);
 392             continue;
 393         }
 394
 395         /* Set the multicast interface and TTL value */
 396         setsockopt(s, IPPROTO_IP, IP_MULTICAST_IF, (char *) &i_addr_zero,
 397             (family == AF_INET6) ? sizeof(struct in6_addr) : sizeof(struct in_addr));
 398         setsockopt(s, IPPROTO_IP, IP_MULTICAST_TTL, &ttl, sizeof(ttl));
 399
 400         sendto(s, data, length, 0, (SOCKADDR *) multi_address->ai_addr, multi_address->ai_addrlen);
 401         closesocket(s);
 402     }
 403
 404     ret = TRUE;
 405
 406 cleanup:
 407     freeaddrinfo(multi_address);
 408     heap_free(adapter_addresses);
 409     return ret;
 410 }
 411
 412 typedef struct IWSDiscoveryPublisherNotifyImpl {
 413     IWSDiscoveryPublisherNotify IWSDiscoveryPublisherNotify_iface;
 414     LONG                  ref;
 415 } IWSDiscoveryPublisherNotifyImpl;
 416
 417 static inline IWSDiscoveryPublisherNotifyImpl *impl_from_IWSDiscoveryPublisherNotify(IWSDiscoveryPublisherNotify *iface)
 418 {
 419     return CONTAINING_RECORD(iface, IWSDiscoveryPublisherNotifyImpl, IWSDiscoveryPublisherNotify_iface);
 420 }
 421
 422 static HRESULT WINAPI IWSDiscoveryPublisherNotifyImpl_QueryInterface(IWSDiscoveryPublisherNotify *iface, REFIID riid, void **ppv)
 423 {
 424     IWSDiscoveryPublisherNotifyImpl *This = impl_from_IWSDiscoveryPublisherNotify(iface);
 425
 426     if (!ppv)
 427     {
 428         return E_INVALIDARG;
 429     }
 430
 431     *ppv = NULL;
 432
 433     if (IsEqualIID(riid, &IID_IUnknown) ||
 434         IsEqualIID(riid, &IID_IWSDiscoveryPublisherNotify))
 435     {
 436         *ppv = &This->IWSDiscoveryPublisherNotify_iface;
 437     }
 438     else
 439     {
 440         return E_NOINTERFACE;
 441     }
 442
 443     IUnknown_AddRef((IUnknown*)*ppv);
 444     return S_OK;
 445 }
 446
 447 static ULONG WINAPI IWSDiscoveryPublisherNotifyImpl_AddRef(IWSDiscoveryPublisherNotify *iface)
 448 {
 449     IWSDiscoveryPublisherNotifyImpl *This = impl_from_IWSDiscoveryPublisherNotify(iface);
 450     ULONG ref = InterlockedIncrement(&This->ref);
 451
 452     trace("IWSDiscoveryPublisherNotifyImpl_AddRef called (%p, ref = %d)\n", This, ref);
 453     return ref;
 454 }
 455
 456 static ULONG WINAPI IWSDiscoveryPublisherNotifyImpl_Release(IWSDiscoveryPublisherNotify *iface)
 457 {
 458     IWSDiscoveryPublisherNotifyImpl *This = impl_from_IWSDiscoveryPublisherNotify(iface);
 459     ULONG ref = InterlockedDecrement(&This->ref);
 460
 461     trace("IWSDiscoveryPublisherNotifyImpl_Release called (%p, ref = %d)\n", This, ref);
 462
 463     if (ref == 0)
 464     {
 465         HeapFree(GetProcessHeap(), 0, This);
 466     }
 467
 468     return ref;
 469 }
 470
 471 static void verify_wsdxml_name(const char *debug_prefix, WSDXML_NAME *name, LPCWSTR uri, LPCWSTR prefix,
 472     LPCWSTR local_name)
 473 {
 474     ok(name != NULL, "%s: name == NULL\n", debug_prefix);
 475     if (name == NULL) return;
 476
 477     ok(name->LocalName != NULL && lstrcmpW(name->LocalName, local_name) == 0,
 478         "%s: Local name = '%s'\n", debug_prefix, wine_dbgstr_w(name->LocalName));
 479
 480     ok(name->Space != NULL, "%s: Space == NULL\n", debug_prefix);
 481     if (name->Space == NULL) return;
 482
 483     ok(name->Space->Uri != NULL && lstrcmpW(name->Space->Uri, uri) == 0,
 484         "%s: URI == '%s'\n", debug_prefix, wine_dbgstr_w(name->Space->Uri));
 485     ok(name->Space->PreferredPrefix != NULL && lstrcmpW(name->Space->PreferredPrefix, prefix) == 0,
 486         "%s: Prefix = '%s'\n", debug_prefix, wine_dbgstr_w(name->Space->PreferredPrefix));
 487 }
 488
 489 static void verify_wsdxml_any_text(const char *debug_prefix, WSDXML_ELEMENT *any, LPCWSTR uri, LPCWSTR prefix,
 490     LPCWSTR local_name, LPCWSTR value)
 491 {
 492     WSDXML_TEXT *child;
 493
 494     ok(any != NULL, "%s: any == NULL\n", debug_prefix);
 495     if (any == NULL) return;
 496
 497     child = (WSDXML_TEXT *) any->FirstChild;
 498
 499     ok(any->Node.Type == ElementType, "%s: Node type == %d\n", debug_prefix, any->Node.Type);
 500     ok(any->Node.Parent == NULL, "%s: Parent == %p\n", debug_prefix, any->Node.Parent);
 501     ok(any->Node.Next == NULL, "%s: Next == %p\n", debug_prefix, any->Node.Next);
 502     verify_wsdxml_name(debug_prefix, any->Name, uri, prefix, local_name);
 503
 504     ok(child != NULL, "%s: First child == NULL\n", debug_prefix);
 505
 506     if (child != NULL)
 507     {
 508         ok(child->Node.Type == TextType, "%s: Node type == %d\n", debug_prefix, child->Node.Type);
 509         ok(child->Node.Parent == any, "%s: Parent == %p\n", debug_prefix, child->Node.Parent);
 510         ok(child->Node.Next == NULL, "%s: Next == %p\n", debug_prefix, child->Node.Next);
 511
 512         if (child->Node.Type == TextType)
 513             ok(child->Text != NULL && lstrcmpW(child->Text, value) == 0,
 514                 "%s: Text == '%s'\n", debug_prefix, wine_dbgstr_w(child->Text));
 515     }
 516 }
 517
 518 static HRESULT WINAPI IWSDiscoveryPublisherNotifyImpl_ProbeHandler(IWSDiscoveryPublisherNotify *This, const WSD_SOAP_MESSAGE *pSoap, IWSDMessageParameters *pMessageParameters)
 519 {
 520     trace("IWSDiscoveryPublisherNotifyImpl_ProbeHandler called (%p, %p, %p)\n", This, pSoap, pMessageParameters);
 521
 522     if (probe_event == NULL)
 523     {
 524         /* We may have received an unrelated probe on the network */
 525         return S_OK;
 526     }
 527
 528     ok(pSoap != NULL, "pSoap == NULL\n");
 529     ok(pMessageParameters != NULL, "pMessageParameters == NULL\n");
 530
 531     if (pSoap != NULL)
 532     {
 533         static const WCHAR perry[] = {'P','e','r','r','y',0};
 534         static const WCHAR extra_info[] = {'E','x','t','r','a','I','n','f','o',0};
 535         WSD_PROBE *probe_msg = (WSD_PROBE *) pSoap->Body;
 536
 537         ok(pSoap->Body != NULL, "pSoap->Body == NULL\n");
 538         ok(pSoap->Header.To != NULL && lstrcmpW(pSoap->Header.To, discoveryTo) == 0,
 539             "pSoap->Header.To == '%s'\n", wine_dbgstr_w(pSoap->Header.To));
 540         ok(pSoap->Header.Action != NULL && lstrcmpW(pSoap->Header.Action, actionProbe) == 0,
 541             "pSoap->Header.Action == '%s'\n", wine_dbgstr_w(pSoap->Header.Action));
 542
 543         ok(pSoap->Header.MessageID != NULL, "pSoap->Header.MessageID == NULL\n");
 544
 545         /* Ensure the message ID is at least 9 characters long (to skip past the 'urn:uuid:' prefix) */
 546         if ((pSoap->Header.MessageID != NULL) && (lstrlenW(pSoap->Header.MessageID) > 9))
 547         {
 548             UUID uuid;
 549             RPC_STATUS ret = UuidFromStringW((LPWSTR)pSoap->Header.MessageID + 9, &uuid);
 550
 551             trace("Received message with UUID '%s' (expected UUID '%s')\n", wine_dbgstr_guid(&uuid),
 552                 wine_dbgstr_guid(&probe_message_id));
 553
 554             /* Check if we've either received a message without a UUID, or the UUID isn't the one we sent. If so,
 555                ignore it and wait for another message. */
 556             if ((ret != RPC_S_OK) || (UuidEqual(&uuid, &probe_message_id, &ret) == FALSE)) return S_OK;
 557         }
 558
 559         verify_wsdxml_any_text("pSoap->Header.AnyHeaders", pSoap->Header.AnyHeaders, uri_more_tests_no_slash,
 560             prefix_grog, perry, extra_info);
 561
 562         if (probe_msg != NULL)
 563         {
 564             static const WCHAR lager[] = {'L','a','g','e','r',0};
 565             static const WCHAR more_info[] = {'M','o','r','e','I','n','f','o',0};
 566
 567             todo_wine ok(probe_msg->Types != NULL, "Probe message Types == NULL\n");
 568
 569             if (probe_msg->Types != NULL)
 570             {
 571                 verify_wsdxml_name("probe_msg->Types->Element", probe_msg->Types->Element, uri_more_tests_no_slash,
 572                     prefix_grog, name_cider);
 573                 ok(probe_msg->Types->Next == NULL, "probe_msg->Types->Next == %p\n", probe_msg->Types->Next);
 574             }
 575
 576             ok(probe_msg->Scopes == NULL, "Probe message Scopes != NULL\n");
 577             verify_wsdxml_any_text("probe_msg->Any", probe_msg->Any, uri_more_tests_no_slash, prefix_grog, lager, more_info);
 578         }
 579     }
 580
 581     SetEvent(probe_event);
 582     return S_OK;
 583 }
 584
 585 static HRESULT WINAPI IWSDiscoveryPublisherNotifyImpl_ResolveHandler(IWSDiscoveryPublisherNotify *This, const WSD_SOAP_MESSAGE *pSoap, IWSDMessageParameters *pMessageParameters)
 586 {
 587     trace("IWSDiscoveryPublisherNotifyImpl_ResolveHandler called (%p, %p, %p)\n", This, pSoap, pMessageParameters);
 588     return S_OK;
 589 }
 590
 591 static const IWSDiscoveryPublisherNotifyVtbl publisherNotify_vtbl =
 592 {
 593     IWSDiscoveryPublisherNotifyImpl_QueryInterface,
 594     IWSDiscoveryPublisherNotifyImpl_AddRef,
 595     IWSDiscoveryPublisherNotifyImpl_Release,
 596     IWSDiscoveryPublisherNotifyImpl_ProbeHandler,
 597     IWSDiscoveryPublisherNotifyImpl_ResolveHandler
 598 };
 599
 600 static BOOL create_discovery_publisher_notify(IWSDiscoveryPublisherNotify **publisherNotify)
 601 {
 602     IWSDiscoveryPublisherNotifyImpl *obj;
 603
 604     *publisherNotify = NULL;
 605
 606     obj = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*obj));
 607
 608     if (!obj)
 609     {
 610         trace("Out of memory creating IWSDiscoveryPublisherNotify\n");
 611         return FALSE;
 612     }
 613
 614     obj->IWSDiscoveryPublisherNotify_iface.lpVtbl = &publisherNotify_vtbl;
 615     obj->ref = 1;
 616
 617     *publisherNotify = &obj->IWSDiscoveryPublisherNotify_iface;
 618
 619     return TRUE;
 620 }
 621
 622 static void CreateDiscoveryPublisher_tests(void)
 623 {
 624     IWSDiscoveryPublisher *publisher = NULL;
 625     IWSDiscoveryPublisher *publisher2;
 626     IUnknown *unknown;
 627     HRESULT rc;
 628     ULONG ref;
 629
 630     rc = WSDCreateDiscoveryPublisher(NULL, NULL);
 631     ok((rc == E_POINTER) || (rc == E_INVALIDARG), "WSDCreateDiscoveryPublisher(NULL, NULL) failed: %08x\n", rc);
 632
 633     rc = WSDCreateDiscoveryPublisher(NULL, &publisher);
 634     ok(rc == S_OK, "WSDCreateDiscoveryPublisher(NULL, &publisher) failed: %08x\n", rc);
 635     ok(publisher != NULL, "WSDCreateDiscoveryPublisher(NULL, &publisher) failed: publisher == NULL\n");
 636
 637     /* Try to query for objects */
 638     rc = IWSDiscoveryPublisher_QueryInterface(publisher, &IID_IUnknown, (LPVOID*)&unknown);
 639     ok(rc == S_OK,"IWSDiscoveryPublisher_QueryInterface(IID_IUnknown) failed: %08x\n", rc);
 640
 641     if (rc == S_OK)
 642         IUnknown_Release(unknown);
 643
 644     rc = IWSDiscoveryPublisher_QueryInterface(publisher, &IID_IWSDiscoveryPublisher, (LPVOID*)&publisher2);
 645     ok(rc == S_OK,"IWSDiscoveryPublisher_QueryInterface(IID_IWSDiscoveryPublisher) failed: %08x\n", rc);
 646
 647     if (rc == S_OK)
 648         IWSDiscoveryPublisher_Release(publisher2);
 649
 650     ref = IWSDiscoveryPublisher_Release(publisher);
 651     ok(ref == 0, "IWSDiscoveryPublisher_Release() has %d references, should have 0\n", ref);
 652 }
 653
 654 static void CreateDiscoveryPublisher_XMLContext_tests(void)
 655 {
 656     IWSDiscoveryPublisher *publisher = NULL;
 657     IWSDXMLContext *xmlContext, *returnedContext;
 658     HRESULT rc;
 659     int ref;
 660
 661     /* Test creating an XML context and supplying it to WSDCreateDiscoveryPublisher */
 662     rc = WSDXMLCreateContext(&xmlContext);
 663     ok(rc == S_OK, "WSDXMLCreateContext failed: %08x\n", rc);
 664
 665     rc = WSDCreateDiscoveryPublisher(xmlContext, &publisher);
 666     ok(rc == S_OK, "WSDCreateDiscoveryPublisher(xmlContext, &publisher) failed: %08x\n", rc);
 667     ok(publisher != NULL, "WSDCreateDiscoveryPublisher(xmlContext, &publisher) failed: publisher == NULL\n");
 668
 669     rc = IWSDiscoveryPublisher_GetXMLContext(publisher, NULL);
 670     ok(rc == E_INVALIDARG, "GetXMLContext returned unexpected value with NULL argument: %08x\n", rc);
 671
 672     rc = IWSDiscoveryPublisher_GetXMLContext(publisher, &returnedContext);
 673     ok(rc == S_OK, "GetXMLContext failed: %08x\n", rc);
 674
 675     ok(xmlContext == returnedContext, "GetXMLContext returned unexpected value: returnedContext == %p\n", returnedContext);
 676
 677     ref = IWSDXMLContext_Release(returnedContext);
 678     ok(ref == 2, "IWSDXMLContext_Release() has %d references, should have 2\n", ref);
 679
 680     ref = IWSDiscoveryPublisher_Release(publisher);
 681     ok(ref == 0, "IWSDiscoveryPublisher_Release() has %d references, should have 0\n", ref);
 682
 683     ref = IWSDXMLContext_Release(returnedContext);
 684     ok(ref == 0, "IWSDXMLContext_Release() has %d references, should have 0\n", ref);
 685
 686     /* Test using a default XML context */
 687     publisher = NULL;
 688     returnedContext = NULL;
 689
 690     rc = WSDCreateDiscoveryPublisher(NULL, &publisher);
 691     ok(rc == S_OK, "WSDCreateDiscoveryPublisher(NULL, &publisher) failed: %08x\n", rc);
 692     ok(publisher != NULL, "WSDCreateDiscoveryPublisher(NULL, &publisher) failed: publisher == NULL\n");
 693
 694     rc = IWSDiscoveryPublisher_GetXMLContext(publisher, &returnedContext);
 695     ok(rc == S_OK, "GetXMLContext failed: %08x\n", rc);
 696
 697     ref = IWSDXMLContext_Release(returnedContext);
 698     ok(ref == 1, "IWSDXMLContext_Release() has %d references, should have 1\n", ref);
 699
 700     ref = IWSDiscoveryPublisher_Release(publisher);
 701     ok(ref == 0, "IWSDiscoveryPublisher_Release() has %d references, should have 0\n", ref);
 702 }
 703
 704 static void Publish_tests(void)
 705 {
 706     IWSDiscoveryPublisher *publisher = NULL;
 707     IWSDiscoveryPublisherNotify *sink1 = NULL, *sink2 = NULL;
 708     IWSDiscoveryPublisherNotifyImpl *sink1Impl = NULL, *sink2Impl = NULL;
 709     char endpointReferenceString[MAX_PATH], app_sequence_string[MAX_PATH];
 710     LPWSTR publisherIdW = NULL, sequenceIdW = NULL;
 711     messageStorage *msgStorage;
 712     WSADATA wsaData;
 713     BOOL messageOK, hello_message_seen = FALSE, endpoint_reference_seen = FALSE, app_sequence_seen = FALSE;
 714     BOOL metadata_version_seen = FALSE, any_header_seen = FALSE, wine_ns_seen = FALSE, body_hello_seen = FALSE;
 715     BOOL any_body_seen = FALSE, types_seen = FALSE, xml_namespaces_seen = FALSE, scopes_seen = FALSE;
 716     BOOL xaddrs_seen = FALSE;
 717     int ret, i;
 718     HRESULT rc;
 719     ULONG ref;
 720     char *msg;
 721     WSDXML_ELEMENT *header_any_element, *body_any_element, *endpoint_any_element, *ref_param_any_element;
 722     WSDXML_NAME header_any_name, another_name;
 723     WSDXML_NAMESPACE ns, ns2;
 724     WCHAR header_any_name_text[] = {'B','e','e','r',0};
 725     static const WCHAR header_any_text[] = {'P','u','b','l','i','s','h','T','e','s','t',0};
 726     static const WCHAR body_any_text[] = {'B','o','d','y','T','e','s','t',0};
 727     static const WCHAR endpoint_any_text[] = {'E','n','d','P','T','e','s','t',0};
 728     static const WCHAR ref_param_any_text[] = {'R','e','f','P','T','e','s','t',0};
 729     static const WCHAR uri[] = {'h','t','t','p',':','/','/','w','i','n','e','.','t','e','s','t','/',0};
 730     static const WCHAR prefix[] = {'w','i','n','e',0};
 731     static const WCHAR uri3[] = {'h','t','t','p',':','/','/','t','h','i','r','d','.','u','r','l','/',0};
 732     WSD_NAME_LIST types_list;
 733     WSD_URI_LIST scopes_list, xaddrs_list;
 734     unsigned char *probe_uuid_str;
 735
 736     rc = WSDCreateDiscoveryPublisher(NULL, &publisher);
 737     ok(rc == S_OK, "WSDCreateDiscoveryPublisher(NULL, &publisher) failed: %08x\n", rc);
 738     ok(publisher != NULL, "WSDCreateDiscoveryPublisher(NULL, &publisher) failed: publisher == NULL\n");
 739
 740     /* Test SetAddressFamily */
 741     rc = IWSDiscoveryPublisher_SetAddressFamily(publisher, 12345);
 742     ok(rc == E_INVALIDARG, "IWSDiscoveryPublisher_SetAddressFamily(12345) returned unexpected result: %08x\n", rc);
 743
 744     rc = IWSDiscoveryPublisher_SetAddressFamily(publisher, WSDAPI_ADDRESSFAMILY_IPV4);
 745     ok(rc == S_OK, "IWSDiscoveryPublisher_SetAddressFamily(WSDAPI_ADDRESSFAMILY_IPV4) failed: %08x\n", rc);
 746
 747     /* Try to update the address family after already setting it */
 748     rc = IWSDiscoveryPublisher_SetAddressFamily(publisher, WSDAPI_ADDRESSFAMILY_IPV6);
 749     ok(rc == STG_E_INVALIDFUNCTION, "IWSDiscoveryPublisher_SetAddressFamily(WSDAPI_ADDRESSFAMILY_IPV6) returned unexpected result: %08x\n", rc);
 750
 751     /* Create notification sinks */
 752     ok(create_discovery_publisher_notify(&sink1) == TRUE, "create_discovery_publisher_notify failed\n");
 753     ok(create_discovery_publisher_notify(&sink2) == TRUE, "create_discovery_publisher_notify failed\n");
 754
 755     /* Get underlying implementation so we can check the ref count */
 756     sink1Impl = impl_from_IWSDiscoveryPublisherNotify(sink1);
 757     sink2Impl = impl_from_IWSDiscoveryPublisherNotify(sink2);
 758
 759     /* Attempt to unregister sink before registering it */
 760     rc = IWSDiscoveryPublisher_UnRegisterNotificationSink(publisher, sink1);
 761     ok(rc == E_FAIL, "IWSDiscoveryPublisher_UnRegisterNotificationSink returned unexpected result: %08x\n", rc);
 762
 763     /* Register notification sinks */
 764     rc = IWSDiscoveryPublisher_RegisterNotificationSink(publisher, sink1);
 765     ok(rc == S_OK, "IWSDiscoveryPublisher_RegisterNotificationSink failed: %08x\n", rc);
 766     ok(sink1Impl->ref == 2, "Ref count for sink 1 is not as expected: %d\n", sink1Impl->ref);
 767
 768     rc = IWSDiscoveryPublisher_RegisterNotificationSink(publisher, sink2);
 769     ok(rc == S_OK, "IWSDiscoveryPublisher_RegisterNotificationSink failed: %08x\n", rc);
 770     ok(sink2Impl->ref == 2, "Ref count for sink 2 is not as expected: %d\n", sink2Impl->ref);
 771
 772     /* Unregister the first sink */
 773     rc = IWSDiscoveryPublisher_UnRegisterNotificationSink(publisher, sink1);
 774     ok(rc == S_OK, "IWSDiscoveryPublisher_UnRegisterNotificationSink failed: %08x\n", rc);
 775     ok(sink1Impl->ref == 1, "Ref count for sink 1 is not as expected: %d\n", sink1Impl->ref);
 776
 777     /* Set up network listener */
 778     publisherIdW = utf8_to_wide(publisherId);
 779     if (publisherIdW == NULL) goto after_publish_test;
 780
 781     sequenceIdW = utf8_to_wide(sequenceId);
 782     if (sequenceIdW == NULL) goto after_publish_test;
 783
 784     msgStorage = heap_alloc_zero(sizeof(messageStorage));
 785     if (msgStorage == NULL) goto after_publish_test;
 786
 787     msgStorage->running = TRUE;
 788     InitializeCriticalSection(&msgStorage->criticalSection);
 789
 790     ret = WSAStartup(MAKEWORD(2, 2), &wsaData);
 791     ok(ret == 0, "WSAStartup failed (ret = %d)\n", ret);
 792
 793     ret = start_listening_on_all_addresses(msgStorage, AF_INET);
 794     ok(ret == TRUE, "Unable to listen on IPv4 addresses (ret == %d)\n", ret);
 795
 796     /* Create "any" elements for header */
 797     ns.Uri = uri;
 798     ns.PreferredPrefix = prefix;
 799
 800     header_any_name.LocalName = header_any_name_text;
 801     header_any_name.Space = &ns;
 802
 803     rc = WSDXMLBuildAnyForSingleElement(&header_any_name, header_any_text, &header_any_element);
 804     ok(rc == S_OK, "WSDXMLBuildAnyForSingleElement failed with %08x\n", rc);
 805
 806     rc = WSDXMLBuildAnyForSingleElement(&header_any_name, body_any_text, &body_any_element);
 807     ok(rc == S_OK, "WSDXMLBuildAnyForSingleElement failed with %08x\n", rc);
 808
 809     rc = WSDXMLBuildAnyForSingleElement(&header_any_name, endpoint_any_text, &endpoint_any_element);
 810     ok(rc == S_OK, "WSDXMLBuildAnyForSingleElement failed with %08x\n", rc);
 811
 812     rc = WSDXMLBuildAnyForSingleElement(&header_any_name, ref_param_any_text, &ref_param_any_element);
 813     ok(rc == S_OK, "WSDXMLBuildAnyForSingleElement failed with %08x\n", rc);
 814
 815     /* Create types list */
 816     ns2.Uri = uri_more_tests;
 817     ns2.PreferredPrefix = prefix_grog;
 818
 819     another_name.LocalName = (WCHAR *) name_cider;
 820     another_name.Space = &ns2;
 821
 822     types_list.Next = malloc(sizeof(WSD_NAME_LIST));
 823     types_list.Element = &another_name;
 824
 825     types_list.Next->Next = NULL;
 826     types_list.Next->Element = &header_any_name;
 827
 828     /* Create scopes and xaddrs lists */
 829     scopes_list.Next = malloc(sizeof(WSD_URI_LIST));
 830     scopes_list.Element = uri;
 831
 832     scopes_list.Next->Next = NULL;
 833     scopes_list.Next->Element = uri_more_tests;
 834
 835     xaddrs_list.Next = malloc(sizeof(WSD_URI_LIST));
 836     xaddrs_list.Element = uri_more_tests;
 837
 838     xaddrs_list.Next->Next = NULL;
 839     xaddrs_list.Next->Element = uri3;
 840
 841     /* Publish the service */
 842     rc = IWSDiscoveryPublisher_PublishEx(publisher, publisherIdW, 1, 1, 1, sequenceIdW, &types_list, &scopes_list,
 843         &xaddrs_list, header_any_element, ref_param_any_element, NULL, endpoint_any_element, body_any_element);
 844
 845     WSDFreeLinkedMemory(header_any_element);
 846     WSDFreeLinkedMemory(body_any_element);
 847     WSDFreeLinkedMemory(endpoint_any_element);
 848     WSDFreeLinkedMemory(ref_param_any_element);
 849     free(types_list.Next);
 850     free(scopes_list.Next);
 851     free(xaddrs_list.Next);
 852
 853     ok(rc == S_OK, "Publish failed: %08x\n", rc);
 854
 855     /* Wait up to 2 seconds for messages to be received */
 856     if (WaitForMultipleObjects(msgStorage->numThreadHandles, msgStorage->threadHandles, TRUE, 2000) == WAIT_TIMEOUT)
 857     {
 858         /* Wait up to 1 more second for threads to terminate */
 859         msgStorage->running = FALSE;
 860         WaitForMultipleObjects(msgStorage->numThreadHandles, msgStorage->threadHandles, TRUE, 1000);
 861     }
 862
 863     DeleteCriticalSection(&msgStorage->criticalSection);
 864
 865     /* Verify we've received a message */
 866     ok(msgStorage->messageCount >= 1, "No messages received\n");
 867
 868     sprintf(endpointReferenceString, "<wsa:EndpointReference><wsa:Address>%s</wsa:Address><wsa:ReferenceParameters>"
 869         "<wine:Beer>RefPTest</wine:Beer></wsa:ReferenceParameters><wine:Beer>EndPTest</wine:Beer>"
 870         "</wsa:EndpointReference>", publisherId);
 871
 872     sprintf(app_sequence_string, "<wsd:AppSequence InstanceId=\"1\" SequenceId=\"%s\" MessageNumber=\"1\"></wsd:AppSequence>",
 873         sequenceId);
 874
 875     messageOK = FALSE;
 876
 877     /* Check we're received the correct message */
 878     for (i = 0; i < msgStorage->messageCount; i++)
 879     {
 880         msg = msgStorage->messages[i];
 881         messageOK = FALSE;
 882
 883         hello_message_seen = (strstr(msg, "<wsa:Action>http://schemas.xmlsoap.org/ws/2005/04/discovery/Hello</wsa:Action>") != NULL);
 884         endpoint_reference_seen = (strstr(msg, endpointReferenceString) != NULL);
 885         app_sequence_seen = (strstr(msg, app_sequence_string) != NULL);
 886         metadata_version_seen = (strstr(msg, "<wsd:MetadataVersion>1</wsd:MetadataVersion>") != NULL);
 887         any_header_seen = (strstr(msg, "<wine:Beer>PublishTest</wine:Beer>") != NULL);
 888         wine_ns_seen = (strstr(msg, "xmlns:wine=\"http://wine.test/\"") != NULL);
 889         body_hello_seen = (strstr(msg, "<soap:Body><wsd:Hello") != NULL);
 890         any_body_seen = (strstr(msg, "<wine:Beer>BodyTest</wine:Beer>") != NULL);
 891         types_seen = (strstr(msg, "<wsd:Types>grog:Cider wine:Beer</wsd:Types>") != NULL);
 892         scopes_seen = (strstr(msg, "<wsd:Scopes>http://wine.test/ http://more.tests/</wsd:Scopes>") != NULL);
 893         xaddrs_seen = (strstr(msg, "<wsd:XAddrs>http://more.tests/ http://third.url/</wsd:XAddrs>") != NULL);
 894         xml_namespaces_seen = (strstr(msg, "xmlns:wine=\"http://wine.test/\" xmlns:grog=\"http://more.tests/\"") != NULL);
 895         messageOK = hello_message_seen && endpoint_reference_seen && app_sequence_seen && metadata_version_seen &&
 896             any_header_seen && wine_ns_seen && body_hello_seen && any_body_seen && types_seen && xml_namespaces_seen &&
 897             scopes_seen && xaddrs_seen;
 898
 899         if (messageOK) break;
 900     }
 901
 902     for (i = 0; i < msgStorage->messageCount; i++)
 903     {
 904         heap_free(msgStorage->messages[i]);
 905     }
 906
 907     heap_free(msgStorage);
 908
 909     ok(hello_message_seen == TRUE, "Hello message not received\n");
 910     ok(endpoint_reference_seen == TRUE, "EndpointReference not received\n");
 911     ok(app_sequence_seen == TRUE, "AppSequence not received\n");
 912     ok(metadata_version_seen == TRUE, "MetadataVersion not received\n");
 913     ok(messageOK == TRUE, "Hello message metadata not received\n");
 914     ok(any_header_seen == TRUE, "Custom header not received\n");
 915     ok(wine_ns_seen == TRUE, "Wine namespace not received\n");
 916     ok(body_hello_seen == TRUE, "Body and Hello elements not received\n");
 917     ok(any_body_seen == TRUE, "Custom body element not received\n");
 918     ok(types_seen == TRUE, "Types not received\n");
 919     ok(xml_namespaces_seen == TRUE, "XML namespaces not received\n");
 920     ok(scopes_seen == TRUE, "Scopes not received\n");
 921     ok(xaddrs_seen == TRUE, "XAddrs not received\n");
 922
 923 after_publish_test:
 924
 925     heap_free(publisherIdW);
 926     heap_free(sequenceIdW);
 927
 928     /* Test the receiving of a probe message */
 929     probe_event = CreateEventW(NULL, TRUE, FALSE, NULL);
 930
 931     UuidCreate(&probe_message_id);
 932     UuidToStringA(&probe_message_id, &probe_uuid_str);
 933
 934     ok(probe_uuid_str != NULL, "Failed to create UUID for probe message\n");
 935
 936     if (probe_uuid_str != NULL)
 937     {
 938         char probe_message[sizeof(testProbeMessage) + 50];
 939         sprintf(probe_message, testProbeMessage, probe_uuid_str);
 940
 941         ok(send_udp_multicast_of_type(probe_message, strlen(probe_message), AF_INET) == TRUE, "Sending Probe message failed\n");
 942         ok(WaitForSingleObject(probe_event, 2000) == WAIT_OBJECT_0, "Probe message not received\n");
 943
 944         RpcStringFreeA(&probe_uuid_str);
 945     }
 946
 947     CloseHandle(probe_event);
 948
 949     ref = IWSDiscoveryPublisher_Release(publisher);
 950     ok(ref == 0, "IWSDiscoveryPublisher_Release() has %d references, should have 0\n", ref);
 951
 952     /* Check that the sinks have been released by the publisher */
 953     ok(sink1Impl->ref == 1, "Ref count for sink 1 is not as expected: %d\n", sink1Impl->ref);
 954     ok(sink2Impl->ref == 1, "Ref count for sink 2 is not as expected: %d\n", sink2Impl->ref);
 955
 956     /* Release the sinks */
 957     IWSDiscoveryPublisherNotify_Release(sink1);
 958     IWSDiscoveryPublisherNotify_Release(sink2);
 959
 960     WSACleanup();
 961 }
 962
 963 static void UnPublish_tests(void)
 964 {
 965     IWSDiscoveryPublisher *publisher = NULL;
 966     IWSDiscoveryPublisherNotify *sink1 = NULL;
 967     char endpoint_reference_string[MAX_PATH], app_sequence_string[MAX_PATH];
 968     LPWSTR publisherIdW = NULL, sequenceIdW = NULL;
 969     messageStorage *msg_storage;
 970     WSADATA wsa_data;
 971     BOOL message_ok, hello_message_seen = FALSE, endpoint_reference_seen = FALSE, app_sequence_seen = FALSE;
 972     BOOL wine_ns_seen = FALSE, body_hello_seen = FALSE, any_body_seen = FALSE;
 973     int ret, i;
 974     HRESULT rc;
 975     ULONG ref;
 976     char *msg;
 977     WSDXML_ELEMENT *body_any_element;
 978     WSDXML_NAME body_any_name;
 979     WSDXML_NAMESPACE ns;
 980     WCHAR body_any_name_text[] = {'B','e','e','r',0};
 981     static const WCHAR body_any_text[] = {'B','o','d','y','T','e','s','t',0};
 982     static const WCHAR uri[] = {'h','t','t','p',':','/','/','w','i','n','e','.','t','e','s','t','/',0};
 983     static const WCHAR prefix[] = {'w','i','n','e',0};
 984
 985     rc = WSDCreateDiscoveryPublisher(NULL, &publisher);
 986     ok(rc == S_OK, "WSDCreateDiscoveryPublisher(NULL, &publisher) failed: %08x\n", rc);
 987     ok(publisher != NULL, "WSDCreateDiscoveryPublisher(NULL, &publisher) failed: publisher == NULL\n");
 988
 989     rc = IWSDiscoveryPublisher_SetAddressFamily(publisher, WSDAPI_ADDRESSFAMILY_IPV4);
 990     ok(rc == S_OK, "IWSDiscoveryPublisher_SetAddressFamily(WSDAPI_ADDRESSFAMILY_IPV4) failed: %08x\n", rc);
 991
 992     /* Create notification sink */
 993     ok(create_discovery_publisher_notify(&sink1) == TRUE, "create_discovery_publisher_notify failed\n");
 994     rc = IWSDiscoveryPublisher_RegisterNotificationSink(publisher, sink1);
 995     ok(rc == S_OK, "IWSDiscoveryPublisher_RegisterNotificationSink failed: %08x\n", rc);
 996
 997     /* Set up network listener */
 998     publisherIdW = utf8_to_wide(publisherId);
 999     if (publisherIdW == NULL) goto after_unpublish_test;
1000
1001     sequenceIdW = utf8_to_wide(sequenceId);
1002     if (sequenceIdW == NULL) goto after_unpublish_test;
1003
1004     msg_storage = heap_alloc_zero(sizeof(messageStorage));
1005     if (msg_storage == NULL) goto after_unpublish_test;
1006
1007     msg_storage->running = TRUE;
1008     InitializeCriticalSection(&msg_storage->criticalSection);
1009
1010     ret = WSAStartup(MAKEWORD(2, 2), &wsa_data);
1011     ok(ret == 0, "WSAStartup failed (ret = %d)\n", ret);
1012
1013     ret = start_listening_on_all_addresses(msg_storage, AF_INET);
1014     ok(ret == TRUE, "Unable to listen on IPv4 addresses (ret == %d)\n", ret);
1015
1016     /* Create "any" elements for header */
1017     ns.Uri = uri;
1018     ns.PreferredPrefix = prefix;
1019
1020     body_any_name.LocalName = body_any_name_text;
1021     body_any_name.Space = &ns;
1022
1023     rc = WSDXMLBuildAnyForSingleElement(&body_any_name, body_any_text, &body_any_element);
1024     ok(rc == S_OK, "WSDXMLBuildAnyForSingleElement failed with %08x\n", rc);
1025
1026     /* Unpublish the service */
1027     rc = IWSDiscoveryPublisher_UnPublish(publisher, publisherIdW, 1, 1, sequenceIdW, body_any_element);
1028
1029     WSDFreeLinkedMemory(body_any_element);
1030
1031     ok(rc == S_OK, "Unpublish failed: %08x\n", rc);
1032
1033     /* Wait up to 2 seconds for messages to be received */
1034     if (WaitForMultipleObjects(msg_storage->numThreadHandles, msg_storage->threadHandles, TRUE, 2000) == WAIT_TIMEOUT)
1035     {
1036         /* Wait up to 1 more second for threads to terminate */
1037         msg_storage->running = FALSE;
1038         WaitForMultipleObjects(msg_storage->numThreadHandles, msg_storage->threadHandles, TRUE, 1000);
1039     }
1040
1041     DeleteCriticalSection(&msg_storage->criticalSection);
1042
1043     /* Verify we've received a message */
1044     ok(msg_storage->messageCount >= 1, "No messages received\n");
1045
1046     sprintf(endpoint_reference_string, "<wsa:EndpointReference><wsa:Address>%s</wsa:Address></wsa:EndpointReference>",
1047         publisherId);
1048     sprintf(app_sequence_string, "<wsd:AppSequence InstanceId=\"1\" SequenceId=\"%s\" MessageNumber=\"1\"></wsd:AppSequence>",
1049         sequenceId);
1050
1051     message_ok = FALSE;
1052
1053     /* Check we're received the correct message */
1054     for (i = 0; i < msg_storage->messageCount; i++)
1055     {
1056         msg = msg_storage->messages[i];
1057         message_ok = FALSE;
1058
1059         hello_message_seen = (strstr(msg, "<wsa:Action>http://schemas.xmlsoap.org/ws/2005/04/discovery/Bye</wsa:Action>") != NULL);
1060         endpoint_reference_seen = (strstr(msg, endpoint_reference_string) != NULL);
1061         app_sequence_seen = (strstr(msg, app_sequence_string) != NULL);
1062         wine_ns_seen = (strstr(msg, "xmlns:wine=\"http://wine.test/\"") != NULL);
1063         body_hello_seen = (strstr(msg, "<soap:Body><wsd:Bye") != NULL);
1064         any_body_seen = (strstr(msg, "<wine:Beer>BodyTest</wine:Beer>") != NULL);
1065         message_ok = hello_message_seen && endpoint_reference_seen && app_sequence_seen && wine_ns_seen &&
1066             body_hello_seen && any_body_seen;
1067
1068         if (message_ok) break;
1069     }
1070
1071     for (i = 0; i < msg_storage->messageCount; i++)
1072     {
1073         heap_free(msg_storage->messages[i]);
1074     }
1075
1076     heap_free(msg_storage);
1077
1078     ok(hello_message_seen == TRUE, "Bye message not received\n");
1079     ok(endpoint_reference_seen == TRUE, "EndpointReference not received\n");
1080     ok(app_sequence_seen == TRUE, "AppSequence not received\n");
1081     ok(message_ok == TRUE, "Bye message metadata not received\n");
1082     ok(wine_ns_seen == TRUE, "Wine namespace not received\n");
1083     ok(body_hello_seen == TRUE, "Body and Bye elements not received\n");
1084     ok(any_body_seen == TRUE, "Custom body element not received\n");
1085
1086 after_unpublish_test:
1087
1088     heap_free(publisherIdW);
1089     heap_free(sequenceIdW);
1090
1091     ref = IWSDiscoveryPublisher_Release(publisher);
1092     ok(ref == 0, "IWSDiscoveryPublisher_Release() has %d references, should have 0\n", ref);
1093
1094     /* Release the sinks */
1095     IWSDiscoveryPublisherNotify_Release(sink1);
1096
1097     WSACleanup();
1098 }
1099
1100 enum firewall_op
1101 {
1102     APP_ADD,
1103     APP_REMOVE
1104 };
1105
1106 static BOOL is_process_elevated(void)
1107 {
1108     HANDLE token;
1109     if (OpenProcessToken( GetCurrentProcess(), TOKEN_QUERY, &token ))
1110     {
1111         TOKEN_ELEVATION_TYPE type;
1112         DWORD size;
1113         BOOL ret;
1114
1115         ret = GetTokenInformation( token, TokenElevationType, &type, sizeof(type), &size );
1116         CloseHandle( token );
1117         return (ret && type == TokenElevationTypeFull);
1118     }
1119     return FALSE;
1120 }
1121
1122 static BOOL is_firewall_enabled(void)
1123 {
1124     HRESULT hr, init;
1125     INetFwMgr *mgr = NULL;
1126     INetFwPolicy *policy = NULL;
1127     INetFwProfile *profile = NULL;
1128     VARIANT_BOOL enabled = VARIANT_FALSE;
1129
1130     init = CoInitializeEx( 0, COINIT_APARTMENTTHREADED );
1131
1132     hr = CoCreateInstance( &CLSID_NetFwMgr, NULL, CLSCTX_INPROC_SERVER, &IID_INetFwMgr,
1133                            (void **)&mgr );
1134     ok( hr == S_OK, "got %08x\n", hr );
1135     if (hr != S_OK) goto done;
1136
1137     hr = INetFwMgr_get_LocalPolicy( mgr, &policy );
1138     ok( hr == S_OK, "got %08x\n", hr );
1139     if (hr != S_OK) goto done;
1140
1141     hr = INetFwPolicy_get_CurrentProfile( policy, &profile );
1142     if (hr != S_OK) goto done;
1143
1144     hr = INetFwProfile_get_FirewallEnabled( profile, &enabled );
1145     ok( hr == S_OK, "got %08x\n", hr );
1146
1147 done:
1148     if (policy) INetFwPolicy_Release( policy );
1149     if (profile) INetFwProfile_Release( profile );
1150     if (mgr) INetFwMgr_Release( mgr );
1151     if (SUCCEEDED( init )) CoUninitialize();
1152     return (enabled == VARIANT_TRUE);
1153 }
1154
1155 static HRESULT set_firewall( enum firewall_op op )
1156 {
1157     static const WCHAR testW[] = {'w','s','d','a','p','i','_','t','e','s','t',0};
1158     HRESULT hr, init;
1159     INetFwMgr *mgr = NULL;
1160     INetFwPolicy *policy = NULL;
1161     INetFwProfile *profile = NULL;
1162     INetFwAuthorizedApplication *app = NULL;
1163     INetFwAuthorizedApplications *apps = NULL;
1164     BSTR name, image = SysAllocStringLen( NULL, MAX_PATH );
1165
1166     if (!GetModuleFileNameW( NULL, image, MAX_PATH ))
1167     {
1168         SysFreeString( image );
1169         return E_FAIL;
1170     }
1171     init = CoInitializeEx( 0, COINIT_APARTMENTTHREADED );
1172
1173     hr = CoCreateInstance( &CLSID_NetFwMgr, NULL, CLSCTX_INPROC_SERVER, &IID_INetFwMgr,
1174                            (void **)&mgr );
1175     ok( hr == S_OK, "got %08x\n", hr );
1176     if (hr != S_OK) goto done;
1177
1178     hr = INetFwMgr_get_LocalPolicy( mgr, &policy );
1179     ok( hr == S_OK, "got %08x\n", hr );
1180     if (hr != S_OK) goto done;
1181
1182     hr = INetFwPolicy_get_CurrentProfile( policy, &profile );
1183     if (hr != S_OK) goto done;
1184
1185     hr = INetFwProfile_get_AuthorizedApplications( profile, &apps );
1186     ok( hr == S_OK, "got %08x\n", hr );
1187     if (hr != S_OK) goto done;
1188
1189     hr = CoCreateInstance( &CLSID_NetFwAuthorizedApplication, NULL, CLSCTX_INPROC_SERVER,
1190                            &IID_INetFwAuthorizedApplication, (void **)&app );
1191     ok( hr == S_OK, "got %08x\n", hr );
1192     if (hr != S_OK) goto done;
1193
1194     hr = INetFwAuthorizedApplication_put_ProcessImageFileName( app, image );
1195     if (hr != S_OK) goto done;
1196
1197     name = SysAllocString( testW );
1198     hr = INetFwAuthorizedApplication_put_Name( app, name );
1199     SysFreeString( name );
1200     ok( hr == S_OK, "got %08x\n", hr );
1201     if (hr != S_OK) goto done;
1202
1203     if (op == APP_ADD)
1204         hr = INetFwAuthorizedApplications_Add( apps, app );
1205     else if (op == APP_REMOVE)
1206         hr = INetFwAuthorizedApplications_Remove( apps, image );
1207     else
1208         hr = E_INVALIDARG;
1209
1210 done:
1211     if (app) INetFwAuthorizedApplication_Release( app );
1212     if (apps) INetFwAuthorizedApplications_Release( apps );
1213     if (policy) INetFwPolicy_Release( policy );
1214     if (profile) INetFwProfile_Release( profile );
1215     if (mgr) INetFwMgr_Release( mgr );
1216     if (SUCCEEDED( init )) CoUninitialize();
1217     SysFreeString( image );
1218     return hr;
1219 }
1220
1221 START_TEST(discovery)
1222 {
1223     BOOL firewall_enabled = is_firewall_enabled();
1224     HRESULT hr;
1225
1226     if (firewall_enabled)
1227     {
1228         if (!is_process_elevated())
1229         {
1230             skip("no privileges, skipping tests to avoid firewall dialog\n");
1231             return;
1232         }
1233         if ((hr = set_firewall(APP_ADD)) != S_OK)
1234         {
1235             skip("can't authorize app in firewall %08x\n", hr);
1236             return;
1237         }
1238     }
1239
1240     CoInitialize(NULL);
1241
1242     CreateDiscoveryPublisher_tests();
1243     CreateDiscoveryPublisher_XMLContext_tests();
1244     Publish_tests();
1245     UnPublish_tests();
1246
1247     CoUninitialize();
1248     if (firewall_enabled) set_firewall(APP_REMOVE);
1249 }