FreeRDP
Loading...
Searching...
No Matches
udpflow.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/synch.h>
24#include <winpr/winsock.h>
25
26#include <freerdp/log.h>
27
28#include "rdpudp.h"
29#include "udplistener_internal.h"
30
31#define TAG FREERDP_TAG("core.udplistener")
32
33rdpUdpFlow* freerdp_udp_flow_new(const BYTE cookieHash[32])
34{
35 WINPR_ASSERT(cookieHash);
36
37 rdpUdpFlow* flow = calloc(1, sizeof(rdpUdpFlow));
38 if (!flow)
39 return nullptr;
40 if (!InitializeCriticalSectionAndSpinCount(&flow->lock, 4000))
41 {
42 free(flow);
43 return nullptr;
44 }
45 flow->event = CreateEvent(nullptr, TRUE, FALSE, nullptr);
46 if (!flow->event)
47 {
48 DeleteCriticalSection(&flow->lock);
49 free(flow);
50 return nullptr;
51 }
52 memcpy(flow->cookieHash, cookieHash, sizeof(flow->cookieHash));
53 flow->sockfd = INVALID_SOCKET;
54 flow->relay = INVALID_SOCKET;
55 return flow;
56}
57
58void freerdp_udp_flow_free(rdpUdpFlow* flow)
59{
60 if (!flow)
61 return;
62
63 /* A registered flow keeps its listener: the last one removed releases a freed listener. */
64 if (flow->listener)
65 // NOLINTNEXTLINE(clang-analyzer-unix.Malloc): see above
66 freerdp_udp_listener_remove_flow(flow->listener, flow);
67
68 if (flow->relay != INVALID_SOCKET)
69 {
70 /* connectionless sockets don't signal closure on their own */
71 if (_send(flow->relay, "", 0, MSG_NOSIGNAL) < 0)
72 WLog_DBG(TAG, "the flow relay is already gone");
73 closesocket(flow->relay);
74 if (!WSACloseEvent(flow->relayEvent))
75 WLog_WARN(TAG, "failed to close the socket event");
76 }
77 (void)CloseHandle(flow->event);
78 DeleteCriticalSection(&flow->lock);
79 free(flow->ring);
80 free(flow);
81}
82
83const BYTE* freerdp_udp_flow_get_cookie_hash(const rdpUdpFlow* flow)
84{
85 WINPR_ASSERT(flow);
86 return flow->cookieHash;
87}
88
89void freerdp_udp_flow_set_receive(rdpUdpFlow* flow, FreeRDP_UdpFlowReceiveFn receive, void* custom)
90{
91 WINPR_ASSERT(flow);
92 EnterCriticalSection(&flow->lock);
93 flow->receive = receive;
94 flow->receiveCustom = custom;
95 LeaveCriticalSection(&flow->lock);
96}
97
98void freerdp_udp_flow_set_send(rdpUdpFlow* flow, FreeRDP_UdpFlowSendFn send, void* custom)
99{
100 WINPR_ASSERT(flow);
101 EnterCriticalSection(&flow->lock);
102 flow->send = send;
103 flow->sendCustom = custom;
104 LeaveCriticalSection(&flow->lock);
105}
106
107BOOL freerdp_udp_flow_set_socket(rdpUdpFlow* flow, int fd)
108{
109 WINPR_ASSERT(flow);
110
111 /* one datagram per message, consistent with freerdp_udp_listener_add_relay() */
112 if (!udpsocket_is_message_socket((SOCKET)fd))
113 return FALSE;
114
115 HANDLE event = WSACreateEvent();
116 if (!event)
117 return FALSE;
118
119 BOOL rc = FALSE;
120 EnterCriticalSection(&flow->lock);
121 /* this also sets the socket to non-blocking mode */
122 if ((flow->relay == INVALID_SOCKET) && (WSAEventSelect((SOCKET)fd, event, FD_READ) == 0))
123 {
124 flow->relay = (SOCKET)fd;
125 flow->relayEvent = event;
126 /* sockets passed from another process lose the close-on-exec flag */
127 udpsocket_set_no_inherit((SOCKET)fd);
128 rc = TRUE;
129 }
130 LeaveCriticalSection(&flow->lock);
131
132 if (!rc && !WSACloseEvent(event))
133 WLog_WARN(TAG, "failed to close the socket event");
134 return rc;
135}
136
137/* Grow the flow's ring and reset queued datagrams to the start. Caller must hold the flow lock. */
138WINPR_ATTR_NODISCARD
139static BOOL udpflow_grow(rdpUdpFlow* flow)
140{
141 WINPR_ASSERT(flow);
142
143 const size_t slots = (flow->slots == 0) ? UDPFLOW_FIRST_SLOTS : 2 * flow->slots;
144 if (slots > UDPFLOW_SLOTS)
145 return FALSE;
146 BYTE* ring = malloc(slots * UDPFLOW_MAX_DATAGRAM);
147 if (!ring)
148 return FALSE;
149
150 UINT16 lengths[UDPFLOW_SLOTS] = WINPR_C_ARRAY_INIT;
151 /* if no ring exists, nothing is queued */
152 const size_t count = (flow->slots > 0) ? flow->count : 0;
153 for (size_t x = 0; x < count; x++)
154 {
155 const size_t from = (flow->head + x) % flow->slots;
156 memcpy(&ring[x * UDPFLOW_MAX_DATAGRAM], &flow->ring[from * UDPFLOW_MAX_DATAGRAM],
157 flow->lengths[from]);
158 lengths[x] = flow->lengths[from];
159 }
160 memcpy(flow->lengths, lengths, sizeof(lengths));
161 free(flow->ring);
162 flow->ring = ring;
163 flow->slots = slots;
164 flow->head = 0;
165 return TRUE;
166}
167
168BOOL freerdp_udp_flow_deliver(rdpUdpFlow* flow, const BYTE* data, size_t length)
169{
170 WINPR_ASSERT(flow);
171 WINPR_ASSERT(data || (length == 0));
172
173 if (length > UDPFLOW_MAX_DATAGRAM)
174 return FALSE;
175
176 BOOL rc = FALSE;
177 EnterCriticalSection(&flow->lock);
178 if ((flow->count < flow->slots) || udpflow_grow(flow))
179 {
180 const size_t slot = (flow->head + flow->count) % flow->slots;
181 if (length > 0)
182 memcpy(&flow->ring[slot * UDPFLOW_MAX_DATAGRAM], data, length);
183 flow->lengths[slot] = WINPR_ASSERTING_INT_CAST(UINT16, length);
184 flow->count++;
185 (void)SetEvent(flow->event);
186 rc = TRUE;
187 }
188 LeaveCriticalSection(&flow->lock);
189 return rc;
190}
191
192BOOL udpflow_read(rdpUdpFlow* flow, BYTE* data, size_t* length)
193{
194 WINPR_ASSERT(flow);
195 WINPR_ASSERT(data);
196 WINPR_ASSERT(length);
197
198 BOOL rc = FALSE;
199 EnterCriticalSection(&flow->lock);
200 if (flow->count > 0)
201 {
202 *length = flow->lengths[flow->head];
203 memcpy(data, &flow->ring[flow->head * UDPFLOW_MAX_DATAGRAM], *length);
204 flow->head = (flow->head + 1) % flow->slots;
205 flow->count--;
206 rc = TRUE;
207 }
208 if (flow->count == 0)
209 (void)ResetEvent(flow->event);
210
211 if (!rc && (flow->relay != INVALID_SOCKET) && !flow->relayClosed)
212 {
213 (void)WSAResetEvent(flow->relayEvent);
214 const int got = _recv(flow->relay, (char*)data, UDPFLOW_MAX_DATAGRAM, 0);
215 if (got > 0)
216 {
217 *length = WINPR_ASSERTING_INT_CAST(size_t, got);
218 rc = TRUE;
219 }
220 else if (got == 0)
221 {
222 /* RDP-UDP timers will detect the unreachable client */
223 WLog_DBG(TAG, "flow relay has been closed");
224 flow->relayClosed = TRUE;
225 }
226 }
227 LeaveCriticalSection(&flow->lock);
228 return rc;
229}
230
231void udpflow_wake(rdpUdpFlow* flow)
232{
233 WINPR_ASSERT(flow);
234 /* Use the flow event, not the relay socket event; on non-Windows platforms, setting the
235 * latter triggers a WinPR socket write. The worker waits on both, see udpflow_get_events(). */
236 (void)SetEvent(flow->event);
237}
238
239DWORD udpflow_get_events(rdpUdpFlow* flow, HANDLE events[2])
240{
241 WINPR_ASSERT(flow);
242 WINPR_ASSERT(events);
243
244 DWORD count = 0;
245 EnterCriticalSection(&flow->lock);
246 events[count++] = flow->event;
247 if ((flow->relay != INVALID_SOCKET) && !flow->relayClosed)
248 events[count++] = flow->relayEvent;
249 LeaveCriticalSection(&flow->lock);
250 return count;
251}
252
253void udpflow_set_worker(rdpUdpFlow* flow, BOOL (*check)(void* custom),
254 UINT32 (*timeout)(void* custom), void* custom)
255{
256 WINPR_ASSERT(flow);
257 flow->check = check;
258 flow->timeout = timeout;
259 flow->workerCustom = custom;
260}
261
262BOOL freerdp_udp_flow_send(rdpUdpFlow* flow, const BYTE* data, size_t length)
263{
264 WINPR_ASSERT(flow);
265 WINPR_ASSERT(data);
266
267 EnterCriticalSection(&flow->lock);
268 const FreeRDP_UdpFlowSendFn sendFn = flow->send;
269 void* custom = flow->sendCustom;
270 BOOL rc = FALSE;
271 /* hold lock as the listener may close sockets during send */
272 if (!sendFn && (flow->relay != INVALID_SOCKET))
273 {
274 const int sent = _send(flow->relay, (const char*)data,
275 WINPR_ASSERTING_INT_CAST(int, length), MSG_NOSIGNAL);
276 rc = (sent >= 0) || rdpudp_socket_error_is_transient(WSAGetLastError());
277 }
278 else if (!sendFn && (flow->sockfd != INVALID_SOCKET))
279 {
280 /* Fall back to system-chosen source address only if the local address is gone; the client
281 * only accepts replies from the address it sent to, so not on other errors. */
282 BOOL fallback = !flow->local.valid;
283 if (!fallback)
284 {
285 rc = udpsocket_send_from(flow->sockfd, &flow->peer, flow->peerLength, &flow->local,
286 data, length);
287 if (!rc)
288 {
289 int error = 0;
290 fallback = udpsocket_source_address_unavailable(&error);
291 rc = !fallback && rdpudp_socket_error_is_transient(error);
292 }
293 }
294 if (fallback)
295 {
296 const int sent =
297 _sendto(flow->sockfd, (const char*)data, WINPR_ASSERTING_INT_CAST(int, length), 0,
298 (const struct sockaddr*)&flow->peer,
299 WINPR_ASSERTING_INT_CAST(int, flow->peerLength));
300 rc = (sent >= 0) || rdpudp_socket_error_is_transient(WSAGetLastError());
301 }
302 }
303 /* The callback runs under the lock, so freerdp_udp_flow_set_send() waits for it. */
304 if (sendFn)
305 rc = sendFn(custom, data, length);
306 LeaveCriticalSection(&flow->lock);
307 return rc;
308}
309
310HANDLE freerdp_udp_flow_get_event(rdpUdpFlow* flow)
311{
312 WINPR_ASSERT(flow);
313
314 EnterCriticalSection(&flow->lock);
315 const BOOL relay = (flow->relay != INVALID_SOCKET) && !flow->relayClosed;
316 HANDLE event = relay ? flow->relayEvent : flow->event;
317 LeaveCriticalSection(&flow->lock);
318 return event;
319}
320
321UINT32 freerdp_udp_flow_get_timeout(rdpUdpFlow* flow)
322{
323 WINPR_ASSERT(flow);
324 return flow->timeout ? flow->timeout(flow->workerCustom) : UINT32_MAX;
325}
326
327BOOL freerdp_udp_flow_check(rdpUdpFlow* flow)
328{
329 WINPR_ASSERT(flow);
330 return flow->check ? flow->check(flow->workerCustom) : FALSE;
331}