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
520 WINPR_ASSERT(data);
521 WINPR_ASSERT(data->serial);
522 WINPR_ASSERT(data->irp);
523
524 /* blocks until the end of the request */
525 UINT error = serial_process_irp(data->serial, data->irp);
526 if (error)
527 {
528 WLog_Print(data->serial->log, WLOG_ERROR,
529 "serial_process_irp failed with error %" PRIu32 "", error);
530 data->irp->Discard(data->irp);
531 goto error_out;
532 }
533
534 EnterCriticalSection(&data->serial->TerminatingIrpThreadsLock);
535 WINPR_ASSERT(data->irp->Complete);
536 error = data->irp->Complete(data->irp);
537 LeaveCriticalSection(&data->serial->TerminatingIrpThreadsLock);
538error_out:
539
540 if (error && data->serial->rdpcontext)
541 setChannelError(data->serial->rdpcontext, error, "irp_thread_func reported an error");
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 ListDictionary_Lock(serial->IrpThreads);
588 ULONG_PTR* ids = NULL;
589 const size_t nbIds = ListDictionary_GetKeys(serial->IrpThreads, &ids);
590
591 for (size_t i = 0; i < nbIds; i++)
592 {
593 ULONG_PTR id = ids[i];
594 if (forceClose)
595 close_unterminated_irp_thread(serial->IrpThreads, serial->log, id);
596 else
597 close_terminated_irp_thread(serial->IrpThreads, serial->log, id);
598 }
599
600 free(ids);
601 ListDictionary_Unlock(serial->IrpThreads);
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
630 ListDictionary_Lock(serial->IrpThreads);
631 previousIrpThread = ListDictionary_GetItemValue(serial->IrpThreads, (void*)key);
632 ListDictionary_Unlock(serial->IrpThreads);
633
634 if (previousIrpThread)
635 {
636 /* Thread still alived <=> Request still pending */
637 WLog_Print(serial->log, WLOG_DEBUG,
638 "IRP recall: IRP with the CompletionId=%" PRIu32 " not yet completed!",
639 irp->CompletionId);
640 WINPR_ASSERT(FALSE); /* unimplemented */
641 /* TODO: WINPR_ASSERTs that previousIrpThread handles well
642 * the same request by checking more details. Need an
643 * access to the IRP object used by previousIrpThread
644 */
645 /* TODO: taking over the pending IRP or sending a kind
646 * of wake up signal to accelerate the pending
647 * request
648 *
649 * To be considered:
650 * if (IoControlCode == IOCTL_SERIAL_WAIT_ON_MASK) {
651 * pComm->PendingEvents |= SERIAL_EV_FREERDP_*;
652 * }
653 */
654 irp->Discard(irp);
655 return;
656 }
657
658 /* error_handle to be used ... */
659 data = (IRP_THREAD_DATA*)calloc(1, sizeof(IRP_THREAD_DATA));
660
661 if (data == NULL)
662 {
663 WLog_Print(serial->log, WLOG_WARN, "Could not allocate a new IRP_THREAD_DATA.");
664 goto error_handle;
665 }
666
667 data->serial = serial;
668 data->irp = irp;
669 /* data freed by irp_thread_func */
670 irpThread = CreateThread(NULL, 0, irp_thread_func, (void*)data, CREATE_SUSPENDED, NULL);
671
672 if (irpThread == INVALID_HANDLE_VALUE)
673 {
674 WLog_Print(serial->log, WLOG_WARN, "Could not allocate a new IRP thread.");
675 goto error_handle;
676 }
677
678 key = irp->CompletionId + 1ull;
679
680 ListDictionary_Lock(serial->IrpThreads);
681 if (ListDictionary_Count(serial->IrpThreads) >= MAX_IRP_THREADS)
682 {
683 WLog_Print(serial->log, WLOG_WARN,
684 "Number of IRP threads threshold reached: %" PRIuz ", keep on anyway",
685 ListDictionary_Count(serial->IrpThreads));
686 WINPR_ASSERT(FALSE); /* unimplemented */
687 /* TODO: MAX_IRP_THREADS has been thought to avoid a
688 * flooding of pending requests. Use
689 * WaitForMultipleObjects() when available in winpr
690 * for threads.
691 */
692 }
693
694 {
695 const BOOL added = ListDictionary_Add(serial->IrpThreads, (void*)key, irpThread);
696 ListDictionary_Unlock(serial->IrpThreads);
697
698 if (!added)
699 {
700 WLog_Print(serial->log, WLOG_ERROR, "ListDictionary_Add failed!");
701 goto error_handle;
702 }
703 }
704
705 ResumeThread(irpThread);
706
707 return;
708error_handle:
709 if (irpThread)
710 (void)CloseHandle(irpThread);
711 irp->IoStatus = STATUS_NO_MEMORY;
712 WINPR_ASSERT(irp->Complete);
713 irp->Complete(irp);
714 free(data);
715}
716
717static DWORD WINAPI serial_thread_func(LPVOID arg)
718{
719 IRP* irp = NULL;
720 wMessage message = { 0 };
721 SERIAL_DEVICE* serial = (SERIAL_DEVICE*)arg;
722 UINT error = CHANNEL_RC_OK;
723
724 WINPR_ASSERT(serial);
725
726 while (1)
727 {
728 if (!MessageQueue_Wait(serial->MainIrpQueue))
729 {
730 WLog_Print(serial->log, WLOG_ERROR, "MessageQueue_Wait failed!");
731 error = ERROR_INTERNAL_ERROR;
732 break;
733 }
734
735 if (!MessageQueue_Peek(serial->MainIrpQueue, &message, TRUE))
736 {
737 WLog_Print(serial->log, WLOG_ERROR, "MessageQueue_Peek failed!");
738 error = ERROR_INTERNAL_ERROR;
739 break;
740 }
741
742 if (message.id == WMQ_QUIT)
743 break;
744
745 irp = (IRP*)message.wParam;
746
747 if (irp)
748 create_irp_thread(serial, irp);
749 }
750
751 ListDictionary_Lock(serial->IrpThreads);
752 ListDictionary_Clear(serial->IrpThreads);
753 ListDictionary_Unlock(serial->IrpThreads);
754
755 if (error && serial->rdpcontext)
756 setChannelError(serial->rdpcontext, error, "serial_thread_func reported an error");
757
758 ExitThread(error);
759 return error;
760}
761
767static UINT serial_irp_request(DEVICE* device, IRP* irp)
768{
769 SERIAL_DEVICE* serial = (SERIAL_DEVICE*)device;
770 WINPR_ASSERT(irp != NULL);
771 WINPR_ASSERT(serial);
772
773 if (irp == NULL)
774 return CHANNEL_RC_OK;
775
776 /* NB: ENABLE_ASYNCIO is set, (MS-RDPEFS 2.2.2.7.2) this
777 * allows the server to send multiple simultaneous read or
778 * write requests.
779 */
780
781 if (!MessageQueue_Post(serial->MainIrpQueue, NULL, 0, (void*)irp, NULL))
782 {
783 WLog_Print(serial->log, WLOG_ERROR, "MessageQueue_Post failed!");
784 return ERROR_INTERNAL_ERROR;
785 }
786
787 return CHANNEL_RC_OK;
788}
789
795static UINT serial_free(DEVICE* device)
796{
797 UINT error = 0;
798 SERIAL_DEVICE* serial = (SERIAL_DEVICE*)device;
799 if (!serial)
800 return CHANNEL_RC_OK;
801
802 WLog_Print(serial->log, WLOG_DEBUG, "freeing");
803 if (serial->MainIrpQueue)
804 MessageQueue_PostQuit(serial->MainIrpQueue, 0);
805
806 if (serial->MainThread)
807 {
808 if (WaitForSingleObject(serial->MainThread, INFINITE) == WAIT_FAILED)
809 {
810 error = GetLastError();
811 WLog_Print(serial->log, WLOG_ERROR,
812 "WaitForSingleObject failed with error %" PRIu32 "!", error);
813 }
814 (void)CloseHandle(serial->MainThread);
815 }
816
817 if (serial->hComm)
818 (void)CloseHandle(serial->hComm);
819
820 /* Clean up resources */
821 Stream_Free(serial->device.data, TRUE);
822 MessageQueue_Free(serial->MainIrpQueue);
823 ListDictionary_Free(serial->IrpThreads);
824 DeleteCriticalSection(&serial->TerminatingIrpThreadsLock);
825 free(serial);
826 return CHANNEL_RC_OK;
827}
828
829static void serial_message_free(void* obj)
830{
831 wMessage* msg = obj;
832 if (!msg)
833 return;
834 if (msg->id != 0)
835 return;
836
837 IRP* irp = (IRP*)msg->wParam;
838 if (!irp)
839 return;
840 WINPR_ASSERT(irp->Discard);
841 irp->Discard(irp);
842}
843
844static void irp_thread_close(void* arg)
845{
846 HANDLE hdl = arg;
847 if (hdl)
848 {
849 HANDLE thz = _GetCurrentThread();
850 if (thz == hdl)
851 WLog_WARN(TAG, "closing self, ignoring...");
852 else
853 {
854 (void)TerminateThread(hdl, 0);
855 (void)WaitForSingleObject(hdl, INFINITE);
856 (void)CloseHandle(hdl);
857 }
858 }
859}
860
866FREERDP_ENTRY_POINT(
867 UINT VCAPITYPE serial_DeviceServiceEntry(PDEVICE_SERVICE_ENTRY_POINTS pEntryPoints))
868{
869 size_t len = 0;
870 SERIAL_DEVICE* serial = NULL;
871 UINT error = CHANNEL_RC_OK;
872
873 WINPR_ASSERT(pEntryPoints);
874
875 RDPDR_SERIAL* device = (RDPDR_SERIAL*)pEntryPoints->device;
876 WINPR_ASSERT(device);
877
878 wLog* log = WLog_Get(TAG);
879 const char* name = device->device.Name;
880 const char* path = device->Path;
881 const char* driver = device->Driver;
882
883 if (!name || (name[0] == '*'))
884 {
885 /* TODO: implement auto detection of serial ports */
886 WLog_Print(log, WLOG_WARN,
887 "Serial port autodetection not implemented, nothing will be redirected!");
888 return CHANNEL_RC_OK;
889 }
890
891 if ((name && name[0]) && (path && path[0]))
892 {
893 WLog_Print(log, WLOG_DEBUG, "Defining %s as %s", name, path);
894
895 if (!DefineCommDevice(name /* eg: COM1 */, path /* eg: /dev/ttyS0 */))
896 {
897 DWORD status = GetLastError();
898 WLog_Print(log, WLOG_ERROR, "DefineCommDevice failed with %08" PRIx32, status);
899 return ERROR_INTERNAL_ERROR;
900 }
901
902 serial = (SERIAL_DEVICE*)calloc(1, sizeof(SERIAL_DEVICE));
903
904 if (!serial)
905 {
906 WLog_Print(log, WLOG_ERROR, "calloc failed!");
907 return CHANNEL_RC_NO_MEMORY;
908 }
909
910 serial->log = log;
911 serial->device.type = RDPDR_DTYP_SERIAL;
912 serial->device.name = name;
913 serial->device.IRPRequest = serial_irp_request;
914 serial->device.Free = serial_free;
915 serial->rdpcontext = pEntryPoints->rdpcontext;
916 len = strlen(name);
917 serial->device.data = Stream_New(NULL, len + 1);
918
919 if (!serial->device.data)
920 {
921 WLog_Print(serial->log, WLOG_ERROR, "calloc failed!");
922 error = CHANNEL_RC_NO_MEMORY;
923 goto error_out;
924 }
925
926 for (size_t i = 0; i <= len; i++)
927 Stream_Write_INT8(serial->device.data, name[i] < 0 ? '_' : name[i]);
928
929 if (driver != NULL)
930 {
931 if (_stricmp(driver, "Serial") == 0)
932 serial->ServerSerialDriverId = SerialDriverSerialSys;
933 else if (_stricmp(driver, "SerCx") == 0)
934 serial->ServerSerialDriverId = SerialDriverSerCxSys;
935 else if (_stricmp(driver, "SerCx2") == 0)
936 serial->ServerSerialDriverId = SerialDriverSerCx2Sys;
937 else
938 {
939 WLog_Print(serial->log, WLOG_WARN, "Unknown server's serial driver: %s.", driver);
940 WLog_Print(serial->log, WLOG_WARN,
941 "Valid options are: 'Serial' (default), 'SerCx' and 'SerCx2'");
942 goto error_out;
943 }
944 }
945 else
946 {
947 /* default driver */
948 serial->ServerSerialDriverId = SerialDriverSerialSys;
949 }
950
951 if (device->Permissive != NULL)
952 {
953 if (_stricmp(device->Permissive, "permissive") == 0)
954 {
955 serial->permissive = TRUE;
956 }
957 else
958 {
959 WLog_Print(serial->log, WLOG_WARN, "Unknown flag: %s", device->Permissive);
960 goto error_out;
961 }
962 }
963
964 WLog_Print(serial->log, WLOG_DEBUG, "Server's serial driver: %s (id: %u)", driver,
965 serial->ServerSerialDriverId);
966
967 serial->MainIrpQueue = MessageQueue_New(NULL);
968
969 if (!serial->MainIrpQueue)
970 {
971 WLog_Print(serial->log, WLOG_ERROR, "MessageQueue_New failed!");
972 error = CHANNEL_RC_NO_MEMORY;
973 goto error_out;
974 }
975
976 {
977 wObject* obj = MessageQueue_Object(serial->MainIrpQueue);
978 WINPR_ASSERT(obj);
979 obj->fnObjectFree = serial_message_free;
980 }
981
982 /* IrpThreads content only modified by create_irp_thread() */
983 serial->IrpThreads = ListDictionary_New(FALSE);
984
985 if (!serial->IrpThreads)
986 {
987 WLog_Print(serial->log, WLOG_ERROR, "ListDictionary_New failed!");
988 error = CHANNEL_RC_NO_MEMORY;
989 goto error_out;
990 }
991
992 {
993 wObject* obj = ListDictionary_ValueObject(serial->IrpThreads);
994 WINPR_ASSERT(obj);
995 obj->fnObjectFree = irp_thread_close;
996 }
997
998 InitializeCriticalSection(&serial->TerminatingIrpThreadsLock);
999
1000 error = pEntryPoints->RegisterDevice(pEntryPoints->devman, &serial->device);
1001 if (error != CHANNEL_RC_OK)
1002 {
1003 WLog_Print(serial->log, WLOG_ERROR,
1004 "EntryPoints->RegisterDevice failed with error %" PRIu32 "!", error);
1005 goto error_out;
1006 }
1007
1008 serial->MainThread = CreateThread(NULL, 0, serial_thread_func, serial, 0, NULL);
1009 if (!serial->MainThread)
1010 {
1011 WLog_Print(serial->log, WLOG_ERROR, "CreateThread failed!");
1012 error = ERROR_INTERNAL_ERROR;
1013 goto error_out;
1014 }
1015 }
1016
1017 return error;
1018error_out:
1019 if (serial)
1020 serial_free(&serial->device);
1021 return error;
1022}
RDPDR_SERIAL
Definition settings_types.h:476
DEVICE_SERVICE_ENTRY_POINTS
Definition channels/rdpdr.h:381
RTL_CRITICAL_SECTION
Definition include/winpr/synch.h:174
wObject
This struct contains function pointer to initialize/free objects.
Definition collections.h:52
wObject::fnObjectFree
OBJECT_FREE_FN fnObjectFree
Definition collections.h:58