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