FreeRDP
Loading...
Searching...
No Matches
udplistener_relay.c
1
17
18#include <string.h>
19
20#include <winpr/assert.h>
21#include <winpr/cast.h>
22#include <winpr/crt.h>
23#include <winpr/interlocked.h>
24#include <winpr/synch.h>
25#include <winpr/thread.h>
26#include <winpr/winsock.h>
27
28#include <freerdp/log.h>
29
30#include "udplistener_internal.h"
31
32#define TAG FREERDP_TAG("core.udplistener")
33
34/* Detaches relay from listener and closes its socket. */
35static void udplistener_free_relay(freerdp_udp_listener* listener, udpListenerRelay* relay)
36{
37 WINPR_ASSERT(listener);
38 WINPR_ASSERT(relay);
39
40 /* Stop datagrams before closing the socket. */
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);
45 free(relay);
46}
47
48void udplistener_stop_relays(freerdp_udp_listener* listener)
49{
50 WINPR_ASSERT(listener);
51
52 if (listener->relayThread)
53 {
54 /* Avoid InterlockedExchange; WinPR reads the old value non-atomically. */
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;
61 }
62 for (size_t x = 0; x < 2; x++)
63 {
64 if (listener->relayWake[x] != INVALID_SOCKET)
65 closesocket(listener->relayWake[x]);
66 listener->relayWake[x] = INVALID_SOCKET;
67 }
68
69 EnterCriticalSection(&listener->lock);
70 udpListenerRelay* relays = listener->relays;
71 listener->relays = nullptr;
72 listener->relayCount = 0;
73 LeaveCriticalSection(&listener->lock);
74 while (relays)
75 {
76 udpListenerRelay* relay = relays;
77 relays = relay->next;
78 /* Notify peer that the relay ended, as udplistener_end_relay() does. */
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);
84 }
85}
86
87void udplistener_relays_close_after_fork(freerdp_udp_listener* listener)
88{
89 WINPR_ASSERT(listener);
90
91 for (size_t x = 0; x < 2; x++)
92 {
93 const SOCKET sockfd = listener->relayWake[x];
94 listener->relayWake[x] = INVALID_SOCKET;
95 if (sockfd != INVALID_SOCKET)
96 closesocket(sockfd);
97 }
98 for (udpListenerRelay* relay = listener->relays; relay; relay = relay->next)
99 {
100 const SOCKET sockfd = relay->sockfd;
101 relay->sockfd = INVALID_SOCKET;
102 if (sockfd != INVALID_SOCKET)
103 closesocket(sockfd);
104 }
105}
106
107static void udplistener_wake_relays(freerdp_udp_listener* listener)
108{
109 WINPR_ASSERT(listener);
110 if (_send(listener->relayWake[0], "", 0, MSG_NOSIGNAL) < 0)
111 WLog_DBG(TAG, "unable to wake the relay thread");
112}
113
114/* Called with listener lock held; see FreeRDP_UdpFlowReceiveFn. */
115WINPR_ATTR_NODISCARD
116static BOOL udplistener_relay_receive(void* custom, const BYTE* data, size_t length)
117{
118 udpListenerRelay* relay = custom;
119 WINPR_ASSERT(relay);
120 if (_send(relay->sockfd, (const char*)data, WINPR_ASSERTING_INT_CAST(int, length),
121 MSG_DONTWAIT | MSG_NOSIGNAL) >= 0)
122 return TRUE;
123
124 if (udpsocket_peer_closed() && (InterlockedCompareExchange(&relay->ending, 1, 0) == 0))
125 udplistener_wake_relays(relay->listener);
126 return FALSE;
127}
128
129/* Forwards pending data from the relay socket to the client.
130 * @return FALSE if the relay ended */
131WINPR_ATTR_NODISCARD
132static BOOL udplistener_relay_forward(udpListenerRelay* relay)
133{
134 WINPR_ASSERT(relay);
135
136 /* The connection process created this socket and may still hold it: it can make the socket
137 * blocking again and stall the thread that serves every relay. So the reads below do not rely
138 * on the socket's mode: MSG_DONTWAIT, and on Windows, where that flag does not exist, the
139 * mode is set again first. */
140#if defined(_WIN32)
141 u_long nonBlocking = 1;
142 if (_ioctlsocket(relay->sockfd, FIONBIO, &nonBlocking) != 0)
143 return FALSE;
144#endif
145 for (size_t count = 0; count < UDPLISTENER_READ_BUDGET; count++)
146 {
147 /* One spare byte: POSIX truncates to buffer size, so a full message is too large. */
148 BYTE data[UDPFLOW_MAX_DATAGRAM + 1] = WINPR_C_ARRAY_INIT;
149 const int rc = _recv(relay->sockfd, (char*)data, sizeof(data), MSG_DONTWAIT);
150 if (rc < 0)
151 {
152 const int error = WSAGetLastError();
153 /* Windows drops oversized messages with this error, while POSIX truncates them;
154 * either way, only this message is lost. */
155 if (error == WSAEMSGSIZE)
156 continue;
157 return (error == WSAEWOULDBLOCK) || (error == WSAEINTR);
158 }
159 if (rc == 0)
160 return FALSE; /* Peer closed. */
161 if ((size_t)rc > UDPFLOW_MAX_DATAGRAM)
162 {
163 WLog_DBG(TAG, "relay dropped an oversized datagram");
164 continue;
165 }
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");
168 }
169 return TRUE;
170}
171
172static void udplistener_end_relay(freerdp_udp_listener* listener, udpListenerRelay* relay)
173{
174 WINPR_ASSERT(listener);
175 WINPR_ASSERT(relay);
176
177 /* Connectionless sockets do not signal closure automatically. */
178 if (_send(relay->sockfd, "", 0, MSG_DONTWAIT | MSG_NOSIGNAL) < 0)
179 WLog_DBG(TAG, "the remote end of the relay has already disconnected");
180
181 EnterCriticalSection(&listener->lock);
182 udpListenerRelay** link = &listener->relays;
183 while (*link && (*link != relay))
184 link = &(*link)->next;
185 if (*link)
186 {
187 *link = relay->next;
188 listener->relayCount--;
189 }
190 LeaveCriticalSection(&listener->lock);
191 udplistener_free_relay(listener, relay);
192}
193
194/* A single thread serves all relays; it is the only entity that ends a relay
195 * unless the listener is stopped. */
196WINPR_ATTR_NODISCARD
197static DWORD WINAPI udplistener_relay_thread(LPVOID arg)
198{
199 freerdp_udp_listener* listener = arg;
200 WINPR_ASSERT(listener);
201
202 udpPollFd* fds = nullptr;
203 udpListenerRelay** polled = nullptr;
204 size_t capacity = 0;
205
206 while (InterlockedCompareExchange(&listener->relayStop, 0, 0) == 0)
207 {
208 EnterCriticalSection(&listener->lock);
209 size_t count = 1;
210 for (const udpListenerRelay* relay = listener->relays; relay; relay = relay->next)
211 count++;
212 if (count > capacity)
213 {
214 udpPollFd* newFds = realloc(fds, count * sizeof(udpPollFd));
215 if (newFds)
216 fds = newFds;
217 udpListenerRelay** newPolled =
218 (udpListenerRelay**)realloc((void*)polled, count * sizeof(udpListenerRelay*));
219 if (newPolled)
220 polled = newPolled;
221 if (!newFds || !newPolled)
222 {
223 /* Held under lock; see freerdp_udp_listener_add_relay(). */
224 InterlockedIncrement(&listener->relayFailed);
225 LeaveCriticalSection(&listener->lock);
226 WLog_ERR(TAG, "stopping relays: out of memory");
227 break;
228 }
229 capacity = count;
230 }
231 udpsocket_poll_set(&fds[0], listener->relayWake[1]);
232 polled[0] = nullptr;
233 size_t used = 1;
234 for (udpListenerRelay* relay = listener->relays; relay; relay = relay->next)
235 {
236 udpsocket_poll_set(&fds[used], relay->sockfd);
237 polled[used++] = relay;
238 }
239 LeaveCriticalSection(&listener->lock);
240
241 if (udpsocket_poll(fds, used) < 0)
242 {
243 if (WSAGetLastError() == WSAEINTR)
244 continue;
245 WLog_ERR(TAG, "relays stopping: poll failed");
246 /* Held under lock; see freerdp_udp_listener_add_relay(). */
247 EnterCriticalSection(&listener->lock);
248 InterlockedIncrement(&listener->relayFailed);
249 LeaveCriticalSection(&listener->lock);
250 break;
251 }
252
253 if (fds[0].revents != 0)
254 {
255 BYTE drain[16] = WINPR_C_ARRAY_INIT;
256 while (_recv(listener->relayWake[1], (char*)drain, sizeof(drain), 0) >= 0)
257 {
258 }
259 }
260 for (size_t x = 1; x < used; x++)
261 {
262 udpListenerRelay* relay = polled[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);
266 }
267 }
268
269 /* After a fatal error, stop serving relays and close their sockets so other
270 * processes are notified. */
271 if (InterlockedCompareExchange(&listener->relayFailed, 0, 0) != 0)
272 {
273 while (TRUE)
274 {
275 EnterCriticalSection(&listener->lock);
276 udpListenerRelay* relay = listener->relays;
277 LeaveCriticalSection(&listener->lock);
278 if (!relay)
279 break;
280 udplistener_end_relay(listener, relay);
281 }
282 }
283
284 free((void*)polled);
285 free(fds);
286 ExitThread(0);
287 return 0;
288}
289
290/* Caller must hold the lock. */
291WINPR_ATTR_NODISCARD
292static BOOL udplistener_start_relays(freerdp_udp_listener* listener)
293{
294 WINPR_ASSERT(listener);
295
296 if (listener->relayThread)
297 return TRUE;
298
299 if (!udpsocket_message_pair(listener->relayWake))
300 return FALSE;
301 u_long nonBlocking = 1;
302 if ((_ioctlsocket(listener->relayWake[0], FIONBIO, &nonBlocking) != 0) ||
303 (_ioctlsocket(listener->relayWake[1], FIONBIO, &nonBlocking) != 0))
304 goto fail;
305
306 listener->relayThread =
307 CreateThread(nullptr, 0, udplistener_relay_thread, listener, 0, nullptr);
308 if (listener->relayThread)
309 return TRUE;
310
311fail:
312 for (size_t x = 0; x < 2; x++)
313 {
314 closesocket(listener->relayWake[x]);
315 listener->relayWake[x] = INVALID_SOCKET;
316 }
317 return FALSE;
318}
319
320BOOL freerdp_udp_listener_add_relay(freerdp_udp_listener* listener, const BYTE cookieHash[32],
321 int fd)
322{
323 WINPR_ASSERT(listener);
324 WINPR_ASSERT(cookieHash);
325
326 udpListenerRelay* relay = calloc(1, sizeof(udpListenerRelay));
327 if (!relay)
328 return FALSE;
329 relay->listener = listener;
330 relay->sockfd = (SOCKET)fd;
331 relay->flow = freerdp_udp_flow_new(cookieHash);
332 if (!relay->flow)
333 goto fail;
334
335 /* Ensure one datagram per message, even for fds from other processes. */
336 if (!udpsocket_is_message_socket(relay->sockfd))
337 goto fail;
338
339 /* Relay thread must not block on any single socket while reading. */
340 u_long nonBlocking = 1;
341 if (_ioctlsocket(relay->sockfd, FIONBIO, &nonBlocking) != 0)
342 goto fail;
343
344 freerdp_udp_flow_set_receive(relay->flow, udplistener_relay_receive, relay);
345
346 /* Reserve the relay slot and start the thread before registering the hash to minimize the
347 * chance that datagrams reach fd if this function fails. */
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);
352 if (reserved)
353 listener->relayCount++;
354 LeaveCriticalSection(&listener->lock);
355 if (!reserved)
356 {
357 if (InterlockedCompareExchange(&listener->relayFailed, 0, 0) != 0)
358 WLog_ERR(
359 TAG,
360 "relay thread terminated due to an error; no further relays will be processed");
361 else
362 WLog_WARN(TAG, "unable to serve an additional relay");
363 goto fail;
364 }
365
366 if (!udplistener_add_flow(listener, relay->flow, INVALID_SOCKET))
367 {
368 EnterCriticalSection(&listener->lock);
369 listener->relayCount--;
370 LeaveCriticalSection(&listener->lock);
371 goto fail;
372 }
373
374 /* The relay thread sets relayFailed and ends all relays under the lock, ensuring that
375 * relays linked before the failure are cleaned up and no new relays are added. */
376 EnterCriticalSection(&listener->lock);
377 const BOOL linked = (InterlockedCompareExchange(&listener->relayFailed, 0, 0) == 0);
378 if (linked)
379 {
380 relay->next = listener->relays;
381 listener->relays = relay;
382 }
383 else
384 listener->relayCount--;
385 LeaveCriticalSection(&listener->lock);
386 if (!linked)
387 goto fail;
388
389 /* Sockets passed from another process may lose the close-on-exec flag. */
390 udpsocket_set_no_inherit((SOCKET)fd);
391 /* Notify the relay thread to poll this socket. */
392 udplistener_wake_relays(listener);
393 return TRUE;
394
395fail:
396 /* Free the flow; the caller retains ownership of fd. */
397 freerdp_udp_flow_free(relay->flow);
398 free(relay);
399 return FALSE;
400}
401
402BOOL freerdp_udp_listener_remove_relay(freerdp_udp_listener* listener, const BYTE cookieHash[32])
403{
404 WINPR_ASSERT(listener);
405 WINPR_ASSERT(cookieHash);
406
407 BOOL found = FALSE;
408 EnterCriticalSection(&listener->lock);
409 for (udpListenerRelay* relay = listener->relays; relay && !found; relay = relay->next)
410 {
411 if (memcmp(relay->flow->cookieHash, cookieHash, sizeof(relay->flow->cookieHash)) == 0)
412 {
413 /* Only the relay thread performs the actual cleanup. */
414 InterlockedIncrement(&relay->ending);
415 found = TRUE;
416 }
417 }
418 if (found)
419 udplistener_wake_relays(listener);
420 LeaveCriticalSection(&listener->lock);
421 return found;
422}