FreeRDP
Loading...
Searching...
No Matches
serial_main.c
1
21
22#include <freerdp/config.h>
23
24#include <errno.h>
25#include <stdio.h>
26#include <stdint.h>
27#include <stdlib.h>
28#include <string.h>
29
30#include <winpr/collections.h>
31#include <winpr/comm.h>
32#include <winpr/crt.h>
33#include <winpr/stream.h>
34#include <winpr/synch.h>
35#include <winpr/thread.h>
36#include <winpr/wlog.h>
37#include <winpr/assert.h>
38
39#include <freerdp/freerdp.h>
40#include <freerdp/channels/rdpdr.h>
41#include <freerdp/channels/log.h>
42#include <freerdp/utils/rdpdr_utils.h>
43
44#define TAG CHANNELS_TAG("serial.client")
45
46#define MAX_IRP_THREADS 5
47
48typedef struct
49{
50 DEVICE device;
51 BOOL permissive;
52 SERIAL_DRIVER_ID ServerSerialDriverId;
53 HANDLE hComm;
54
55 wLog* log;
56 HANDLE MainThread;
57 wMessageQueue* MainIrpQueue;
58
59 /* one thread per pending IRP and indexed according their CompletionId */
60 wListDictionary* IrpThreads;
61 CRITICAL_SECTION TerminatingIrpThreadsLock;
62 rdpContext* rdpcontext;
63} SERIAL_DEVICE;
64
65typedef struct
66{
67 SERIAL_DEVICE* serial;
68 IRP* irp;
69} IRP_THREAD_DATA;
70
71static void close_terminated_irp_thread_handles(SERIAL_DEVICE* serial, BOOL forceClose);
72static NTSTATUS GetLastErrorToIoStatus(SERIAL_DEVICE* serial)
73{
74 /* http://msdn.microsoft.com/en-us/library/ff547466%28v=vs.85%29.aspx#generic_status_values_for_serial_device_control_requests
75 */
76 switch (GetLastError())
77 {
78 case ERROR_BAD_DEVICE:
79 return STATUS_INVALID_DEVICE_REQUEST;
80
81 case ERROR_CALL_NOT_IMPLEMENTED:
82 return STATUS_NOT_IMPLEMENTED;
83
84 case ERROR_CANCELLED:
85 return STATUS_CANCELLED;
86
87 case ERROR_INSUFFICIENT_BUFFER:
88 return STATUS_BUFFER_TOO_SMALL; /* NB: STATUS_BUFFER_SIZE_TOO_SMALL not defined */
89
90 case ERROR_INVALID_DEVICE_OBJECT_PARAMETER: /* eg: SerCx2.sys' _purge() */
91 return STATUS_INVALID_DEVICE_STATE;
92
93 case ERROR_INVALID_HANDLE:
94 return STATUS_INVALID_DEVICE_REQUEST;
95
96 case ERROR_INVALID_PARAMETER:
97 return STATUS_INVALID_PARAMETER;
98
99 case ERROR_IO_DEVICE:
100 return STATUS_IO_DEVICE_ERROR;
101
102 case ERROR_IO_PENDING:
103 return STATUS_PENDING;
104
105 case ERROR_NOT_SUPPORTED:
106 return STATUS_NOT_SUPPORTED;
107
108 case ERROR_TIMEOUT:
109 return STATUS_TIMEOUT;
110 default:
111 break;
112 }
113
114 WLog_Print(serial->log, WLOG_DEBUG, "unexpected last-error: 0x%08" PRIX32 "", GetLastError());
115 return STATUS_UNSUCCESSFUL;
116}
117
118WINPR_ATTR_NODISCARD
119static UINT serial_process_irp_create(SERIAL_DEVICE* serial, IRP* irp)
120{
121 DWORD DesiredAccess = 0;
122 DWORD SharedAccess = 0;
123 DWORD CreateDisposition = 0;
124 UINT32 PathLength = 0;
125
126 WINPR_ASSERT(serial);
127 WINPR_ASSERT(irp);
128
129 if (!Stream_CheckAndLogRequiredLengthWLog(serial->log, irp->input, 32))
130 return ERROR_INVALID_DATA;
131
132 Stream_Read_UINT32(irp->input, DesiredAccess); /* DesiredAccess (4 bytes) */
133 Stream_Seek_UINT64(irp->input); /* AllocationSize (8 bytes) */
134 Stream_Seek_UINT32(irp->input); /* FileAttributes (4 bytes) */
135 Stream_Read_UINT32(irp->input, SharedAccess); /* SharedAccess (4 bytes) */
136 Stream_Read_UINT32(irp->input, CreateDisposition); /* CreateDisposition (4 bytes) */
137 Stream_Seek_UINT32(irp->input); /* CreateOptions (4 bytes) */
138 Stream_Read_UINT32(irp->input, PathLength); /* PathLength (4 bytes) */
139
140 if (!Stream_SafeSeek(irp->input, PathLength)) /* Path (variable) */
141 return ERROR_INVALID_DATA;
142
143 if (PathLength == 0) /* MS-RDPESP 2.2.2.2 */
144 return ERROR_INVALID_DATA;
145#ifndef _WIN32
146 /* Windows 2012 server sends on a first call :
147 * DesiredAccess = 0x00100080: SYNCHRONIZE | FILE_READ_ATTRIBUTES
148 * SharedAccess = 0x00000007: FILE_SHARE_DELETE | FILE_SHARE_WRITE | FILE_SHARE_READ
149 * CreateDisposition = 0x00000001: CREATE_NEW
150 *
151 * then Windows 2012 sends :
152 * DesiredAccess = 0x00120089: SYNCHRONIZE | READ_CONTROL | FILE_READ_ATTRIBUTES |
153 * FILE_READ_EA | FILE_READ_DATA SharedAccess = 0x00000007: FILE_SHARE_DELETE |
154 * FILE_SHARE_WRITE | FILE_SHARE_READ CreateDisposition = 0x00000001: CREATE_NEW
155 *
156 * WINPR_ASSERT(DesiredAccess == (GENERIC_READ | GENERIC_WRITE));
157 * WINPR_ASSERT(SharedAccess == 0);
158 * WINPR_ASSERT(CreateDisposition == OPEN_EXISTING);
159 *
160 */
161 WLog_Print(serial->log, WLOG_DEBUG,
162 "DesiredAccess: 0x%" PRIX32 ", SharedAccess: 0x%" PRIX32
163 ", CreateDisposition: 0x%" PRIX32 "",
164 DesiredAccess, SharedAccess, CreateDisposition);
165 /* FIXME: As of today only the flags below are supported by CommCreateFileA: */
166 DesiredAccess = GENERIC_READ | GENERIC_WRITE;
167 SharedAccess = 0;
168 CreateDisposition = OPEN_EXISTING;
169#endif
170 if (serial->hComm)
171 {
172 WLog_Print(serial->log, WLOG_ERROR, "Device %s already open, cancel request",
173 serial->device.name);
174 return ERROR_INVALID_DATA;
175 }
176
177 serial->hComm = winpr_CreateFile(serial->device.name, DesiredAccess, SharedAccess,
178 nullptr, /* SecurityAttributes */
179 CreateDisposition, 0, /* FlagsAndAttributes */
180 nullptr); /* TemplateFile */
181
182 if (!serial->hComm || (serial->hComm == INVALID_HANDLE_VALUE))
183 {
184 WLog_Print(serial->log, WLOG_WARN, "CreateFile failure: %s last-error: 0x%08" PRIX32 "",
185 serial->device.name, GetLastError());
186 serial->hComm = nullptr;
187 irp->IoStatus = STATUS_UNSUCCESSFUL;
188 goto error_handle;
189 }
190
191 _comm_setServerSerialDriver(serial->hComm, serial->ServerSerialDriverId);
192 _comm_set_permissive(serial->hComm, serial->permissive);
193 /* NOTE: binary mode/raw mode required for the redirection. On
194 * Linux, CommCreateFileA forces this setting.
195 */
196 /* ZeroMemory(&dcb, sizeof(DCB)); */
197 /* dcb.DCBlength = sizeof(DCB); */
198 /* GetCommState(serial->hComm, &dcb); */
199 /* dcb.fBinary = TRUE; */
200 /* SetCommState(serial->hComm, &dcb); */
201 WINPR_ASSERT(irp->FileId == 0);
202 irp->FileId = irp->devman->id_sequence++; /* FIXME: why not ((WINPR_COMM*)hComm)->fd? */
203 irp->IoStatus = STATUS_SUCCESS;
204 WLog_Print(serial->log, WLOG_DEBUG, "%s (DeviceId: %" PRIu32 ", FileId: %" PRIu32 ") created.",
205 serial->device.name, irp->device->id, irp->FileId);
206
207 {
208 DWORD BytesReturned = 0;
209 if (!CommDeviceIoControl(serial->hComm, IOCTL_SERIAL_RESET_DEVICE, nullptr, 0, nullptr, 0,
210 &BytesReturned, nullptr))
211 goto error_handle;
212 }
213
214error_handle:
215 Stream_Write_UINT32(irp->output, irp->FileId); /* FileId (4 bytes) */
216 Stream_Write_UINT8(irp->output, 0); /* Information (1 byte) */
217 return CHANNEL_RC_OK;
218}
219
220static UINT serial_process_irp_close(SERIAL_DEVICE* serial, IRP* irp)
221{
222 WINPR_ASSERT(serial);
223 WINPR_ASSERT(irp);
224
225 if (!Stream_CheckAndLogRequiredLengthWLog(serial->log, irp->input, 32))
226 return ERROR_INVALID_DATA;
227
228 Stream_Seek(irp->input, 32); /* Padding (32 bytes) */
229
230 if (!serial->hComm)
231 {
232 WLog_Print(serial->log, WLOG_ERROR, "serial device %s is not open, aborting close",
233 serial->device.name);
234 return ERROR_INVALID_DATA;
235 }
236
237 close_terminated_irp_thread_handles(serial, TRUE);
238
239 if (!CloseHandle(serial->hComm))
240 {
241 WLog_Print(serial->log, WLOG_WARN, "CloseHandle failure: %s (%" PRIu32 ") closed.",
242 serial->device.name, irp->device->id);
243 irp->IoStatus = STATUS_UNSUCCESSFUL;
244 goto error_handle;
245 }
246
247 WLog_Print(serial->log, WLOG_DEBUG, "%s (DeviceId: %" PRIu32 ", FileId: %" PRIu32 ") closed.",
248 serial->device.name, irp->device->id, irp->FileId);
249 irp->IoStatus = STATUS_SUCCESS;
250error_handle:
251 serial->hComm = nullptr;
252 Stream_Zero(irp->output, 5); /* Padding (5 bytes) */
253 return CHANNEL_RC_OK;
254}
255
261WINPR_ATTR_NODISCARD
262static UINT serial_process_irp_read(SERIAL_DEVICE* serial, IRP* irp)
263{
264 UINT32 Length = 0;
265 UINT64 Offset = 0;
266 DWORD nbRead = 0;
267
268 WINPR_ASSERT(serial);
269 WINPR_ASSERT(irp);
270
271 if (!Stream_CheckAndLogRequiredLengthWLog(serial->log, irp->input, 32))
272 return ERROR_INVALID_DATA;
273
274 Stream_Read_UINT32(irp->input, Length); /* Length (4 bytes) */
275 Stream_Read_UINT64(irp->input, Offset); /* Offset (8 bytes) */
276 (void)Offset; /* [MS-RDPESP] 3.2.5.1.4 Processing a Server Read Request Message
277 * ignored */
278 Stream_Seek(irp->input, 20); /* Padding (20 bytes) */
279
280 if (!serial->hComm)
281 {
282 WLog_Print(serial->log, WLOG_ERROR, "serial device %s is not open, aborting read",
283 serial->device.name);
284 return ERROR_INVALID_DATA;
285 }
286
287 BYTE* buffer = (BYTE*)calloc(Length, sizeof(BYTE));
288
289 if (buffer == nullptr)
290 {
291 irp->IoStatus = STATUS_NO_MEMORY;
292 goto error_handle;
293 }
294
295 /* MS-RDPESP 3.2.5.1.4: If the Offset field is not set to 0, the value MUST be ignored
296 * WINPR_ASSERT(Offset == 0);
297 */
298 WLog_Print(serial->log, WLOG_DEBUG, "reading %" PRIu32 " bytes from %s", Length,
299 serial->device.name);
300
301 /* FIXME: CommReadFile to be replaced by ReadFile */
302 if (CommReadFile(serial->hComm, buffer, Length, &nbRead, nullptr))
303 {
304 irp->IoStatus = STATUS_SUCCESS;
305 }
306 else
307 {
308 WLog_Print(serial->log, WLOG_DEBUG,
309 "read failure to %s, nbRead=%" PRIu32 ", last-error: 0x%08" PRIX32 "",
310 serial->device.name, nbRead, GetLastError());
311 irp->IoStatus = GetLastErrorToIoStatus(serial);
312 }
313
314 WLog_Print(serial->log, WLOG_DEBUG, "%" PRIu32 " bytes read from %s", nbRead,
315 serial->device.name);
316error_handle:
317 Stream_Write_UINT32(irp->output, nbRead); /* Length (4 bytes) */
318
319 if (nbRead > 0)
320 {
321 if (!Stream_EnsureRemainingCapacity(irp->output, nbRead))
322 {
323 WLog_Print(serial->log, WLOG_ERROR, "Stream_EnsureRemainingCapacity failed!");
324 free(buffer);
325 return CHANNEL_RC_NO_MEMORY;
326 }
327
328 Stream_Write(irp->output, buffer, nbRead); /* ReadData */
329 }
330
331 free(buffer);
332 return CHANNEL_RC_OK;
333}
334
335WINPR_ATTR_NODISCARD
336static UINT serial_process_irp_write(SERIAL_DEVICE* serial, IRP* irp)
337{
338 UINT32 Length = 0;
339 UINT64 Offset = 0;
340 DWORD nbWritten = 0;
341
342 WINPR_ASSERT(serial);
343 WINPR_ASSERT(irp);
344
345 if (!Stream_CheckAndLogRequiredLengthWLog(serial->log, irp->input, 32))
346 return ERROR_INVALID_DATA;
347
348 Stream_Read_UINT32(irp->input, Length); /* Length (4 bytes) */
349 Stream_Read_UINT64(irp->input, Offset); /* Offset (8 bytes) */
350 (void)Offset; /* [MS-RDPESP] 3.2.5.1.4 Processing a Server Read Request Message
351 * ignored */
352 if (!Stream_SafeSeek(irp->input, 20)) /* Padding (20 bytes) */
353 return ERROR_INVALID_DATA;
354
355 /* MS-RDPESP 3.2.5.1.5: The Offset field is ignored
356 * WINPR_ASSERT(Offset == 0);
357 *
358 * Using a serial printer, noticed though this field could be
359 * set.
360 */
361 WLog_Print(serial->log, WLOG_DEBUG, "writing %" PRIu32 " bytes to %s", Length,
362 serial->device.name);
363
364 const void* ptr = Stream_ConstPointer(irp->input);
365 if (!Stream_SafeSeek(irp->input, Length))
366 return ERROR_INVALID_DATA;
367
368 if (!serial->hComm)
369 {
370 WLog_Print(serial->log, WLOG_ERROR, "serial device %s is not open, aborting write",
371 serial->device.name);
372 return ERROR_INVALID_DATA;
373 }
374
375 /* FIXME: CommWriteFile to be replaced by WriteFile */
376 if (CommWriteFile(serial->hComm, ptr, Length, &nbWritten, nullptr))
377 {
378 irp->IoStatus = STATUS_SUCCESS;
379 }
380 else
381 {
382 WLog_Print(serial->log, WLOG_DEBUG,
383 "write failure to %s, nbWritten=%" PRIu32 ", last-error: 0x%08" PRIX32 "",
384 serial->device.name, nbWritten, GetLastError());
385 irp->IoStatus = GetLastErrorToIoStatus(serial);
386 }
387
388 WLog_Print(serial->log, WLOG_DEBUG, "%" PRIu32 " bytes written to %s", nbWritten,
389 serial->device.name);
390 Stream_Write_UINT32(irp->output, nbWritten); /* Length (4 bytes) */
391 Stream_Write_UINT8(irp->output, 0); /* Padding (1 byte) */
392 return CHANNEL_RC_OK;
393}
394
400WINPR_ATTR_NODISCARD
401static UINT serial_process_irp_device_control(SERIAL_DEVICE* serial, IRP* irp)
402{
403 DWORD BytesReturned = 0;
404
405 WINPR_ASSERT(serial);
406 WINPR_ASSERT(irp);
407
408 if (!Stream_CheckAndLogRequiredLengthWLog(serial->log, irp->input, 32))
409 return ERROR_INVALID_DATA;
410
411 const UINT32 OutputBufferLength =
412 Stream_Get_UINT32(irp->input); /* OutputBufferLength (4 bytes) */
413 const UINT32 InputBufferLength =
414 Stream_Get_UINT32(irp->input); /* InputBufferLength (4 bytes) */
415 const UINT32 IoControlCode = Stream_Get_UINT32(irp->input); /* IoControlCode (4 bytes) */
416 Stream_Seek(irp->input, 20); /* Padding (20 bytes) */
417
418 if (!Stream_CheckAndLogRequiredLengthWLog(serial->log, irp->input, InputBufferLength))
419 return ERROR_INVALID_DATA;
420
421 if (!serial->hComm)
422 {
423 WLog_Print(serial->log, WLOG_ERROR,
424 "serial device %s is not open, aborting device IO control", serial->device.name);
425 return ERROR_INVALID_DATA;
426 }
427
428 const BYTE* InputBuffer = Stream_PointerAs(irp->input, BYTE);
429 if (!Stream_SafeSeek(irp->input, InputBufferLength))
430 return ERROR_INVALID_DATA;
431
432 WLog_Print(serial->log, WLOG_DEBUG,
433 "CommDeviceIoControl: CompletionId=%" PRIu32 ", IoControlCode=[0x%" PRIX32 "] %s",
434 irp->CompletionId, IoControlCode, _comm_serial_ioctl_name(IoControlCode));
435
436 BYTE* OutputBuffer = nullptr;
437 if (OutputBufferLength > 0)
438 {
439 OutputBuffer = (BYTE*)calloc(OutputBufferLength, sizeof(BYTE));
440 if (!OutputBuffer)
441 {
442 irp->IoStatus = STATUS_NO_MEMORY;
443 goto error_handle;
444 }
445 }
446
447 /* FIXME: CommDeviceIoControl to be replaced by DeviceIoControl() */
448 if (CommDeviceIoControl(serial->hComm, IoControlCode, InputBuffer, InputBufferLength,
449 OutputBuffer, OutputBufferLength, &BytesReturned, nullptr))
450 {
451 /* WLog_Print(serial->log, WLOG_DEBUG, "CommDeviceIoControl: CompletionId=%"PRIu32",
452 * IoControlCode=[0x%"PRIX32"] %s done", irp->CompletionId, IoControlCode,
453 * _comm_serial_ioctl_name(IoControlCode)); */
454 irp->IoStatus = STATUS_SUCCESS;
455 }
456 else
457 {
458 WLog_Print(serial->log, WLOG_DEBUG,
459 "CommDeviceIoControl failure: IoControlCode=[0x%" PRIX32
460 "] %s, last-error: 0x%08" PRIX32 "",
461 IoControlCode, _comm_serial_ioctl_name(IoControlCode), GetLastError());
462 irp->IoStatus = GetLastErrorToIoStatus(serial);
463 BytesReturned = 0;
464 }
465
466error_handle:
467 Stream_Write_UINT32(irp->output, BytesReturned); /* OutputBufferLength (4 bytes) */
468
469 if (BytesReturned > 0)
470 {
471 if (!Stream_EnsureRemainingCapacity(irp->output, BytesReturned))
472 {
473 WLog_Print(serial->log, WLOG_ERROR, "Stream_EnsureRemainingCapacity failed!");
474 free(OutputBuffer);
475 return CHANNEL_RC_NO_MEMORY;
476 }
477
478 Stream_Write(irp->output, OutputBuffer, BytesReturned); /* OutputBuffer */
479 }
480
481 /* FIXME: Why at least Windows 2008R2 gets lost with this
482 * extra byte and likely on a IOCTL_SERIAL_SET_BAUD_RATE? The
483 * extra byte is well required according MS-RDPEFS
484 * 2.2.1.5.5 */
485 /* else */
486 /* { */
487 /* Stream_Write_UINT8(irp->output, 0); /\* Padding (1 byte) *\/ */
488 /* } */
489 free(OutputBuffer);
490 return CHANNEL_RC_OK;
491}
492
498static UINT serial_process_irp(SERIAL_DEVICE* serial, IRP* irp)
499{
500 UINT error = CHANNEL_RC_OK;
501
502 WINPR_ASSERT(serial);
503 WINPR_ASSERT(irp);
504
505 WLog_Print(serial->log, WLOG_DEBUG, "IRP MajorFunction: %s, MinorFunction: 0x%08" PRIX32 "\n",
506 rdpdr_irp_string(irp->MajorFunction), irp->MinorFunction);
507
508 switch (irp->MajorFunction)
509 {
510 case IRP_MJ_CREATE:
511 error = serial_process_irp_create(serial, irp);
512 break;
513
514 case IRP_MJ_CLOSE:
515 error = serial_process_irp_close(serial, irp);
516 break;
517
518 case IRP_MJ_READ:
519 error = serial_process_irp_read(serial, irp);
520 break;
521
522 case IRP_MJ_WRITE:
523 error = serial_process_irp_write(serial, irp);
524 break;
525
526 case IRP_MJ_DEVICE_CONTROL:
527 error = serial_process_irp_device_control(serial, irp);
528 break;
529
530 default:
531 irp->IoStatus = STATUS_NOT_SUPPORTED;
532 break;
533 }
534
535 DWORD level = WLOG_TRACE;
536 if (error)
537 level = WLOG_WARN;
538
539 WLog_Print(serial->log, level,
540 "[%s|0x%08" PRIx32 "] completed with %s [0x%08" PRIx32 "] (IoStatus %s [0x%08" PRIx32
541 "])",
542 rdpdr_irp_string(irp->MajorFunction), irp->MajorFunction, WTSErrorToString(error),
543 error, NtStatus2Tag(irp->IoStatus), WINPR_CXX_COMPAT_CAST(UINT32, irp->IoStatus));
544
545 return error;
546}
547
548static DWORD WINAPI irp_thread_func(LPVOID arg)
549{
550 IRP_THREAD_DATA* data = (IRP_THREAD_DATA*)arg;
551
552 WINPR_ASSERT(data);
553 WINPR_ASSERT(data->serial);
554 WINPR_ASSERT(data->irp);
555
556 /* blocks until the end of the request */
557 UINT error = serial_process_irp(data->serial, data->irp);
558 if (error)
559 {
560 WLog_Print(data->serial->log, WLOG_ERROR,
561 "serial_process_irp failed with error %" PRIu32 "", error);
562 data->irp->Discard(data->irp);
563 goto error_out;
564 }
565
566 EnterCriticalSection(&data->serial->TerminatingIrpThreadsLock);
567 WINPR_ASSERT(data->irp->Complete);
568 error = data->irp->Complete(data->irp);
569 LeaveCriticalSection(&data->serial->TerminatingIrpThreadsLock);
570error_out:
571
572 if (error && data->serial->rdpcontext)
573 setChannelError(data->serial->rdpcontext, error, "irp_thread_func reported an error");
574
575 /* NB: At this point, the server might already being reusing
576 * the CompletionId whereas the thread is not yet
577 * terminated */
578 free(data);
579 ExitThread(error);
580 return error;
581}
582
583static void close_unterminated_irp_thread(wListDictionary* list, wLog* log, ULONG_PTR id)
584{
585 WINPR_ASSERT(list);
586 HANDLE self = _GetCurrentThread();
587 HANDLE cirpThread = ListDictionary_GetItemValue(list, (void*)id);
588 if (self == cirpThread)
589 WLog_Print(log, WLOG_DEBUG, "Skipping termination of own IRP thread");
590 else
591 ListDictionary_Remove(list, (void*)id);
592}
593
594static void close_terminated_irp_thread(wListDictionary* list, wLog* log, ULONG_PTR id)
595{
596 WINPR_ASSERT(list);
597
598 HANDLE cirpThread = ListDictionary_GetItemValue(list, (void*)id);
599 /* FIXME: not quite sure a zero timeout is a good thing to check whether a thread is
600 * still alive or not */
601 const DWORD waitResult = WaitForSingleObject(cirpThread, 0);
602
603 if (waitResult == WAIT_OBJECT_0)
604 ListDictionary_Remove(list, (void*)id);
605 else if (waitResult != WAIT_TIMEOUT)
606 {
607 /* unexpected thread state */
608 WLog_Print(log, WLOG_WARN, "WaitForSingleObject, got an unexpected result=0x%" PRIX32 "\n",
609 waitResult);
610 }
611}
612
613void close_terminated_irp_thread_handles(SERIAL_DEVICE* serial, BOOL forceClose)
614{
615 WINPR_ASSERT(serial);
616
617 EnterCriticalSection(&serial->TerminatingIrpThreadsLock);
618
619 ListDictionary_Lock(serial->IrpThreads);
620 ULONG_PTR* ids = nullptr;
621 const size_t nbIds = ListDictionary_GetKeys(serial->IrpThreads, &ids);
622
623 for (size_t i = 0; i < nbIds; i++)
624 {
625 ULONG_PTR id = ids[i];
626 if (forceClose)
627 close_unterminated_irp_thread(serial->IrpThreads, serial->log, id);
628 else
629 close_terminated_irp_thread(serial->IrpThreads, serial->log, id);
630 }
631
632 free(ids);
633 ListDictionary_Unlock(serial->IrpThreads);
634
635 LeaveCriticalSection(&serial->TerminatingIrpThreadsLock);
636}
637
638static void create_irp_thread(SERIAL_DEVICE* serial, IRP* irp)
639{
640 IRP_THREAD_DATA* data = nullptr;
641 HANDLE irpThread = nullptr;
642 HANDLE previousIrpThread = nullptr;
643 uintptr_t key = 0;
644
645 WINPR_ASSERT(serial);
646 WINPR_ASSERT(irp);
647
648 close_terminated_irp_thread_handles(serial, FALSE);
649
650 /* NB: At this point and thanks to the synchronization we're
651 * sure that the incoming IRP uses well a recycled
652 * CompletionId or the server sent again an IRP already posted
653 * which didn't get yet a response (this later server behavior
654 * at least observed with IOCTL_SERIAL_WAIT_ON_MASK and
655 * mstsc.exe).
656 *
657 * FIXME: behavior documented somewhere? behavior not yet
658 * observed with FreeRDP).
659 */
660 key = irp->CompletionId + 1ull;
661
662 ListDictionary_Lock(serial->IrpThreads);
663 previousIrpThread = ListDictionary_GetItemValue(serial->IrpThreads, (void*)key);
664 ListDictionary_Unlock(serial->IrpThreads);
665
666 if (previousIrpThread)
667 {
668 /* Thread still alived <=> Request still pending */
669 WLog_Print(serial->log, WLOG_DEBUG,
670 "IRP recall: IRP with the CompletionId=%" PRIu32 " not yet completed!",
671 irp->CompletionId);
672 WINPR_ASSERT(FALSE); /* unimplemented */
673 /* TODO: WINPR_ASSERTs that previousIrpThread handles well
674 * the same request by checking more details. Need an
675 * access to the IRP object used by previousIrpThread
676 */
677 /* TODO: taking over the pending IRP or sending a kind
678 * of wake up signal to accelerate the pending
679 * request
680 *
681 * To be considered:
682 * if (IoControlCode == IOCTL_SERIAL_WAIT_ON_MASK) {
683 * pComm->PendingEvents |= SERIAL_EV_FREERDP_*;
684 * }
685 */
686 irp->Discard(irp);
687 return;
688 }
689
690 /* error_handle to be used ... */
691 data = (IRP_THREAD_DATA*)calloc(1, sizeof(IRP_THREAD_DATA));
692
693 if (data == nullptr)
694 {
695 WLog_Print(serial->log, WLOG_WARN, "Could not allocate a new IRP_THREAD_DATA.");
696 goto error_handle;
697 }
698
699 data->serial = serial;
700 data->irp = irp;
701 /* data freed by irp_thread_func */
702 irpThread = CreateThread(nullptr, 0, irp_thread_func, (void*)data, CREATE_SUSPENDED, nullptr);
703
704 if (irpThread == INVALID_HANDLE_VALUE)
705 {
706 WLog_Print(serial->log, WLOG_WARN, "Could not allocate a new IRP thread.");
707 goto error_handle;
708 }
709
710 key = irp->CompletionId + 1ull;
711
712 ListDictionary_Lock(serial->IrpThreads);
713 if (ListDictionary_Count(serial->IrpThreads) >= MAX_IRP_THREADS)
714 {
715 WLog_Print(serial->log, WLOG_WARN,
716 "Number of IRP threads threshold reached: %" PRIuz ", keep on anyway",
717 ListDictionary_Count(serial->IrpThreads));
718 WINPR_ASSERT(FALSE); /* unimplemented */
719 /* TODO: MAX_IRP_THREADS has been thought to avoid a
720 * flooding of pending requests. Use
721 * WaitForMultipleObjects() when available in winpr
722 * for threads.
723 */
724 }
725
726 {
727 const BOOL added = ListDictionary_Add(serial->IrpThreads, (void*)key, irpThread);
728
729 /* Start the thread before the list is unlocked: IRP_MJ_CLOSE terminates and closes every
730 * thread it finds in the list, which must not happen to a thread not yet started. */
731 if (added)
732 ResumeThread(irpThread);
733 ListDictionary_Unlock(serial->IrpThreads);
734
735 if (!added)
736 {
737 WLog_Print(serial->log, WLOG_ERROR, "ListDictionary_Add failed!");
738 goto error_handle;
739 }
740 }
741
742 return;
743error_handle:
744 if (irpThread)
745 (void)CloseHandle(irpThread);
746 irp->IoStatus = STATUS_NO_MEMORY;
747 WINPR_ASSERT(irp->Complete);
748 const UINT rc = irp->Complete(irp);
749 if (rc != CHANNEL_RC_OK)
750 WLog_Print(serial->log, WLOG_WARN, "irp->Complete failed with %" PRIu32, rc);
751 free(data);
752}
753
754static DWORD WINAPI serial_thread_func(LPVOID arg)
755{
756 IRP* irp = nullptr;
757 wMessage message = WINPR_C_ARRAY_INIT;
758 SERIAL_DEVICE* serial = (SERIAL_DEVICE*)arg;
759 UINT error = CHANNEL_RC_OK;
760
761 WINPR_ASSERT(serial);
762
763 while (1)
764 {
765 if (!MessageQueue_Wait(serial->MainIrpQueue))
766 {
767 WLog_Print(serial->log, WLOG_ERROR, "MessageQueue_Wait failed!");
768 error = ERROR_INTERNAL_ERROR;
769 break;
770 }
771
772 if (!MessageQueue_Peek(serial->MainIrpQueue, &message, TRUE))
773 {
774 WLog_Print(serial->log, WLOG_ERROR, "MessageQueue_Peek failed!");
775 error = ERROR_INTERNAL_ERROR;
776 break;
777 }
778
779 if (message.id == WMQ_QUIT)
780 break;
781
782 irp = (IRP*)message.wParam;
783
784 if (irp)
785 create_irp_thread(serial, irp);
786 }
787
788 ListDictionary_Lock(serial->IrpThreads);
789 ListDictionary_Clear(serial->IrpThreads);
790 ListDictionary_Unlock(serial->IrpThreads);
791
792 if (error && serial->rdpcontext)
793 setChannelError(serial->rdpcontext, error, "serial_thread_func reported an error");
794
795 ExitThread(error);
796 return error;
797}
798
804static UINT serial_irp_request(DEVICE* device, IRP* irp)
805{
806 SERIAL_DEVICE* serial = (SERIAL_DEVICE*)device;
807 WINPR_ASSERT(irp != nullptr);
808 WINPR_ASSERT(serial);
809
810 /* NB: ENABLE_ASYNCIO is set, (MS-RDPEFS 2.2.2.7.2) this
811 * allows the server to send multiple simultaneous read or
812 * write requests.
813 */
814
815 if (!MessageQueue_Post(serial->MainIrpQueue, nullptr, 0, (void*)irp, nullptr))
816 {
817 WLog_Print(serial->log, WLOG_ERROR, "MessageQueue_Post failed!");
818 irp->Discard(irp);
819 return ERROR_INTERNAL_ERROR;
820 }
821
822 return CHANNEL_RC_OK;
823}
824
830static UINT serial_free(DEVICE* device)
831{
832 UINT error = 0;
833 SERIAL_DEVICE* serial = (SERIAL_DEVICE*)device;
834 if (!serial)
835 return CHANNEL_RC_OK;
836
837 WLog_Print(serial->log, WLOG_DEBUG, "freeing");
838 if (serial->MainIrpQueue)
839 MessageQueue_PostQuit(serial->MainIrpQueue, 0);
840
841 if (serial->MainThread)
842 {
843 if (WaitForSingleObject(serial->MainThread, INFINITE) == WAIT_FAILED)
844 {
845 error = GetLastError();
846 WLog_Print(serial->log, WLOG_ERROR,
847 "WaitForSingleObject failed with error %" PRIu32 "!", error);
848 }
849 (void)CloseHandle(serial->MainThread);
850 }
851
852 if (serial->hComm)
853 (void)CloseHandle(serial->hComm);
854
855 /* Clean up resources */
856 Stream_Free(serial->device.data, TRUE);
857 MessageQueue_Free(serial->MainIrpQueue);
858 ListDictionary_Free(serial->IrpThreads);
859 DeleteCriticalSection(&serial->TerminatingIrpThreadsLock);
860 free(serial);
861 return CHANNEL_RC_OK;
862}
863
864static void serial_message_free(void* obj)
865{
866 wMessage* msg = obj;
867 if (!msg)
868 return;
869 if (msg->id != 0)
870 return;
871
872 IRP* irp = (IRP*)msg->wParam;
873 if (!irp)
874 return;
875 WINPR_ASSERT(irp->Discard);
876 irp->Discard(irp);
877}
878
879static void irp_thread_close(void* arg)
880{
881 HANDLE hdl = arg;
882 if (hdl)
883 {
884 HANDLE thz = _GetCurrentThread();
885 if (thz == hdl)
886 WLog_WARN(TAG, "closing self, ignoring...");
887 else
888 {
889 (void)TerminateThread(hdl, 0);
890 (void)WaitForSingleObject(hdl, INFINITE);
891 (void)CloseHandle(hdl);
892 }
893 }
894}
895
901FREERDP_ENTRY_POINT(
902 UINT VCAPITYPE serial_DeviceServiceEntry(PDEVICE_SERVICE_ENTRY_POINTS pEntryPoints))
903{
904 size_t len = 0;
905 SERIAL_DEVICE* serial = nullptr;
906 UINT error = CHANNEL_RC_OK;
907
908 WINPR_ASSERT(pEntryPoints);
909
910 RDPDR_SERIAL* device = (RDPDR_SERIAL*)pEntryPoints->device;
911 WINPR_ASSERT(device);
912
913 wLog* log = WLog_Get(TAG);
914 const char* name = device->device.Name;
915 const char* path = device->Path;
916 const char* driver = device->Driver;
917
918 if (!name || (name[0] == '*'))
919 {
920 /* TODO: implement auto detection of serial ports */
921 WLog_Print(log, WLOG_WARN,
922 "Serial port autodetection not implemented, nothing will be redirected!");
923 return CHANNEL_RC_OK;
924 }
925
926 if ((name && name[0]) && (path && path[0]))
927 {
928 WLog_Print(log, WLOG_DEBUG, "Defining %s as %s", name, path);
929
930 if (!DefineCommDevice(name /* eg: COM1 */, path /* eg: /dev/ttyS0 */))
931 {
932 DWORD status = GetLastError();
933 WLog_Print(log, WLOG_ERROR, "DefineCommDevice failed with %08" PRIx32, status);
934 return ERROR_INTERNAL_ERROR;
935 }
936
937 serial = (SERIAL_DEVICE*)calloc(1, sizeof(SERIAL_DEVICE));
938
939 if (!serial)
940 {
941 WLog_Print(log, WLOG_ERROR, "calloc failed!");
942 return CHANNEL_RC_NO_MEMORY;
943 }
944
945 serial->log = log;
946 serial->device.type = RDPDR_DTYP_SERIAL;
947 serial->device.name = name;
948 serial->device.IRPRequest = serial_irp_request;
949 serial->device.Free = serial_free;
950 serial->rdpcontext = pEntryPoints->rdpcontext;
951 len = strlen(name);
952 serial->device.data = Stream_New(nullptr, len + 1);
953
954 if (!serial->device.data)
955 {
956 WLog_Print(serial->log, WLOG_ERROR, "calloc failed!");
957 error = CHANNEL_RC_NO_MEMORY;
958 goto error_out;
959 }
960
961 for (size_t i = 0; i <= len; i++)
962 Stream_Write_INT8(serial->device.data, name[i] < 0 ? '_' : name[i]);
963
964 if (driver != nullptr)
965 {
966 if (_stricmp(driver, "Serial") == 0)
967 serial->ServerSerialDriverId = SerialDriverSerialSys;
968 else if (_stricmp(driver, "SerCx") == 0)
969 serial->ServerSerialDriverId = SerialDriverSerCxSys;
970 else if (_stricmp(driver, "SerCx2") == 0)
971 serial->ServerSerialDriverId = SerialDriverSerCx2Sys;
972 else
973 {
974 WLog_Print(serial->log, WLOG_WARN, "Unknown server's serial driver: %s.", driver);
975 WLog_Print(serial->log, WLOG_WARN,
976 "Valid options are: 'Serial' (default), 'SerCx' and 'SerCx2'");
977 goto error_out;
978 }
979 }
980 else
981 {
982 /* default driver */
983 serial->ServerSerialDriverId = SerialDriverSerialSys;
984 }
985
986 if (device->Permissive != nullptr)
987 {
988 if (_stricmp(device->Permissive, "permissive") == 0)
989 {
990 serial->permissive = TRUE;
991 }
992 else
993 {
994 WLog_Print(serial->log, WLOG_WARN, "Unknown flag: %s", device->Permissive);
995 goto error_out;
996 }
997 }
998
999 WLog_Print(serial->log, WLOG_DEBUG, "Server's serial driver: %s (id: %u)", driver,
1000 serial->ServerSerialDriverId);
1001
1002 serial->MainIrpQueue = MessageQueue_New(nullptr);
1003
1004 if (!serial->MainIrpQueue)
1005 {
1006 WLog_Print(serial->log, WLOG_ERROR, "MessageQueue_New failed!");
1007 error = CHANNEL_RC_NO_MEMORY;
1008 goto error_out;
1009 }
1010
1011 {
1012 wObject* obj = MessageQueue_Object(serial->MainIrpQueue);
1013 WINPR_ASSERT(obj);
1014 obj->fnObjectFree = serial_message_free;
1015 }
1016
1017 /* IrpThreads content only modified by create_irp_thread() */
1018 serial->IrpThreads = ListDictionary_New(FALSE);
1019
1020 if (!serial->IrpThreads)
1021 {
1022 WLog_Print(serial->log, WLOG_ERROR, "ListDictionary_New failed!");
1023 error = CHANNEL_RC_NO_MEMORY;
1024 goto error_out;
1025 }
1026
1027 {
1028 wObject* obj = ListDictionary_ValueObject(serial->IrpThreads);
1029 WINPR_ASSERT(obj);
1030 obj->fnObjectFree = irp_thread_close;
1031 }
1032
1033 InitializeCriticalSection(&serial->TerminatingIrpThreadsLock);
1034
1035 error = pEntryPoints->RegisterDevice(pEntryPoints->devman, &serial->device);
1036 if (error != CHANNEL_RC_OK)
1037 {
1038 WLog_Print(serial->log, WLOG_ERROR,
1039 "EntryPoints->RegisterDevice failed with error %" PRIu32 "!", error);
1040 goto error_out;
1041 }
1042
1043 serial->MainThread = CreateThread(nullptr, 0, serial_thread_func, serial, 0, nullptr);
1044 if (!serial->MainThread)
1045 {
1046 WLog_Print(serial->log, WLOG_ERROR, "CreateThread failed!");
1047 error = ERROR_INTERNAL_ERROR;
1048 goto error_out;
1049 }
1050 }
1051
1052 return error;
1053error_out:
1054 if (serial)
1055 serial_free(&serial->device);
1056 return error;
1057}
This struct contains function pointer to initialize/free objects.
Definition collections.h:52