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 #define MAX_CACHED_MESSAGES     5
  45 #define MAX_LISTENING_THREADS  20
  46
  47 typedef struct messageStorage {
  48     BOOL                  running;
  49     CRITICAL_SECTION      criticalSection;
  50     char*                 messages[MAX_CACHED_MESSAGES];
  51     int                   messageCount;
  52     HANDLE                threadHandles[MAX_LISTENING_THREADS];
  53     int                   numThreadHandles;
  54 } messageStorage;
  55
  56 static LPWSTR utf8_to_wide(const char *utf8String)
  57 {
  58     int sizeNeeded = 0, utf8StringLength = 0, memLength = 0;
  59     LPWSTR newString = NULL;
  60
  61     if (utf8String == NULL) return NULL;
  62     utf8StringLength = lstrlenA(utf8String);
  63
  64     sizeNeeded = MultiByteToWideChar(CP_UTF8, 0, utf8String, utf8StringLength, NULL, 0);
  65     if (sizeNeeded <= 0) return NULL;
  66
  67     memLength = sizeof(WCHAR) * (sizeNeeded + 1);
  68     newString = heap_alloc_zero(memLength);
  69
  70     MultiByteToWideChar(CP_UTF8, 0, utf8String, utf8StringLength, newString, sizeNeeded);
  71     return newString;
  72 }
  73
  74 static int join_multicast_group(SOCKET s, struct addrinfo *group, struct addrinfo *iface)
  75 {
  76     int level, optname, optlen;
  77     struct ipv6_mreq mreqv6;
  78     struct ip_mreq mreqv4;
  79     char *optval;
  80
  81     if (group->ai_family == AF_INET6)
  82     {
  83         level = IPPROTO_IPV6;
  84         optname = IPV6_ADD_MEMBERSHIP;
  85         optval = (char *)&mreqv6;
  86         optlen = sizeof(mreqv6);
  87
  88         mreqv6.ipv6mr_multiaddr = ((SOCKADDR_IN6 *)group->ai_addr)->sin6_addr;
  89         mreqv6.ipv6mr_interface = ((SOCKADDR_IN6 *)iface->ai_addr)->sin6_scope_id;
  90     }
  91     else
  92     {
  93         level = IPPROTO_IP;
  94         optname = IP_ADD_MEMBERSHIP;
  95         optval = (char *)&mreqv4;
  96         optlen = sizeof(mreqv4);
  97
  98         mreqv4.imr_multiaddr.s_addr = ((SOCKADDR_IN *)group->ai_addr)->sin_addr.s_addr;
  99         mreqv4.imr_interface.s_addr = ((SOCKADDR_IN *)iface->ai_addr)->sin_addr.s_addr;
 100     }
 101
 102     return setsockopt(s, level, optname, optval, optlen);
 103 }
 104
 105 static int set_send_interface(SOCKET s, struct addrinfo *iface)
 106 {
 107     int level, optname, optlen;
 108     char *optval = NULL;
 109
 110     if (iface->ai_family == AF_INET6)
 111     {
 112         level = IPPROTO_IPV6;
 113         optname = IPV6_MULTICAST_IF;
 114         optval = (char *) &((SOCKADDR_IN6 *)iface->ai_addr)->sin6_scope_id;
 115         optlen = sizeof(((SOCKADDR_IN6 *)iface->ai_addr)->sin6_scope_id);
 116     }
 117     else
 118     {
 119         level = IPPROTO_IP;
 120         optname = IP_MULTICAST_IF;
 121         optval = (char *) &((SOCKADDR_IN *)iface->ai_addr)->sin_addr.s_addr;
 122         optlen = sizeof(((SOCKADDR_IN *)iface->ai_addr)->sin_addr.s_addr);
 123     }
 124
 125     return setsockopt(s, level, optname, optval, optlen);
 126 }
 127
 128 static struct addrinfo *resolve_address(const char *address, const char *port, int family, int type, int protocol)
 129 {
 130     struct addrinfo hints, *result = NULL;
 131
 132     ZeroMemory(&hints, sizeof(hints));
 133
 134     hints.ai_flags = AI_PASSIVE;
 135     hints.ai_family = family;
 136     hints.ai_socktype = type;
 137     hints.ai_protocol = protocol;
 138
 139     return getaddrinfo(address, port, &hints, &result) == 0 ? result : NULL;
 140 }
 141
 142 typedef struct listenerThreadParams
 143 {
 144     messageStorage *msgStorage;
 145     SOCKET listeningSocket;
 146 } listenerThreadParams;
 147
 148 #define RECEIVE_BUFFER_SIZE        65536
 149
 150 static DWORD WINAPI listening_thread(LPVOID lpParam)
 151 {
 152     listenerThreadParams *parameter = (listenerThreadParams *)lpParam;
 153     messageStorage *msgStorage = parameter->msgStorage;
 154     int bytesReceived;
 155     char *buffer;
 156
 157     buffer = heap_alloc(RECEIVE_BUFFER_SIZE);
 158
 159     while (parameter->msgStorage->running)
 160     {
 161         ZeroMemory(buffer, RECEIVE_BUFFER_SIZE);
 162         bytesReceived = recv(parameter->listeningSocket, buffer, RECEIVE_BUFFER_SIZE, 0);
 163
 164         if (bytesReceived == SOCKET_ERROR)
 165         {
 166             if (WSAGetLastError() != WSAETIMEDOUT)
 167                 return 0;
 168         }
 169         else
 170         {
 171             EnterCriticalSection(&msgStorage->criticalSection);
 172
 173             if (msgStorage->messageCount < MAX_CACHED_MESSAGES)
 174             {
 175                 msgStorage->messages[msgStorage->messageCount] = heap_alloc(bytesReceived);
 176
 177                 if (msgStorage->messages[msgStorage->messageCount] != NULL)
 178                 {
 179                     memcpy(msgStorage->messages[msgStorage->messageCount], buffer, bytesReceived);
 180                     msgStorage->messageCount++;
 181                 }
 182             }
 183
 184             LeaveCriticalSection(&msgStorage->criticalSection);
 185
 186             if (msgStorage->messageCount >= MAX_CACHED_MESSAGES)
 187             {
 188                 /* Stop all threads */
 189                 msgStorage->running = FALSE;
 190                 break;
 191             }
 192         }
 193     }
 194
 195     closesocket(parameter->listeningSocket);
 196
 197     heap_free(buffer);
 198     heap_free(parameter);
 199
 200     return 0;
 201 }
 202
 203 static void start_listening(messageStorage *msgStorage, const char *multicastAddress, const char *bindAddress)
 204 {
 205     struct addrinfo *multicastAddr = NULL, *bindAddr = NULL, *interfaceAddr = NULL;
 206     listenerThreadParams *parameter = NULL;
 207     const DWORD receiveTimeout = 5000;
 208     const UINT reuseAddr = 1;
 209     HANDLE hThread;
 210     SOCKET s = 0;
 211
 212     /* Resolve the multicast address */
 213     multicastAddr = resolve_address(multicastAddress, SEND_PORT, AF_UNSPEC, SOCK_DGRAM, IPPROTO_UDP);
 214     if (multicastAddr == NULL) goto cleanup;
 215
 216     /* Resolve the binding address */
 217     bindAddr = resolve_address(bindAddress, SEND_PORT, multicastAddr->ai_family, multicastAddr->ai_socktype, multicastAddr->ai_protocol);
 218     if (bindAddr == NULL) goto cleanup;
 219
 220     /* Resolve the multicast interface */
 221     interfaceAddr = resolve_address(bindAddress, "0", multicastAddr->ai_family, multicastAddr->ai_socktype, multicastAddr->ai_protocol);
 222     if (interfaceAddr == NULL) goto cleanup;
 223
 224     /* Create the socket */
 225     s = socket(multicastAddr->ai_family, multicastAddr->ai_socktype, multicastAddr->ai_protocol);
 226     if (s == INVALID_SOCKET) goto cleanup;
 227
 228     /* Ensure the socket can be reused */
 229     if (setsockopt(s, SOL_SOCKET, SO_REUSEADDR, (const char *)&reuseAddr, sizeof(reuseAddr)) == SOCKET_ERROR) goto cleanup;
 230
 231     /* Bind the socket to the local interface so we can receive data */
 232     if (bind(s, bindAddr->ai_addr, bindAddr->ai_addrlen) == SOCKET_ERROR) goto cleanup;
 233
 234     /* Join the multicast group */
 235     if (join_multicast_group(s, multicastAddr, interfaceAddr) == SOCKET_ERROR) goto cleanup;
 236
 237     /* Set the outgoing interface */
 238     if (set_send_interface(s, interfaceAddr) == SOCKET_ERROR) goto cleanup;
 239
 240     /* For IPv6, ensure the scope ID is zero */
 241     if (multicastAddr->ai_family == AF_INET6)
 242         ((SOCKADDR_IN6 *)multicastAddr->ai_addr)->sin6_scope_id = 0;
 243
 244     /* Set a 5-second receive timeout */
 245     if (setsockopt(s, SOL_SOCKET, SO_RCVTIMEO, (const char *)&receiveTimeout, sizeof(receiveTimeout)) == SOCKET_ERROR) goto cleanup;
 246
 247     /* Allocate memory for thread parameters */
 248     parameter = heap_alloc(sizeof(listenerThreadParams));
 249
 250     parameter->msgStorage = msgStorage;
 251     parameter->listeningSocket = s;
 252
 253     hThread = CreateThread(NULL, 0, listening_thread, parameter, 0, NULL);
 254     if (hThread == NULL) goto cleanup;
 255
 256     msgStorage->threadHandles[msgStorage->numThreadHandles] = hThread;
 257     msgStorage->numThreadHandles++;
 258
 259     goto cleanup_addresses;
 260
 261 cleanup:
 262     closesocket(s);
 263     heap_free(parameter);
 264
 265 cleanup_addresses:
 266     freeaddrinfo(multicastAddr);
 267     freeaddrinfo(bindAddr);
 268     freeaddrinfo(interfaceAddr);
 269 }
 270
 271 static BOOL start_listening_on_all_addresses(messageStorage *msgStorage, ULONG family)
 272 {
 273     IP_ADAPTER_ADDRESSES *adapterAddresses = NULL, *adapterAddress;
 274     ULONG bufferSize = 0;
 275     LPSOCKADDR sockaddr;
 276     DWORD addressLength;
 277     char address[64];
 278     BOOL ret = FALSE;
 279     ULONG retVal;
 280
 281     retVal = GetAdaptersAddresses(family, 0, NULL, NULL, &bufferSize); /* family should be AF_INET or AF_INET6 */
 282     if (retVal != ERROR_BUFFER_OVERFLOW) goto cleanup;
 283
 284     /* Get size of buffer for adapters */
 285     adapterAddresses = (IP_ADAPTER_ADDRESSES *)heap_alloc(bufferSize);
 286     if (adapterAddresses == NULL) goto cleanup;
 287
 288     /* Get list of adapters */
 289     retVal = GetAdaptersAddresses(family, 0, NULL, adapterAddresses, &bufferSize);
 290     if (retVal != ERROR_SUCCESS) goto cleanup;
 291
 292     for (adapterAddress = adapterAddresses; adapterAddress != NULL; adapterAddress = adapterAddress->Next)
 293     {
 294         if (msgStorage->numThreadHandles >= MAX_LISTENING_THREADS)
 295         {
 296             ret = TRUE;
 297             goto cleanup;
 298         }
 299
 300         if (adapterAddress->FirstUnicastAddress == NULL) continue;
 301
 302         sockaddr = adapterAddress->FirstUnicastAddress->Address.lpSockaddr;
 303         addressLength = sizeof(address);
 304         WSAAddressToStringA(sockaddr, adapterAddress->FirstUnicastAddress->Address.iSockaddrLength, NULL, address, &addressLength);
 305
 306         start_listening(msgStorage, adapterAddress->FirstUnicastAddress->Address.lpSockaddr->sa_family == AF_INET ? SEND_ADDRESS_IPV4 : SEND_ADDRESS_IPV6, address);
 307     }
 308
 309     ret = TRUE;
 310
 311 cleanup:
 312     heap_free(adapterAddresses);
 313     return ret;
 314 }
 315
 316 typedef struct IWSDiscoveryPublisherNotifyImpl {
 317     IWSDiscoveryPublisherNotify IWSDiscoveryPublisherNotify_iface;
 318     LONG                  ref;
 319 } IWSDiscoveryPublisherNotifyImpl;
 320
 321 static inline IWSDiscoveryPublisherNotifyImpl *impl_from_IWSDiscoveryPublisherNotify(IWSDiscoveryPublisherNotify *iface)
 322 {
 323     return CONTAINING_RECORD(iface, IWSDiscoveryPublisherNotifyImpl, IWSDiscoveryPublisherNotify_iface);
 324 }
 325
 326 static HRESULT WINAPI IWSDiscoveryPublisherNotifyImpl_QueryInterface(IWSDiscoveryPublisherNotify *iface, REFIID riid, void **ppv)
 327 {
 328     IWSDiscoveryPublisherNotifyImpl *This = impl_from_IWSDiscoveryPublisherNotify(iface);
 329
 330     if (!ppv)
 331     {
 332         return E_INVALIDARG;
 333     }
 334
 335     *ppv = NULL;
 336
 337     if (IsEqualIID(riid, &IID_IUnknown) ||
 338         IsEqualIID(riid, &IID_IWSDiscoveryPublisherNotify))
 339     {
 340         *ppv = &This->IWSDiscoveryPublisherNotify_iface;
 341     }
 342     else
 343     {
 344         return E_NOINTERFACE;
 345     }
 346
 347     IUnknown_AddRef((IUnknown*)*ppv);
 348     return S_OK;
 349 }
 350
 351 static ULONG WINAPI IWSDiscoveryPublisherNotifyImpl_AddRef(IWSDiscoveryPublisherNotify *iface)
 352 {
 353     IWSDiscoveryPublisherNotifyImpl *This = impl_from_IWSDiscoveryPublisherNotify(iface);
 354     ULONG ref = InterlockedIncrement(&This->ref);
 355
 356     trace("IWSDiscoveryPublisherNotifyImpl_AddRef called (%p, ref = %d)\n", This, ref);
 357     return ref;
 358 }
 359
 360 static ULONG WINAPI IWSDiscoveryPublisherNotifyImpl_Release(IWSDiscoveryPublisherNotify *iface)
 361 {
 362     IWSDiscoveryPublisherNotifyImpl *This = impl_from_IWSDiscoveryPublisherNotify(iface);
 363     ULONG ref = InterlockedDecrement(&This->ref);
 364
 365     trace("IWSDiscoveryPublisherNotifyImpl_Release called (%p, ref = %d)\n", This, ref);
 366
 367     if (ref == 0)
 368     {
 369         HeapFree(GetProcessHeap(), 0, This);
 370     }
 371
 372     return ref;
 373 }
 374
 375 static HRESULT WINAPI IWSDiscoveryPublisherNotifyImpl_ProbeHandler(IWSDiscoveryPublisherNotify *This, const WSD_SOAP_MESSAGE *pSoap, IWSDMessageParameters *pMessageParameters)
 376 {
 377     trace("IWSDiscoveryPublisherNotifyImpl_ProbeHandler called (%p, %p, %p)\n", This, pSoap, pMessageParameters);
 378     return S_OK;
 379 }
 380
 381 static HRESULT WINAPI IWSDiscoveryPublisherNotifyImpl_ResolveHandler(IWSDiscoveryPublisherNotify *This, const WSD_SOAP_MESSAGE *pSoap, IWSDMessageParameters *pMessageParameters)
 382 {
 383     trace("IWSDiscoveryPublisherNotifyImpl_ResolveHandler called (%p, %p, %p)\n", This, pSoap, pMessageParameters);
 384     return S_OK;
 385 }
 386
 387 static const IWSDiscoveryPublisherNotifyVtbl publisherNotify_vtbl =
 388 {
 389     IWSDiscoveryPublisherNotifyImpl_QueryInterface,
 390     IWSDiscoveryPublisherNotifyImpl_AddRef,
 391     IWSDiscoveryPublisherNotifyImpl_Release,
 392     IWSDiscoveryPublisherNotifyImpl_ProbeHandler,
 393     IWSDiscoveryPublisherNotifyImpl_ResolveHandler
 394 };
 395
 396 static BOOL create_discovery_publisher_notify(IWSDiscoveryPublisherNotify **publisherNotify)
 397 {
 398     IWSDiscoveryPublisherNotifyImpl *obj;
 399
 400     *publisherNotify = NULL;
 401
 402     obj = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*obj));
 403
 404     if (!obj)
 405     {
 406         trace("Out of memory creating IWSDiscoveryPublisherNotify\n");
 407         return FALSE;
 408     }
 409
 410     obj->IWSDiscoveryPublisherNotify_iface.lpVtbl = &publisherNotify_vtbl;
 411     obj->ref = 1;
 412
 413     *publisherNotify = &obj->IWSDiscoveryPublisherNotify_iface;
 414
 415     return TRUE;
 416 }
 417
 418 static void CreateDiscoveryPublisher_tests(void)
 419 {
 420     IWSDiscoveryPublisher *publisher = NULL;
 421     IWSDiscoveryPublisher *publisher2;
 422     IUnknown *unknown;
 423     HRESULT rc;
 424     ULONG ref;
 425
 426     rc = WSDCreateDiscoveryPublisher(NULL, NULL);
 427     ok((rc == E_POINTER) || (rc == E_INVALIDARG), "WSDCreateDiscoveryPublisher(NULL, NULL) failed: %08x\n", rc);
 428
 429     rc = WSDCreateDiscoveryPublisher(NULL, &publisher);
 430     ok(rc == S_OK, "WSDCreateDiscoveryPublisher(NULL, &publisher) failed: %08x\n", rc);
 431     ok(publisher != NULL, "WSDCreateDiscoveryPublisher(NULL, &publisher) failed: publisher == NULL\n");
 432
 433     /* Try to query for objects */
 434     rc = IWSDiscoveryPublisher_QueryInterface(publisher, &IID_IUnknown, (LPVOID*)&unknown);
 435     ok(rc == S_OK,"IWSDiscoveryPublisher_QueryInterface(IID_IUnknown) failed: %08x\n", rc);
 436
 437     if (rc == S_OK)
 438         IUnknown_Release(unknown);
 439
 440     rc = IWSDiscoveryPublisher_QueryInterface(publisher, &IID_IWSDiscoveryPublisher, (LPVOID*)&publisher2);
 441     ok(rc == S_OK,"IWSDiscoveryPublisher_QueryInterface(IID_IWSDiscoveryPublisher) failed: %08x\n", rc);
 442
 443     if (rc == S_OK)
 444         IWSDiscoveryPublisher_Release(publisher2);
 445
 446     ref = IWSDiscoveryPublisher_Release(publisher);
 447     ok(ref == 0, "IWSDiscoveryPublisher_Release() has %d references, should have 0\n", ref);
 448 }
 449
 450 static void CreateDiscoveryPublisher_XMLContext_tests(void)
 451 {
 452     IWSDiscoveryPublisher *publisher = NULL;
 453     IWSDXMLContext *xmlContext, *returnedContext;
 454     HRESULT rc;
 455     int ref;
 456
 457     /* Test creating an XML context and supplying it to WSDCreateDiscoveryPublisher */
 458     rc = WSDXMLCreateContext(&xmlContext);
 459     ok(rc == S_OK, "WSDXMLCreateContext failed: %08x\n", rc);
 460
 461     rc = WSDCreateDiscoveryPublisher(xmlContext, &publisher);
 462     ok(rc == S_OK, "WSDCreateDiscoveryPublisher(xmlContext, &publisher) failed: %08x\n", rc);
 463     ok(publisher != NULL, "WSDCreateDiscoveryPublisher(xmlContext, &publisher) failed: publisher == NULL\n");
 464
 465     rc = IWSDiscoveryPublisher_GetXMLContext(publisher, NULL);
 466     ok(rc == E_INVALIDARG, "GetXMLContext returned unexpected value with NULL argument: %08x\n", rc);
 467
 468     rc = IWSDiscoveryPublisher_GetXMLContext(publisher, &returnedContext);
 469     ok(rc == S_OK, "GetXMLContext failed: %08x\n", rc);
 470
 471     ok(xmlContext == returnedContext, "GetXMLContext returned unexpected value: returnedContext == %p\n", returnedContext);
 472
 473     ref = IWSDXMLContext_Release(returnedContext);
 474     ok(ref == 2, "IWSDXMLContext_Release() has %d references, should have 2\n", ref);
 475
 476     ref = IWSDiscoveryPublisher_Release(publisher);
 477     ok(ref == 0, "IWSDiscoveryPublisher_Release() has %d references, should have 0\n", ref);
 478
 479     ref = IWSDXMLContext_Release(returnedContext);
 480     ok(ref == 0, "IWSDXMLContext_Release() has %d references, should have 0\n", ref);
 481
 482     /* Test using a default XML context */
 483     publisher = NULL;
 484     returnedContext = NULL;
 485
 486     rc = WSDCreateDiscoveryPublisher(NULL, &publisher);
 487     ok(rc == S_OK, "WSDCreateDiscoveryPublisher(NULL, &publisher) failed: %08x\n", rc);
 488     ok(publisher != NULL, "WSDCreateDiscoveryPublisher(NULL, &publisher) failed: publisher == NULL\n");
 489
 490     rc = IWSDiscoveryPublisher_GetXMLContext(publisher, &returnedContext);
 491     ok(rc == S_OK, "GetXMLContext failed: %08x\n", rc);
 492
 493     ref = IWSDXMLContext_Release(returnedContext);
 494     ok(ref == 1, "IWSDXMLContext_Release() has %d references, should have 1\n", ref);
 495
 496     ref = IWSDiscoveryPublisher_Release(publisher);
 497     ok(ref == 0, "IWSDiscoveryPublisher_Release() has %d references, should have 0\n", ref);
 498 }
 499
 500 static void Publish_tests(void)
 501 {
 502     IWSDiscoveryPublisher *publisher = NULL;
 503     IWSDiscoveryPublisherNotify *sink1 = NULL, *sink2 = NULL;
 504     IWSDiscoveryPublisherNotifyImpl *sink1Impl = NULL, *sink2Impl = NULL;
 505     char endpointReferenceString[MAX_PATH], app_sequence_string[MAX_PATH];
 506     LPWSTR publisherIdW = NULL, sequenceIdW = NULL;
 507     messageStorage *msgStorage;
 508     WSADATA wsaData;
 509     BOOL messageOK, hello_message_seen = FALSE, endpoint_reference_seen = FALSE, app_sequence_seen = FALSE;
 510     BOOL metadata_version_seen = FALSE, any_header_seen = FALSE, wine_ns_seen = FALSE, body_hello_seen = FALSE;
 511     BOOL any_body_seen = FALSE;
 512     int ret, i;
 513     HRESULT rc;
 514     ULONG ref;
 515     char *msg;
 516     WSDXML_ELEMENT *header_any_element, *body_any_element;
 517     WSDXML_NAME header_any_name;
 518     WSDXML_NAMESPACE ns;
 519     WCHAR header_any_name_text[] = {'B','e','e','r',0};
 520     static const WCHAR header_any_text[] = {'P','u','b','l','i','s','h','T','e','s','t',0};
 521     static const WCHAR body_any_text[] = {'B','o','d','y','T','e','s','t',0};
 522     static const WCHAR uri[] = {'h','t','t','p',':','/','/','w','i','n','e','.','t','e','s','t','/',0};
 523     static const WCHAR prefix[] = {'w','i','n','e',0};
 524
 525     rc = WSDCreateDiscoveryPublisher(NULL, &publisher);
 526     ok(rc == S_OK, "WSDCreateDiscoveryPublisher(NULL, &publisher) failed: %08x\n", rc);
 527     ok(publisher != NULL, "WSDCreateDiscoveryPublisher(NULL, &publisher) failed: publisher == NULL\n");
 528
 529     /* Test SetAddressFamily */
 530     rc = IWSDiscoveryPublisher_SetAddressFamily(publisher, 12345);
 531     ok(rc == E_INVALIDARG, "IWSDiscoveryPublisher_SetAddressFamily(12345) returned unexpected result: %08x\n", rc);
 532
 533     rc = IWSDiscoveryPublisher_SetAddressFamily(publisher, WSDAPI_ADDRESSFAMILY_IPV4);
 534     ok(rc == S_OK, "IWSDiscoveryPublisher_SetAddressFamily(WSDAPI_ADDRESSFAMILY_IPV4) failed: %08x\n", rc);
 535
 536     /* Try to update the address family after already setting it */
 537     rc = IWSDiscoveryPublisher_SetAddressFamily(publisher, WSDAPI_ADDRESSFAMILY_IPV6);
 538     ok(rc == STG_E_INVALIDFUNCTION, "IWSDiscoveryPublisher_SetAddressFamily(WSDAPI_ADDRESSFAMILY_IPV6) returned unexpected result: %08x\n", rc);
 539
 540     /* Create notification sinks */
 541     ok(create_discovery_publisher_notify(&sink1) == TRUE, "create_discovery_publisher_notify failed\n");
 542     ok(create_discovery_publisher_notify(&sink2) == TRUE, "create_discovery_publisher_notify failed\n");
 543
 544     /* Get underlying implementation so we can check the ref count */
 545     sink1Impl = impl_from_IWSDiscoveryPublisherNotify(sink1);
 546     sink2Impl = impl_from_IWSDiscoveryPublisherNotify(sink2);
 547
 548     /* Attempt to unregister sink before registering it */
 549     rc = IWSDiscoveryPublisher_UnRegisterNotificationSink(publisher, sink1);
 550     ok(rc == E_FAIL, "IWSDiscoveryPublisher_UnRegisterNotificationSink returned unexpected result: %08x\n", rc);
 551
 552     /* Register notification sinks */
 553     rc = IWSDiscoveryPublisher_RegisterNotificationSink(publisher, sink1);
 554     ok(rc == S_OK, "IWSDiscoveryPublisher_RegisterNotificationSink failed: %08x\n", rc);
 555     ok(sink1Impl->ref == 2, "Ref count for sink 1 is not as expected: %d\n", sink1Impl->ref);
 556
 557     rc = IWSDiscoveryPublisher_RegisterNotificationSink(publisher, sink2);
 558     ok(rc == S_OK, "IWSDiscoveryPublisher_RegisterNotificationSink failed: %08x\n", rc);
 559     ok(sink2Impl->ref == 2, "Ref count for sink 2 is not as expected: %d\n", sink2Impl->ref);
 560
 561     /* Unregister the first sink */
 562     rc = IWSDiscoveryPublisher_UnRegisterNotificationSink(publisher, sink1);
 563     ok(rc == S_OK, "IWSDiscoveryPublisher_UnRegisterNotificationSink failed: %08x\n", rc);
 564     ok(sink1Impl->ref == 1, "Ref count for sink 1 is not as expected: %d\n", sink1Impl->ref);
 565
 566     /* Set up network listener */
 567     publisherIdW = utf8_to_wide(publisherId);
 568     if (publisherIdW == NULL) goto after_publish_test;
 569
 570     sequenceIdW = utf8_to_wide(sequenceId);
 571     if (sequenceIdW == NULL) goto after_publish_test;
 572
 573     msgStorage = heap_alloc_zero(sizeof(messageStorage));
 574     if (msgStorage == NULL) goto after_publish_test;
 575
 576     msgStorage->running = TRUE;
 577     InitializeCriticalSection(&msgStorage->criticalSection);
 578
 579     ret = WSAStartup(MAKEWORD(2, 2), &wsaData);
 580     ok(ret == 0, "WSAStartup failed (ret = %d)\n", ret);
 581
 582     ret = start_listening_on_all_addresses(msgStorage, AF_INET);
 583     ok(ret == TRUE, "Unable to listen on IPv4 addresses (ret == %d)\n", ret);
 584
 585     /* Create "any" elements for header */
 586     ns.Uri = uri;
 587     ns.PreferredPrefix = prefix;
 588
 589     header_any_name.LocalName = header_any_name_text;
 590     header_any_name.Space = &ns;
 591
 592     rc = WSDXMLBuildAnyForSingleElement(&header_any_name, header_any_text, &header_any_element);
 593     ok(rc == S_OK, "WSDXMLBuildAnyForSingleElement failed with %08x\n", rc);
 594
 595     rc = WSDXMLBuildAnyForSingleElement(&header_any_name, body_any_text, &body_any_element);
 596     ok(rc == S_OK, "WSDXMLBuildAnyForSingleElement failed with %08x\n", rc);
 597
 598     /* Publish the service */
 599     rc = IWSDiscoveryPublisher_PublishEx(publisher, publisherIdW, 1, 1, 1, sequenceIdW, NULL, NULL, NULL,
 600         header_any_element, NULL, NULL, NULL, body_any_element);
 601
 602     WSDFreeLinkedMemory(header_any_element);
 603     WSDFreeLinkedMemory(body_any_element);
 604
 605     ok(rc == S_OK, "Publish failed: %08x\n", rc);
 606
 607     /* Wait up to 2 seconds for messages to be received */
 608     if (WaitForMultipleObjects(msgStorage->numThreadHandles, msgStorage->threadHandles, TRUE, 2000) == WAIT_TIMEOUT)
 609     {
 610         /* Wait up to 1 more second for threads to terminate */
 611         msgStorage->running = FALSE;
 612         WaitForMultipleObjects(msgStorage->numThreadHandles, msgStorage->threadHandles, TRUE, 1000);
 613     }
 614
 615     DeleteCriticalSection(&msgStorage->criticalSection);
 616
 617     /* Verify we've received a message */
 618     ok(msgStorage->messageCount >= 1, "No messages received\n");
 619
 620     sprintf(endpointReferenceString, "<wsa:EndpointReference><wsa:Address>%s</wsa:Address></wsa:EndpointReference>", publisherId);
 621     sprintf(app_sequence_string, "<wsd:AppSequence InstanceId=\"1\" SequenceId=\"%s\" MessageNumber=\"1\"></wsd:AppSequence>",
 622         sequenceId);
 623
 624     messageOK = FALSE;
 625
 626     /* Check we're received the correct message */
 627     for (i = 0; i < msgStorage->messageCount; i++)
 628     {
 629         msg = msgStorage->messages[i];
 630         messageOK = FALSE;
 631
 632         hello_message_seen = (strstr(msg, "<wsa:Action>http://schemas.xmlsoap.org/ws/2005/04/discovery/Hello</wsa:Action>") != NULL);
 633         endpoint_reference_seen = (strstr(msg, endpointReferenceString) != NULL);
 634         app_sequence_seen = (strstr(msg, app_sequence_string) != NULL);
 635         metadata_version_seen = (strstr(msg, "<wsd:MetadataVersion>1</wsd:MetadataVersion>") != NULL);
 636         any_header_seen = (strstr(msg, "<wine:Beer>PublishTest</wine:Beer>") != NULL);
 637         wine_ns_seen = (strstr(msg, "xmlns:wine=\"http://wine.test/\"") != NULL);
 638         body_hello_seen = (strstr(msg, "<soap:Body><wsd:Hello") != NULL);
 639         any_body_seen = (strstr(msg, "<wine:Beer>BodyTest</wine:Beer>") != NULL);
 640         messageOK = hello_message_seen && endpoint_reference_seen && app_sequence_seen && metadata_version_seen &&
 641             any_header_seen && wine_ns_seen && body_hello_seen && any_body_seen;
 642
 643         if (messageOK) break;
 644     }
 645
 646     for (i = 0; i < msgStorage->messageCount; i++)
 647     {
 648         heap_free(msgStorage->messages[i]);
 649     }
 650
 651     heap_free(msgStorage);
 652
 653     ok(hello_message_seen == TRUE, "Hello message not received\n");
 654     todo_wine ok(endpoint_reference_seen == TRUE, "EndpointReference not received\n");
 655     ok(app_sequence_seen == TRUE, "AppSequence not received\n");
 656     todo_wine ok(metadata_version_seen == TRUE, "MetadataVersion not received\n");
 657     todo_wine ok(messageOK == TRUE, "Hello message metadata not received\n");
 658     ok(any_header_seen == TRUE, "Custom header not received\n");
 659     ok(wine_ns_seen == TRUE, "Wine namespace not received\n");
 660     ok(body_hello_seen == TRUE, "Body and Hello elements not received\n");
 661     ok(any_body_seen == TRUE, "Custom body element not received\n");
 662
 663 after_publish_test:
 664
 665     heap_free(publisherIdW);
 666     heap_free(sequenceIdW);
 667
 668     ref = IWSDiscoveryPublisher_Release(publisher);
 669     ok(ref == 0, "IWSDiscoveryPublisher_Release() has %d references, should have 0\n", ref);
 670
 671     /* Check that the sinks have been released by the publisher */
 672     ok(sink1Impl->ref == 1, "Ref count for sink 1 is not as expected: %d\n", sink1Impl->ref);
 673     ok(sink2Impl->ref == 1, "Ref count for sink 2 is not as expected: %d\n", sink2Impl->ref);
 674
 675     /* Release the sinks */
 676     IWSDiscoveryPublisherNotify_Release(sink1);
 677     IWSDiscoveryPublisherNotify_Release(sink2);
 678
 679     WSACleanup();
 680 }
 681
 682 enum firewall_op
 683 {
 684     APP_ADD,
 685     APP_REMOVE
 686 };
 687
 688 static BOOL is_process_elevated(void)
 689 {
 690     HANDLE token;
 691     if (OpenProcessToken( GetCurrentProcess(), TOKEN_QUERY, &token ))
 692     {
 693         TOKEN_ELEVATION_TYPE type;
 694         DWORD size;
 695         BOOL ret;
 696
 697         ret = GetTokenInformation( token, TokenElevationType, &type, sizeof(type), &size );
 698         CloseHandle( token );
 699         return (ret && type == TokenElevationTypeFull);
 700     }
 701     return FALSE;
 702 }
 703
 704 static BOOL is_firewall_enabled(void)
 705 {
 706     HRESULT hr, init;
 707     INetFwMgr *mgr = NULL;
 708     INetFwPolicy *policy = NULL;
 709     INetFwProfile *profile = NULL;
 710     VARIANT_BOOL enabled = VARIANT_FALSE;
 711
 712     init = CoInitializeEx( 0, COINIT_APARTMENTTHREADED );
 713
 714     hr = CoCreateInstance( &CLSID_NetFwMgr, NULL, CLSCTX_INPROC_SERVER, &IID_INetFwMgr,
 715                            (void **)&mgr );
 716     ok( hr == S_OK, "got %08x\n", hr );
 717     if (hr != S_OK) goto done;
 718
 719     hr = INetFwMgr_get_LocalPolicy( mgr, &policy );
 720     ok( hr == S_OK, "got %08x\n", hr );
 721     if (hr != S_OK) goto done;
 722
 723     hr = INetFwPolicy_get_CurrentProfile( policy, &profile );
 724     if (hr != S_OK) goto done;
 725
 726     hr = INetFwProfile_get_FirewallEnabled( profile, &enabled );
 727     ok( hr == S_OK, "got %08x\n", hr );
 728
 729 done:
 730     if (policy) INetFwPolicy_Release( policy );
 731     if (profile) INetFwProfile_Release( profile );
 732     if (mgr) INetFwMgr_Release( mgr );
 733     if (SUCCEEDED( init )) CoUninitialize();
 734     return (enabled == VARIANT_TRUE);
 735 }
 736
 737 static HRESULT set_firewall( enum firewall_op op )
 738 {
 739     static const WCHAR testW[] = {'w','s','d','a','p','i','_','t','e','s','t',0};
 740     HRESULT hr, init;
 741     INetFwMgr *mgr = NULL;
 742     INetFwPolicy *policy = NULL;
 743     INetFwProfile *profile = NULL;
 744     INetFwAuthorizedApplication *app = NULL;
 745     INetFwAuthorizedApplications *apps = NULL;
 746     BSTR name, image = SysAllocStringLen( NULL, MAX_PATH );
 747
 748     if (!GetModuleFileNameW( NULL, image, MAX_PATH ))
 749     {
 750         SysFreeString( image );
 751         return E_FAIL;
 752     }
 753     init = CoInitializeEx( 0, COINIT_APARTMENTTHREADED );
 754
 755     hr = CoCreateInstance( &CLSID_NetFwMgr, NULL, CLSCTX_INPROC_SERVER, &IID_INetFwMgr,
 756                            (void **)&mgr );
 757     ok( hr == S_OK, "got %08x\n", hr );
 758     if (hr != S_OK) goto done;
 759
 760     hr = INetFwMgr_get_LocalPolicy( mgr, &policy );
 761     ok( hr == S_OK, "got %08x\n", hr );
 762     if (hr != S_OK) goto done;
 763
 764     hr = INetFwPolicy_get_CurrentProfile( policy, &profile );
 765     if (hr != S_OK) goto done;
 766
 767     hr = INetFwProfile_get_AuthorizedApplications( profile, &apps );
 768     ok( hr == S_OK, "got %08x\n", hr );
 769     if (hr != S_OK) goto done;
 770
 771     hr = CoCreateInstance( &CLSID_NetFwAuthorizedApplication, NULL, CLSCTX_INPROC_SERVER,
 772                            &IID_INetFwAuthorizedApplication, (void **)&app );
 773     ok( hr == S_OK, "got %08x\n", hr );
 774     if (hr != S_OK) goto done;
 775
 776     hr = INetFwAuthorizedApplication_put_ProcessImageFileName( app, image );
 777     if (hr != S_OK) goto done;
 778
 779     name = SysAllocString( testW );
 780     hr = INetFwAuthorizedApplication_put_Name( app, name );
 781     SysFreeString( name );
 782     ok( hr == S_OK, "got %08x\n", hr );
 783     if (hr != S_OK) goto done;
 784
 785     if (op == APP_ADD)
 786         hr = INetFwAuthorizedApplications_Add( apps, app );
 787     else if (op == APP_REMOVE)
 788         hr = INetFwAuthorizedApplications_Remove( apps, image );
 789     else
 790         hr = E_INVALIDARG;
 791
 792 done:
 793     if (app) INetFwAuthorizedApplication_Release( app );
 794     if (apps) INetFwAuthorizedApplications_Release( apps );
 795     if (policy) INetFwPolicy_Release( policy );
 796     if (profile) INetFwProfile_Release( profile );
 797     if (mgr) INetFwMgr_Release( mgr );
 798     if (SUCCEEDED( init )) CoUninitialize();
 799     SysFreeString( image );
 800     return hr;
 801 }
 802
 803 START_TEST(discovery)
 804 {
 805     BOOL firewall_enabled = is_firewall_enabled();
 806     HRESULT hr;
 807
 808     if (firewall_enabled)
 809     {
 810         if (!is_process_elevated())
 811         {
 812             skip("no privileges, skipping tests to avoid firewall dialog\n");
 813             return;
 814         }
 815         if ((hr = set_firewall(APP_ADD)) != S_OK)
 816         {
 817             skip("can't authorize app in firewall %08x\n", hr);
 818             return;
 819         }
 820     }
 821
 822     CoInitialize(NULL);
 823
 824     CreateDiscoveryPublisher_tests();
 825     CreateDiscoveryPublisher_XMLContext_tests();
 826     Publish_tests();
 827
 828     CoUninitialize();
 829     if (firewall_enabled) set_firewall(APP_REMOVE);
 830 }