dlls/wsdapi/network.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
  23 #define COBJMACROS
  24
  25 #include "wsdapi_internal.h"
  26 #include "wine/debug.h"
  27 #include "wine/heap.h"
  28 #include "iphlpapi.h"
  29 #include "bcrypt.h"
  30
  31 WINE_DEFAULT_DEBUG_CHANNEL(wsdapi);
  32
  33 #define SEND_ADDRESS_IPV4   0xEFFFFFFA /* 239.255.255.250 */
  34 #define SEND_PORT           3702
  35
  36 static UCHAR send_address_ipv6[] = {0xFF,0x02,0,0,0,0,0,0,0,0,0,0,0,0,0,0xC}; /* FF02::C */
  37
  38 #define UNICAST_UDP_REPEAT     1
  39 #define MULTICAST_UDP_REPEAT   2
  40 #define UDP_MIN_DELAY         50
  41 #define UDP_MAX_DELAY        250
  42 #define UDP_UPPER_DELAY      500
  43
  44 static void send_message(SOCKET s, char *data, int length, SOCKADDR_STORAGE *dest, int max_initial_delay, int repeat)
  45 {
  46     UINT delay;
  47     int len;
  48
  49     /* Sleep for a random amount of time before sending the message */
  50     if (max_initial_delay > 0)
  51     {
  52         BCryptGenRandom(NULL, (BYTE*) &delay, sizeof(UINT), BCRYPT_USE_SYSTEM_PREFERRED_RNG);
  53         Sleep(delay % max_initial_delay);
  54     }
  55
  56     len = (dest->ss_family == AF_INET6) ? sizeof(SOCKADDR_IN6) : sizeof(SOCKADDR_IN);
  57
  58     if (sendto(s, data, length, 0, (SOCKADDR *) dest, len) == SOCKET_ERROR)
  59         WARN("Unable to send data to socket: %d\n", WSAGetLastError());
  60
  61     if (repeat-- <= 0) return;
  62
  63     BCryptGenRandom(NULL, (BYTE*) &delay, sizeof(UINT), BCRYPT_USE_SYSTEM_PREFERRED_RNG);
  64     delay = delay % (UDP_MAX_DELAY - UDP_MIN_DELAY + 1) + UDP_MIN_DELAY;
  65
  66     for (;;)
  67     {
  68         Sleep(delay);
  69
  70         if (sendto(s, data, length, 0, (SOCKADDR *) dest, len) == SOCKET_ERROR)
  71             WARN("Unable to send data to socket: %d\n", WSAGetLastError());
  72
  73         if (repeat-- <= 0) break;
  74         delay = min(delay * 2, UDP_UPPER_DELAY);
  75     }
  76 }
  77
  78 typedef struct sending_thread_params
  79 {
  80     char *data;
  81     int length;
  82     SOCKET sock;
  83     SOCKADDR_STORAGE dest;
  84     int max_initial_delay;
  85 } sending_thread_params;
  86
  87 static DWORD WINAPI sending_thread(LPVOID lpParam)
  88 {
  89     sending_thread_params *params = (sending_thread_params *) lpParam;
  90
  91     send_message(params->sock, params->data, params->length, &params->dest, params->max_initial_delay,
  92         MULTICAST_UDP_REPEAT);
  93     closesocket(params->sock);
  94
  95     heap_free(params->data);
  96     heap_free(params);
  97
  98     return 0;
  99 }
 100
 101 BOOL send_udp_multicast_of_type(char *data, int length, int max_initial_delay, ULONG family)
 102 {
 103     IP_ADAPTER_ADDRESSES *adapter_addresses = NULL, *adapter_addr;
 104     static const struct in6_addr i_addr_zero;
 105     sending_thread_params *send_params;
 106     ULONG bufferSize = 0;
 107     LPSOCKADDR sockaddr;
 108     BOOL ret = FALSE;
 109     HANDLE thread_handle;
 110     const char ttl = 8;
 111     ULONG retval;
 112     SOCKET s;
 113
 114     /* Get size of buffer for adapters */
 115     retval = GetAdaptersAddresses(family, 0, NULL, NULL, &bufferSize);
 116
 117     if (retval != ERROR_BUFFER_OVERFLOW)
 118     {
 119         WARN("GetAdaptorsAddresses failed with error %08x\n", retval);
 120         goto cleanup;
 121     }
 122
 123     adapter_addresses = (IP_ADAPTER_ADDRESSES *) heap_alloc(bufferSize);
 124
 125     if (adapter_addresses == NULL)
 126     {
 127         WARN("Out of memory allocating space for adapter information\n");
 128         goto cleanup;
 129     }
 130
 131     /* Get list of adapters */
 132     retval = GetAdaptersAddresses(family, 0, NULL, adapter_addresses, &bufferSize);
 133
 134     if (retval != ERROR_SUCCESS)
 135     {
 136         WARN("GetAdaptorsAddresses failed with error %08x\n", retval);
 137         goto cleanup;
 138     }
 139
 140     for (adapter_addr = adapter_addresses; adapter_addr != NULL; adapter_addr = adapter_addr->Next)
 141     {
 142         if (adapter_addr->FirstUnicastAddress == NULL)
 143         {
 144             TRACE("No address found for adaptor '%s' (%p)\n", debugstr_a(adapter_addr->AdapterName), adapter_addr);
 145             continue;
 146         }
 147
 148         sockaddr = adapter_addr->FirstUnicastAddress->Address.lpSockaddr;
 149
 150         /* Create a socket and bind to the adapter address */
 151         s = socket(family, SOCK_DGRAM, IPPROTO_UDP);
 152
 153         if (s == INVALID_SOCKET)
 154         {
 155             WARN("Unable to create socket: %d\n", WSAGetLastError());
 156             continue;
 157         }
 158
 159         if (bind(s, sockaddr, adapter_addr->FirstUnicastAddress->Address.iSockaddrLength) == SOCKET_ERROR)
 160         {
 161             WARN("Unable to bind to socket (adaptor '%s' (%p)): %d\n", debugstr_a(adapter_addr->AdapterName),
 162                 adapter_addr, WSAGetLastError());
 163             closesocket(s);
 164             continue;
 165         }
 166
 167         /* Set the multicast interface and TTL value */
 168         setsockopt(s, IPPROTO_IP, IP_MULTICAST_IF, (char *) &i_addr_zero,
 169             (family == AF_INET6) ? sizeof(struct in6_addr) : sizeof(struct in_addr));
 170         setsockopt(s, IPPROTO_IP, IP_MULTICAST_TTL, &ttl, sizeof(ttl));
 171
 172         /* Set up the thread parameters */
 173         send_params = heap_alloc(sizeof(*send_params));
 174
 175         send_params->data = heap_alloc(length);
 176         memcpy(send_params->data, data, length);
 177         send_params->length = length;
 178         send_params->sock = s;
 179         send_params->max_initial_delay = max_initial_delay;
 180
 181         memset(&send_params->dest, 0, sizeof(SOCKADDR_STORAGE));
 182         send_params->dest.ss_family = family;
 183
 184         if (family == AF_INET)
 185         {
 186             SOCKADDR_IN *sockaddr4 = (SOCKADDR_IN *)&send_params->dest;
 187
 188             sockaddr4->sin_port = htons(SEND_PORT);
 189             sockaddr4->sin_addr.S_un.S_addr = htonl(SEND_ADDRESS_IPV4);
 190         }
 191         else
 192         {
 193             SOCKADDR_IN6 *sockaddr6 = (SOCKADDR_IN6 *)&send_params->dest;
 194
 195             sockaddr6->sin6_port = htons(SEND_PORT);
 196             memcpy(&sockaddr6->sin6_addr, &send_address_ipv6, sizeof(send_address_ipv6));
 197         }
 198
 199         thread_handle = CreateThread(NULL, 0, sending_thread, send_params, 0, NULL);
 200
 201         if (thread_handle == NULL)
 202         {
 203             WARN("CreateThread failed (error %d)\n", GetLastError());
 204             closesocket(s);
 205
 206             heap_free(send_params->data);
 207             heap_free(send_params);
 208
 209             continue;
 210         }
 211
 212         CloseHandle(thread_handle);
 213     }
 214
 215     ret = TRUE;
 216
 217 cleanup:
 218     if (adapter_addresses != NULL) heap_free(adapter_addresses);
 219
 220     return ret;
 221 }
 222
 223 BOOL send_udp_multicast(IWSDiscoveryPublisherImpl *impl, char *data, int length, int max_initial_delay)
 224 {
 225     if ((impl->addressFamily & WSDAPI_ADDRESSFAMILY_IPV4) &&
 226         (!send_udp_multicast_of_type(data, length,max_initial_delay, AF_INET))) return FALSE;
 227
 228     if ((impl->addressFamily & WSDAPI_ADDRESSFAMILY_IPV6) &&
 229         (!send_udp_multicast_of_type(data, length, max_initial_delay, AF_INET6))) return FALSE;
 230
 231     return TRUE;
 232 }
 233
 234 void terminate_networking(IWSDiscoveryPublisherImpl *impl)
 235 {
 236     BOOL needsCleanup = impl->publisherStarted;
 237
 238     impl->publisherStarted = FALSE;
 239
 240     if (needsCleanup)
 241         WSACleanup();
 242 }
 243
 244 BOOL init_networking(IWSDiscoveryPublisherImpl *impl)
 245 {
 246     WSADATA wsaData;
 247     int ret = WSAStartup(MAKEWORD(2, 2), &wsaData);
 248
 249     if (ret != 0)
 250     {
 251         WARN("WSAStartup failed with error: %d\n", ret);
 252         return FALSE;
 253     }
 254
 255     impl->publisherStarted = TRUE;
 256
 257     /* TODO: Start listening */
 258     return TRUE;
 259 }