20#include <winpr/assert.h>
21#include <winpr/cast.h>
23#include <winpr/interlocked.h>
24#include <winpr/synch.h>
25#include <winpr/thread.h>
26#include <winpr/winsock.h>
28#include <freerdp/log.h>
30#include "udplistener_internal.h"
32#define TAG FREERDP_TAG("core.udplistener")
35static void udplistener_free_relay(freerdp_udp_listener* listener,
udpListenerRelay* relay)
37 WINPR_ASSERT(listener);
41 freerdp_udp_listener_remove_flow(listener, relay->flow);
42 if (relay->sockfd != INVALID_SOCKET)
43 closesocket(relay->sockfd);
44 freerdp_udp_flow_free(relay->flow);
48void udplistener_stop_relays(freerdp_udp_listener* listener)
50 WINPR_ASSERT(listener);
52 if (listener->relayThread)
55 InterlockedIncrement(&listener->relayStop);
56 if (_send(listener->relayWake[0],
"", 0, MSG_NOSIGNAL) < 0)
57 WLog_DBG(TAG,
"unable to wake the relay thread");
58 (void)WaitForSingleObject(listener->relayThread, INFINITE);
59 (void)CloseHandle(listener->relayThread);
60 listener->relayThread =
nullptr;
62 for (
size_t x = 0; x < 2; x++)
64 if (listener->relayWake[x] != INVALID_SOCKET)
65 closesocket(listener->relayWake[x]);
66 listener->relayWake[x] = INVALID_SOCKET;
69 EnterCriticalSection(&listener->lock);
71 listener->relays =
nullptr;
72 listener->relayCount = 0;
73 LeaveCriticalSection(&listener->lock);
79 if (_send(relay->sockfd,
"", 0, MSG_DONTWAIT | MSG_NOSIGNAL) < 0)
80 WLog_DBG(TAG,
"the remote end of the relay has already disconnected");
81 if (_shutdown(relay->sockfd, SHUT_RDWR) != 0)
82 WLog_DBG(TAG,
"failed to shut down the relay socket");
83 udplistener_free_relay(listener, relay);
87void udplistener_relays_close_after_fork(freerdp_udp_listener* listener)
89 WINPR_ASSERT(listener);
91 for (
size_t x = 0; x < 2; x++)
93 const SOCKET sockfd = listener->relayWake[x];
94 listener->relayWake[x] = INVALID_SOCKET;
95 if (sockfd != INVALID_SOCKET)
100 const SOCKET sockfd = relay->sockfd;
101 relay->sockfd = INVALID_SOCKET;
102 if (sockfd != INVALID_SOCKET)
107static void udplistener_wake_relays(freerdp_udp_listener* listener)
109 WINPR_ASSERT(listener);
110 if (_send(listener->relayWake[0],
"", 0, MSG_NOSIGNAL) < 0)
111 WLog_DBG(TAG,
"unable to wake the relay thread");
116static BOOL udplistener_relay_receive(
void* custom,
const BYTE* data,
size_t length)
120 if (_send(relay->sockfd, (
const char*)data, WINPR_ASSERTING_INT_CAST(
int, length),
121 MSG_DONTWAIT | MSG_NOSIGNAL) >= 0)
124 if (udpsocket_peer_closed() && (InterlockedCompareExchange(&relay->ending, 1, 0) == 0))
125 udplistener_wake_relays(relay->listener);
141 u_long nonBlocking = 1;
142 if (_ioctlsocket(relay->sockfd, FIONBIO, &nonBlocking) != 0)
145 for (
size_t count = 0; count < UDPLISTENER_READ_BUDGET; count++)
148 BYTE data[UDPFLOW_MAX_DATAGRAM + 1] = WINPR_C_ARRAY_INIT;
149 const int rc = _recv(relay->sockfd, (
char*)data,
sizeof(data), MSG_DONTWAIT);
152 const int error = WSAGetLastError();
155 if (error == WSAEMSGSIZE)
157 return (error == WSAEWOULDBLOCK) || (error == WSAEINTR);
161 if ((
size_t)rc > UDPFLOW_MAX_DATAGRAM)
163 WLog_DBG(TAG,
"relay dropped an oversized datagram");
166 if (!freerdp_udp_flow_send(relay->flow, data, WINPR_ASSERTING_INT_CAST(
size_t, rc)))
167 WLog_DBG(TAG,
"relay failed to send a datagram");
172static void udplistener_end_relay(freerdp_udp_listener* listener,
udpListenerRelay* relay)
174 WINPR_ASSERT(listener);
178 if (_send(relay->sockfd,
"", 0, MSG_DONTWAIT | MSG_NOSIGNAL) < 0)
179 WLog_DBG(TAG,
"the remote end of the relay has already disconnected");
181 EnterCriticalSection(&listener->lock);
183 while (*link && (*link != relay))
184 link = &(*link)->next;
188 listener->relayCount--;
190 LeaveCriticalSection(&listener->lock);
191 udplistener_free_relay(listener, relay);
197static DWORD WINAPI udplistener_relay_thread(LPVOID arg)
199 freerdp_udp_listener* listener = arg;
200 WINPR_ASSERT(listener);
202 udpPollFd* fds =
nullptr;
206 while (InterlockedCompareExchange(&listener->relayStop, 0, 0) == 0)
208 EnterCriticalSection(&listener->lock);
210 for (
const udpListenerRelay* relay = listener->relays; relay; relay = relay->next)
212 if (count > capacity)
214 udpPollFd* newFds = realloc(fds, count *
sizeof(udpPollFd));
221 if (!newFds || !newPolled)
224 InterlockedIncrement(&listener->relayFailed);
225 LeaveCriticalSection(&listener->lock);
226 WLog_ERR(TAG,
"stopping relays: out of memory");
231 udpsocket_poll_set(&fds[0], listener->relayWake[1]);
234 for (
udpListenerRelay* relay = listener->relays; relay; relay = relay->next)
236 udpsocket_poll_set(&fds[used], relay->sockfd);
237 polled[used++] = relay;
239 LeaveCriticalSection(&listener->lock);
241 if (udpsocket_poll(fds, used) < 0)
243 if (WSAGetLastError() == WSAEINTR)
245 WLog_ERR(TAG,
"relays stopping: poll failed");
247 EnterCriticalSection(&listener->lock);
248 InterlockedIncrement(&listener->relayFailed);
249 LeaveCriticalSection(&listener->lock);
253 if (fds[0].revents != 0)
255 BYTE drain[16] = WINPR_C_ARRAY_INIT;
256 while (_recv(listener->relayWake[1], (
char*)drain,
sizeof(drain), 0) >= 0)
260 for (
size_t x = 1; x < used; x++)
263 const BOOL ending = (InterlockedCompareExchange(&relay->ending, 0, 0) != 0);
264 if (ending || ((fds[x].revents != 0) && !udplistener_relay_forward(relay)))
265 udplistener_end_relay(listener, relay);
271 if (InterlockedCompareExchange(&listener->relayFailed, 0, 0) != 0)
275 EnterCriticalSection(&listener->lock);
277 LeaveCriticalSection(&listener->lock);
280 udplistener_end_relay(listener, relay);
292static BOOL udplistener_start_relays(freerdp_udp_listener* listener)
294 WINPR_ASSERT(listener);
296 if (listener->relayThread)
299 if (!udpsocket_message_pair(listener->relayWake))
301 u_long nonBlocking = 1;
302 if ((_ioctlsocket(listener->relayWake[0], FIONBIO, &nonBlocking) != 0) ||
303 (_ioctlsocket(listener->relayWake[1], FIONBIO, &nonBlocking) != 0))
306 listener->relayThread =
307 CreateThread(
nullptr, 0, udplistener_relay_thread, listener, 0,
nullptr);
308 if (listener->relayThread)
312 for (
size_t x = 0; x < 2; x++)
314 closesocket(listener->relayWake[x]);
315 listener->relayWake[x] = INVALID_SOCKET;
320BOOL freerdp_udp_listener_add_relay(freerdp_udp_listener* listener,
const BYTE cookieHash[32],
323 WINPR_ASSERT(listener);
324 WINPR_ASSERT(cookieHash);
329 relay->listener = listener;
330 relay->sockfd = (SOCKET)fd;
331 relay->flow = freerdp_udp_flow_new(cookieHash);
336 if (!udpsocket_is_message_socket(relay->sockfd))
340 u_long nonBlocking = 1;
341 if (_ioctlsocket(relay->sockfd, FIONBIO, &nonBlocking) != 0)
344 freerdp_udp_flow_set_receive(relay->flow, udplistener_relay_receive, relay);
348 EnterCriticalSection(&listener->lock);
349 const BOOL reserved = (listener->relayCount < UDPLISTENER_MAX_RELAYS) &&
350 (InterlockedCompareExchange(&listener->relayFailed, 0, 0) == 0) &&
351 udplistener_start_relays(listener);
353 listener->relayCount++;
354 LeaveCriticalSection(&listener->lock);
357 if (InterlockedCompareExchange(&listener->relayFailed, 0, 0) != 0)
360 "relay thread terminated due to an error; no further relays will be processed");
362 WLog_WARN(TAG,
"unable to serve an additional relay");
366 if (!udplistener_add_flow(listener, relay->flow, INVALID_SOCKET))
368 EnterCriticalSection(&listener->lock);
369 listener->relayCount--;
370 LeaveCriticalSection(&listener->lock);
376 EnterCriticalSection(&listener->lock);
377 const BOOL linked = (InterlockedCompareExchange(&listener->relayFailed, 0, 0) == 0);
380 relay->next = listener->relays;
381 listener->relays = relay;
384 listener->relayCount--;
385 LeaveCriticalSection(&listener->lock);
390 udpsocket_set_no_inherit((SOCKET)fd);
392 udplistener_wake_relays(listener);
397 freerdp_udp_flow_free(relay->flow);
402BOOL freerdp_udp_listener_remove_relay(freerdp_udp_listener* listener,
const BYTE cookieHash[32])
404 WINPR_ASSERT(listener);
405 WINPR_ASSERT(cookieHash);
408 EnterCriticalSection(&listener->lock);
409 for (
udpListenerRelay* relay = listener->relays; relay && !found; relay = relay->next)
411 if (memcmp(relay->flow->cookieHash, cookieHash,
sizeof(relay->flow->cookieHash)) == 0)
414 InterlockedIncrement(&relay->ending);
419 udplistener_wake_relays(listener);
420 LeaveCriticalSection(&listener->lock);