FreeRDP
Loading...
Searching...
No Matches
telemetry_main.c
1
20#include <freerdp/config.h>
21
22#include <freerdp/freerdp.h>
23#include <freerdp/channels/log.h>
24#include <freerdp/server/telemetry.h>
25
26#define TAG CHANNELS_TAG("telemetry.server")
27
28typedef enum
29{
30 TELEMETRY_INITIAL,
31 TELEMETRY_OPENED,
32} eTelemetryChannelState;
33
34typedef struct
35{
36 TelemetryServerContext context;
37
38 HANDLE stopEvent;
39
40 HANDLE thread;
41 void* telemetry_channel;
42
43 DWORD SessionId;
44
45 BOOL isOpened;
46 BOOL externalThread;
47
48 /* Channel state */
49 eTelemetryChannelState state;
50
51 wStream* buffer;
52 wLog* log;
53} telemetry_server;
54
55static UINT telemetry_server_initialize(TelemetryServerContext* context, BOOL externalThread)
56{
57 UINT error = CHANNEL_RC_OK;
58 telemetry_server* telemetry = (telemetry_server*)context;
59
60 WINPR_ASSERT(telemetry);
61
62 if (telemetry->isOpened)
63 {
64 WLog_Print(telemetry->log, WLOG_WARN,
65 "Application error: TELEMETRY channel already initialized, "
66 "calling in this state is not possible!");
67 return ERROR_INVALID_STATE;
68 }
69
70 telemetry->externalThread = externalThread;
71
72 return error;
73}
74
75static UINT telemetry_server_open_channel(telemetry_server* telemetry)
76{
77 WINPR_ASSERT(telemetry);
78
79 TelemetryServerContext* context = &telemetry->context;
80 DWORD Error = ERROR_SUCCESS;
81 DWORD BytesReturned = 0;
82 PULONG pSessionId = nullptr;
83 BOOL status = TRUE;
84
85 WINPR_ASSERT(telemetry);
86
87 if (WTSQuerySessionInformationA(telemetry->context.vcm, WTS_CURRENT_SESSION, WTSSessionId,
88 (LPSTR*)&pSessionId, &BytesReturned) == FALSE)
89 {
90 WLog_Print(telemetry->log, WLOG_ERROR, "WTSQuerySessionInformationA failed!");
91 return ERROR_INTERNAL_ERROR;
92 }
93
94 telemetry->SessionId = (DWORD)*pSessionId;
95 WTSFreeMemory(pSessionId);
96
97 HANDLE hEvent = WTSVirtualChannelManagerGetEventHandle(telemetry->context.vcm);
98
99 if (WaitForSingleObject(hEvent, 1000) == WAIT_FAILED)
100 {
101 Error = GetLastError();
102 WLog_Print(telemetry->log, WLOG_ERROR, "WaitForSingleObject failed with error %" PRIu32 "!",
103 Error);
104 return Error;
105 }
106
107 telemetry->telemetry_channel = WTSVirtualChannelOpenEx(
108 telemetry->SessionId, TELEMETRY_DVC_CHANNEL_NAME, WTS_CHANNEL_OPTION_DYNAMIC);
109 if (!telemetry->telemetry_channel)
110 {
111 Error = GetLastError();
112 WLog_Print(telemetry->log, WLOG_ERROR,
113 "WTSVirtualChannelOpenEx failed with error %" PRIu32 "!", Error);
114 return Error;
115 }
116
117 const UINT32 channelId = WTSChannelGetIdByHandle(telemetry->telemetry_channel);
118
119 IFCALLRET(context->ChannelIdAssigned, status, context, channelId);
120 if (!status)
121 {
122 WLog_Print(telemetry->log, WLOG_ERROR, "context->ChannelIdAssigned failed!");
123 return ERROR_INTERNAL_ERROR;
124 }
125
126 return Error;
127}
128
129static UINT telemetry_server_recv_rdp_telemetry_pdu(TelemetryServerContext* context, wStream* s)
130{
131 TELEMETRY_RDP_TELEMETRY_PDU pdu = WINPR_C_ARRAY_INIT;
132 UINT error = CHANNEL_RC_OK;
133 telemetry_server* telemetry = (telemetry_server*)context;
134
135 WINPR_ASSERT(telemetry);
136
137 if (!Stream_CheckAndLogRequiredLengthWLog(telemetry->log, s, 16))
138 return ERROR_NO_DATA;
139
140 Stream_Read_UINT32(s, pdu.PromptForCredentialsMillis);
141 Stream_Read_UINT32(s, pdu.PromptForCredentialsDoneMillis);
142 Stream_Read_UINT32(s, pdu.GraphicsChannelOpenedMillis);
143 Stream_Read_UINT32(s, pdu.FirstGraphicsReceivedMillis);
144
145 IFCALLRET(context->RdpTelemetry, error, context, &pdu);
146 if (error)
147 WLog_Print(telemetry->log, WLOG_ERROR,
148 "context->RdpTelemetry failed with error %" PRIu32 "", error);
149
150 return error;
151}
152
153static UINT telemetry_process_message(telemetry_server* telemetry)
154{
155 UINT error = ERROR_INTERNAL_ERROR;
156 ULONG BytesReturned = 0;
157 BYTE MessageId = 0;
158 BYTE Length = 0;
159
160 WINPR_ASSERT(telemetry);
161 WINPR_ASSERT(telemetry->telemetry_channel);
162
163 wStream* s = telemetry->buffer;
164 WINPR_ASSERT(s);
165
166 Stream_ResetPosition(s);
167 const BOOL rc =
168 WTSVirtualChannelRead(telemetry->telemetry_channel, 0, nullptr, 0, &BytesReturned);
169 if (!rc)
170 goto out;
171
172 if (BytesReturned < 1)
173 {
174 error = CHANNEL_RC_OK;
175 goto out;
176 }
177
178 if (!Stream_EnsureRemainingCapacity(s, BytesReturned))
179 {
180 WLog_Print(telemetry->log, WLOG_ERROR, "Stream_EnsureRemainingCapacity failed!");
181 error = CHANNEL_RC_NO_MEMORY;
182 goto out;
183 }
184
185 if (WTSVirtualChannelRead(telemetry->telemetry_channel, 0, Stream_BufferAs(s, char),
186 (ULONG)Stream_Capacity(s), &BytesReturned) == FALSE)
187 {
188 WLog_Print(telemetry->log, WLOG_ERROR, "WTSVirtualChannelRead failed!");
189 goto out;
190 }
191
192 if (!Stream_SetLength(s, BytesReturned))
193 goto out;
194
195 if (!Stream_CheckAndLogRequiredLengthWLog(telemetry->log, s, 2))
196 return ERROR_NO_DATA;
197
198 Stream_Read_UINT8(s, MessageId);
199 Stream_Read_UINT8(s, Length);
200 if (!Stream_CheckAndLogRequiredLengthWLog(telemetry->log, s, Length))
201 return ERROR_NO_DATA;
202
203 switch (MessageId)
204 {
205 case 0x01:
206 error = telemetry_server_recv_rdp_telemetry_pdu(&telemetry->context, s);
207 break;
208 default:
209 WLog_Print(telemetry->log, WLOG_ERROR,
210 "telemetry_process_message: unknown MessageId %" PRIu8 "", MessageId);
211 break;
212 }
213
214out:
215 if (error)
216 WLog_Print(telemetry->log, WLOG_ERROR, "Response failed with error %" PRIu32 "!", error);
217
218 return error;
219}
220
221static UINT telemetry_server_context_poll_int(TelemetryServerContext* context)
222{
223 telemetry_server* telemetry = (telemetry_server*)context;
224 UINT error = ERROR_INTERNAL_ERROR;
225
226 WINPR_ASSERT(telemetry);
227
228 switch (telemetry->state)
229 {
230 case TELEMETRY_INITIAL:
231 error = telemetry_server_open_channel(telemetry);
232 if (error)
233 WLog_Print(telemetry->log, WLOG_ERROR,
234 "telemetry_server_open_channel failed with error %" PRIu32 "!", error);
235 else
236 telemetry->state = TELEMETRY_OPENED;
237 break;
238 case TELEMETRY_OPENED:
239 error = telemetry_process_message(telemetry);
240 break;
241 default:
242 break;
243 }
244
245 return error;
246}
247
248static HANDLE telemetry_server_get_channel_handle(telemetry_server* telemetry)
249{
250 void* buffer = nullptr;
251 DWORD BytesReturned = 0;
252 HANDLE ChannelEvent = nullptr;
253
254 WINPR_ASSERT(telemetry);
255
256 if (WTSVirtualChannelQuery(telemetry->telemetry_channel, WTSVirtualEventHandle, &buffer,
257 &BytesReturned) == TRUE)
258 {
259 if (BytesReturned == sizeof(HANDLE))
260 ChannelEvent = *(HANDLE*)buffer;
261
262 WTSFreeMemory(buffer);
263 }
264
265 return ChannelEvent;
266}
267
268static DWORD WINAPI telemetry_server_thread_func(LPVOID arg)
269{
270 DWORD nCount = 0;
271 HANDLE events[2] = WINPR_C_ARRAY_INIT;
272 telemetry_server* telemetry = (telemetry_server*)arg;
273 UINT error = CHANNEL_RC_OK;
274 DWORD status = 0;
275
276 WINPR_ASSERT(telemetry);
277
278 nCount = 0;
279 events[nCount++] = telemetry->stopEvent;
280
281 while ((error == CHANNEL_RC_OK) && (WaitForSingleObject(events[0], 0) != WAIT_OBJECT_0))
282 {
283 switch (telemetry->state)
284 {
285 case TELEMETRY_INITIAL:
286 error = telemetry_server_context_poll_int(&telemetry->context);
287 if (error == CHANNEL_RC_OK)
288 {
289 events[1] = telemetry_server_get_channel_handle(telemetry);
290 nCount = 2;
291 }
292 break;
293 case TELEMETRY_OPENED:
294 status = WaitForMultipleObjects(nCount, events, FALSE, INFINITE);
295 switch (status)
296 {
297 case WAIT_OBJECT_0:
298 break;
299 case WAIT_OBJECT_0 + 1:
300 case WAIT_TIMEOUT:
301 error = telemetry_server_context_poll_int(&telemetry->context);
302 break;
303
304 case WAIT_FAILED:
305 default:
306 error = ERROR_INTERNAL_ERROR;
307 break;
308 }
309 break;
310 default:
311 break;
312 }
313 }
314
315 (void)WTSVirtualChannelClose(telemetry->telemetry_channel);
316 telemetry->telemetry_channel = nullptr;
317
318 if (error && telemetry->context.rdpcontext)
319 setChannelError(telemetry->context.rdpcontext, error,
320 "telemetry_server_thread_func reported an error");
321
322 ExitThread(error);
323 return error;
324}
325
326static UINT telemetry_server_open(TelemetryServerContext* context)
327{
328 telemetry_server* telemetry = (telemetry_server*)context;
329
330 WINPR_ASSERT(telemetry);
331
332 if (!telemetry->externalThread && (telemetry->thread == nullptr))
333 {
334 telemetry->stopEvent = CreateEvent(nullptr, TRUE, FALSE, nullptr);
335 if (!telemetry->stopEvent)
336 {
337 WLog_Print(telemetry->log, WLOG_ERROR, "CreateEvent failed!");
338 return ERROR_INTERNAL_ERROR;
339 }
340
341 telemetry->thread =
342 CreateThread(nullptr, 0, telemetry_server_thread_func, telemetry, 0, nullptr);
343 if (!telemetry->thread)
344 {
345 WLog_Print(telemetry->log, WLOG_ERROR, "CreateThread failed!");
346 (void)CloseHandle(telemetry->stopEvent);
347 telemetry->stopEvent = nullptr;
348 return ERROR_INTERNAL_ERROR;
349 }
350 }
351 telemetry->isOpened = TRUE;
352
353 return CHANNEL_RC_OK;
354}
355
356static UINT telemetry_server_close(TelemetryServerContext* context)
357{
358 telemetry_server* telemetry = (telemetry_server*)context;
359
360 WINPR_ASSERT(telemetry);
361
362 if (!telemetry->externalThread && telemetry->thread)
363 {
364 (void)SetEvent(telemetry->stopEvent);
365
366 if (WaitForSingleObject(telemetry->thread, INFINITE) == WAIT_FAILED)
367 {
368 const UINT error = GetLastError();
369 if (telemetry->log)
370 WLog_Print(telemetry->log, WLOG_ERROR,
371 "WaitForSingleObject failed with error %" PRIu32 "", error);
372 return error;
373 }
374
375 (void)CloseHandle(telemetry->thread);
376 (void)CloseHandle(telemetry->stopEvent);
377 telemetry->thread = nullptr;
378 telemetry->stopEvent = nullptr;
379 }
380 if (telemetry->externalThread)
381 {
382 if (telemetry->state != TELEMETRY_INITIAL)
383 {
384 (void)WTSVirtualChannelClose(telemetry->telemetry_channel);
385 telemetry->telemetry_channel = nullptr;
386 telemetry->state = TELEMETRY_INITIAL;
387 }
388 }
389 telemetry->isOpened = FALSE;
390
391 return CHANNEL_RC_OK;
392}
393
394static UINT telemetry_server_context_poll(TelemetryServerContext* context)
395{
396 telemetry_server* telemetry = (telemetry_server*)context;
397
398 WINPR_ASSERT(telemetry);
399
400 if (!telemetry->externalThread)
401 return ERROR_INTERNAL_ERROR;
402
403 return telemetry_server_context_poll_int(context);
404}
405
406static BOOL telemetry_server_context_handle(TelemetryServerContext* context, HANDLE* handle)
407{
408 telemetry_server* telemetry = (telemetry_server*)context;
409
410 WINPR_ASSERT(telemetry);
411 WINPR_ASSERT(handle);
412
413 if (!telemetry->externalThread)
414 return FALSE;
415 if (telemetry->state == TELEMETRY_INITIAL)
416 return FALSE;
417
418 *handle = telemetry_server_get_channel_handle(telemetry);
419
420 return TRUE;
421}
422
423TelemetryServerContext* telemetry_server_context_new(HANDLE vcm)
424{
425 telemetry_server* telemetry = (telemetry_server*)calloc(1, sizeof(telemetry_server));
426
427 if (!telemetry)
428 return nullptr;
429 telemetry->log = WLog_Get(TAG);
430 if (!telemetry->log)
431 goto fail;
432 telemetry->context.vcm = vcm;
433 telemetry->context.Initialize = telemetry_server_initialize;
434 telemetry->context.Open = telemetry_server_open;
435 telemetry->context.Close = telemetry_server_close;
436 telemetry->context.Poll = telemetry_server_context_poll;
437 telemetry->context.ChannelHandle = telemetry_server_context_handle;
438
439 telemetry->buffer = Stream_New(nullptr, 4096);
440 if (!telemetry->buffer)
441 goto fail;
442
443 return &telemetry->context;
444fail:
445 WINPR_PRAGMA_DIAG_PUSH
446 WINPR_PRAGMA_DIAG_IGNORED_MISMATCHED_DEALLOC
447 telemetry_server_context_free(&telemetry->context);
448 WINPR_PRAGMA_DIAG_POP
449 return nullptr;
450}
451
452void telemetry_server_context_free(TelemetryServerContext* context)
453{
454 telemetry_server* telemetry = (telemetry_server*)context;
455
456 if (telemetry)
457 {
458 telemetry_server_close(context);
459 Stream_Free(telemetry->buffer, TRUE);
460 }
461
462 free(telemetry);
463}
TELEMETRY_RDP_TELEMETRY_PDU
Definition channels/telemetry.h:40