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