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