22#include <freerdp/config.h>
30#include <winpr/collections.h>
31#include <winpr/comm.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>
39#include <freerdp/freerdp.h>
40#include <freerdp/channels/rdpdr.h>
41#include <freerdp/channels/log.h>
42#include <freerdp/utils/rdpdr_utils.h>
44#define TAG CHANNELS_TAG("serial.client")
46#define MAX_IRP_THREADS 5
52 SERIAL_DRIVER_ID ServerSerialDriverId;
57 wMessageQueue* MainIrpQueue;
60 wListDictionary* IrpThreads;
61 CRITICAL_SECTION TerminatingIrpThreadsLock;
62 rdpContext* rdpcontext;
67 SERIAL_DEVICE* serial;
71static void close_terminated_irp_thread_handles(SERIAL_DEVICE* serial, BOOL forceClose);
72static NTSTATUS GetLastErrorToIoStatus(SERIAL_DEVICE* serial)
76 switch (GetLastError())
78 case ERROR_BAD_DEVICE:
79 return STATUS_INVALID_DEVICE_REQUEST;
81 case ERROR_CALL_NOT_IMPLEMENTED:
82 return STATUS_NOT_IMPLEMENTED;
85 return STATUS_CANCELLED;
87 case ERROR_INSUFFICIENT_BUFFER:
88 return STATUS_BUFFER_TOO_SMALL;
90 case ERROR_INVALID_DEVICE_OBJECT_PARAMETER:
91 return STATUS_INVALID_DEVICE_STATE;
93 case ERROR_INVALID_HANDLE:
94 return STATUS_INVALID_DEVICE_REQUEST;
96 case ERROR_INVALID_PARAMETER:
97 return STATUS_INVALID_PARAMETER;
100 return STATUS_IO_DEVICE_ERROR;
102 case ERROR_IO_PENDING:
103 return STATUS_PENDING;
105 case ERROR_NOT_SUPPORTED:
106 return STATUS_NOT_SUPPORTED;
109 return STATUS_TIMEOUT;
114 WLog_Print(serial->log, WLOG_DEBUG,
"unexpected last-error: 0x%08" PRIX32
"", GetLastError());
115 return STATUS_UNSUCCESSFUL;
119static UINT serial_process_irp_create(SERIAL_DEVICE* serial, IRP* irp)
121 DWORD DesiredAccess = 0;
122 DWORD SharedAccess = 0;
123 DWORD CreateDisposition = 0;
124 UINT32 PathLength = 0;
126 WINPR_ASSERT(serial);
129 if (!Stream_CheckAndLogRequiredLengthWLog(serial->log, irp->input, 32))
130 return ERROR_INVALID_DATA;
132 Stream_Read_UINT32(irp->input, DesiredAccess);
133 Stream_Seek_UINT64(irp->input);
134 Stream_Seek_UINT32(irp->input);
135 Stream_Read_UINT32(irp->input, SharedAccess);
136 Stream_Read_UINT32(irp->input, CreateDisposition);
137 Stream_Seek_UINT32(irp->input);
138 Stream_Read_UINT32(irp->input, PathLength);
140 if (!Stream_SafeSeek(irp->input, PathLength))
141 return ERROR_INVALID_DATA;
144 return ERROR_INVALID_DATA;
161 WLog_Print(serial->log, WLOG_DEBUG,
162 "DesiredAccess: 0x%" PRIX32
", SharedAccess: 0x%" PRIX32
163 ", CreateDisposition: 0x%" PRIX32
"",
164 DesiredAccess, SharedAccess, CreateDisposition);
166 DesiredAccess = GENERIC_READ | GENERIC_WRITE;
168 CreateDisposition = OPEN_EXISTING;
172 WLog_Print(serial->log, WLOG_ERROR,
"Device %s already open, cancel request",
173 serial->device.name);
174 return ERROR_INVALID_DATA;
177 serial->hComm = winpr_CreateFile(serial->device.name, DesiredAccess, SharedAccess,
179 CreateDisposition, 0,
182 if (!serial->hComm || (serial->hComm == INVALID_HANDLE_VALUE))
184 WLog_Print(serial->log, WLOG_WARN,
"CreateFile failure: %s last-error: 0x%08" PRIX32
"",
185 serial->device.name, GetLastError());
186 serial->hComm =
nullptr;
187 irp->IoStatus = STATUS_UNSUCCESSFUL;
191 _comm_setServerSerialDriver(serial->hComm, serial->ServerSerialDriverId);
192 _comm_set_permissive(serial->hComm, serial->permissive);
201 WINPR_ASSERT(irp->FileId == 0);
202 irp->FileId = irp->devman->id_sequence++;
203 irp->IoStatus = STATUS_SUCCESS;
204 WLog_Print(serial->log, WLOG_DEBUG,
"%s (DeviceId: %" PRIu32
", FileId: %" PRIu32
") created.",
205 serial->device.name, irp->device->id, irp->FileId);
208 DWORD BytesReturned = 0;
209 if (!CommDeviceIoControl(serial->hComm, IOCTL_SERIAL_RESET_DEVICE,
nullptr, 0,
nullptr, 0,
210 &BytesReturned,
nullptr))
215 Stream_Write_UINT32(irp->output, irp->FileId);
216 Stream_Write_UINT8(irp->output, 0);
217 return CHANNEL_RC_OK;
220static UINT serial_process_irp_close(SERIAL_DEVICE* serial, IRP* irp)
222 WINPR_ASSERT(serial);
225 if (!Stream_CheckAndLogRequiredLengthWLog(serial->log, irp->input, 32))
226 return ERROR_INVALID_DATA;
228 Stream_Seek(irp->input, 32);
232 WLog_Print(serial->log, WLOG_ERROR,
"serial device %s is not open, aborting close",
233 serial->device.name);
234 return ERROR_INVALID_DATA;
237 close_terminated_irp_thread_handles(serial, TRUE);
239 if (!CloseHandle(serial->hComm))
241 WLog_Print(serial->log, WLOG_WARN,
"CloseHandle failure: %s (%" PRIu32
") closed.",
242 serial->device.name, irp->device->id);
243 irp->IoStatus = STATUS_UNSUCCESSFUL;
247 WLog_Print(serial->log, WLOG_DEBUG,
"%s (DeviceId: %" PRIu32
", FileId: %" PRIu32
") closed.",
248 serial->device.name, irp->device->id, irp->FileId);
249 irp->IoStatus = STATUS_SUCCESS;
251 serial->hComm =
nullptr;
252 Stream_Zero(irp->output, 5);
253 return CHANNEL_RC_OK;
262static UINT serial_process_irp_read(SERIAL_DEVICE* serial, IRP* irp)
268 WINPR_ASSERT(serial);
271 if (!Stream_CheckAndLogRequiredLengthWLog(serial->log, irp->input, 32))
272 return ERROR_INVALID_DATA;
274 Stream_Read_UINT32(irp->input, Length);
275 Stream_Read_UINT64(irp->input, Offset);
278 Stream_Seek(irp->input, 20);
282 WLog_Print(serial->log, WLOG_ERROR,
"serial device %s is not open, aborting read",
283 serial->device.name);
284 return ERROR_INVALID_DATA;
287 BYTE* buffer = (BYTE*)calloc(Length,
sizeof(BYTE));
289 if (buffer ==
nullptr)
291 irp->IoStatus = STATUS_NO_MEMORY;
298 WLog_Print(serial->log, WLOG_DEBUG,
"reading %" PRIu32
" bytes from %s", Length,
299 serial->device.name);
302 if (CommReadFile(serial->hComm, buffer, Length, &nbRead,
nullptr))
304 irp->IoStatus = STATUS_SUCCESS;
308 WLog_Print(serial->log, WLOG_DEBUG,
309 "read failure to %s, nbRead=%" PRIu32
", last-error: 0x%08" PRIX32
"",
310 serial->device.name, nbRead, GetLastError());
311 irp->IoStatus = GetLastErrorToIoStatus(serial);
314 WLog_Print(serial->log, WLOG_DEBUG,
"%" PRIu32
" bytes read from %s", nbRead,
315 serial->device.name);
317 Stream_Write_UINT32(irp->output, nbRead);
321 if (!Stream_EnsureRemainingCapacity(irp->output, nbRead))
323 WLog_Print(serial->log, WLOG_ERROR,
"Stream_EnsureRemainingCapacity failed!");
325 return CHANNEL_RC_NO_MEMORY;
328 Stream_Write(irp->output, buffer, nbRead);
332 return CHANNEL_RC_OK;
336static UINT serial_process_irp_write(SERIAL_DEVICE* serial, IRP* irp)
342 WINPR_ASSERT(serial);
345 if (!Stream_CheckAndLogRequiredLengthWLog(serial->log, irp->input, 32))
346 return ERROR_INVALID_DATA;
348 Stream_Read_UINT32(irp->input, Length);
349 Stream_Read_UINT64(irp->input, Offset);
352 if (!Stream_SafeSeek(irp->input, 20))
353 return ERROR_INVALID_DATA;
361 WLog_Print(serial->log, WLOG_DEBUG,
"writing %" PRIu32
" bytes to %s", Length,
362 serial->device.name);
364 const void* ptr = Stream_ConstPointer(irp->input);
365 if (!Stream_SafeSeek(irp->input, Length))
366 return ERROR_INVALID_DATA;
370 WLog_Print(serial->log, WLOG_ERROR,
"serial device %s is not open, aborting write",
371 serial->device.name);
372 return ERROR_INVALID_DATA;
376 if (CommWriteFile(serial->hComm, ptr, Length, &nbWritten,
nullptr))
378 irp->IoStatus = STATUS_SUCCESS;
382 WLog_Print(serial->log, WLOG_DEBUG,
383 "write failure to %s, nbWritten=%" PRIu32
", last-error: 0x%08" PRIX32
"",
384 serial->device.name, nbWritten, GetLastError());
385 irp->IoStatus = GetLastErrorToIoStatus(serial);
388 WLog_Print(serial->log, WLOG_DEBUG,
"%" PRIu32
" bytes written to %s", nbWritten,
389 serial->device.name);
390 Stream_Write_UINT32(irp->output, nbWritten);
391 Stream_Write_UINT8(irp->output, 0);
392 return CHANNEL_RC_OK;
401static UINT serial_process_irp_device_control(SERIAL_DEVICE* serial, IRP* irp)
403 DWORD BytesReturned = 0;
405 WINPR_ASSERT(serial);
408 if (!Stream_CheckAndLogRequiredLengthWLog(serial->log, irp->input, 32))
409 return ERROR_INVALID_DATA;
411 const UINT32 OutputBufferLength =
412 Stream_Get_UINT32(irp->input);
413 const UINT32 InputBufferLength =
414 Stream_Get_UINT32(irp->input);
415 const UINT32 IoControlCode = Stream_Get_UINT32(irp->input);
416 Stream_Seek(irp->input, 20);
418 if (!Stream_CheckAndLogRequiredLengthWLog(serial->log, irp->input, InputBufferLength))
419 return ERROR_INVALID_DATA;
423 WLog_Print(serial->log, WLOG_ERROR,
424 "serial device %s is not open, aborting device IO control", serial->device.name);
425 return ERROR_INVALID_DATA;
428 const BYTE* InputBuffer = Stream_PointerAs(irp->input, BYTE);
429 if (!Stream_SafeSeek(irp->input, InputBufferLength))
430 return ERROR_INVALID_DATA;
432 WLog_Print(serial->log, WLOG_DEBUG,
433 "CommDeviceIoControl: CompletionId=%" PRIu32
", IoControlCode=[0x%" PRIX32
"] %s",
434 irp->CompletionId, IoControlCode, _comm_serial_ioctl_name(IoControlCode));
436 BYTE* OutputBuffer =
nullptr;
437 if (OutputBufferLength > 0)
439 OutputBuffer = (BYTE*)calloc(OutputBufferLength,
sizeof(BYTE));
442 irp->IoStatus = STATUS_NO_MEMORY;
448 if (CommDeviceIoControl(serial->hComm, IoControlCode, InputBuffer, InputBufferLength,
449 OutputBuffer, OutputBufferLength, &BytesReturned,
nullptr))
454 irp->IoStatus = STATUS_SUCCESS;
458 WLog_Print(serial->log, WLOG_DEBUG,
459 "CommDeviceIoControl failure: IoControlCode=[0x%" PRIX32
460 "] %s, last-error: 0x%08" PRIX32
"",
461 IoControlCode, _comm_serial_ioctl_name(IoControlCode), GetLastError());
462 irp->IoStatus = GetLastErrorToIoStatus(serial);
467 Stream_Write_UINT32(irp->output, BytesReturned);
469 if (BytesReturned > 0)
471 if (!Stream_EnsureRemainingCapacity(irp->output, BytesReturned))
473 WLog_Print(serial->log, WLOG_ERROR,
"Stream_EnsureRemainingCapacity failed!");
475 return CHANNEL_RC_NO_MEMORY;
478 Stream_Write(irp->output, OutputBuffer, BytesReturned);
490 return CHANNEL_RC_OK;
498static UINT serial_process_irp(SERIAL_DEVICE* serial, IRP* irp)
500 UINT error = CHANNEL_RC_OK;
502 WINPR_ASSERT(serial);
505 WLog_Print(serial->log, WLOG_DEBUG,
"IRP MajorFunction: %s, MinorFunction: 0x%08" PRIX32
"\n",
506 rdpdr_irp_string(irp->MajorFunction), irp->MinorFunction);
508 switch (irp->MajorFunction)
511 error = serial_process_irp_create(serial, irp);
515 error = serial_process_irp_close(serial, irp);
519 error = serial_process_irp_read(serial, irp);
523 error = serial_process_irp_write(serial, irp);
526 case IRP_MJ_DEVICE_CONTROL:
527 error = serial_process_irp_device_control(serial, irp);
531 irp->IoStatus = STATUS_NOT_SUPPORTED;
535 DWORD level = WLOG_TRACE;
539 WLog_Print(serial->log, level,
540 "[%s|0x%08" PRIx32
"] completed with %s [0x%08" PRIx32
"] (IoStatus %s [0x%08" PRIx32
542 rdpdr_irp_string(irp->MajorFunction), irp->MajorFunction, WTSErrorToString(error),
543 error, NtStatus2Tag(irp->IoStatus), WINPR_CXX_COMPAT_CAST(UINT32, irp->IoStatus));
548static DWORD WINAPI irp_thread_func(LPVOID arg)
550 IRP_THREAD_DATA* data = (IRP_THREAD_DATA*)arg;
553 WINPR_ASSERT(data->serial);
554 WINPR_ASSERT(data->irp);
557 UINT error = serial_process_irp(data->serial, data->irp);
560 WLog_Print(data->serial->log, WLOG_ERROR,
561 "serial_process_irp failed with error %" PRIu32
"", error);
562 data->irp->Discard(data->irp);
566 EnterCriticalSection(&data->serial->TerminatingIrpThreadsLock);
567 WINPR_ASSERT(data->irp->Complete);
568 error = data->irp->Complete(data->irp);
569 LeaveCriticalSection(&data->serial->TerminatingIrpThreadsLock);
572 if (error && data->serial->rdpcontext)
573 setChannelError(data->serial->rdpcontext, error,
"irp_thread_func reported an error");
583static void close_unterminated_irp_thread(wListDictionary* list, wLog* log, ULONG_PTR
id)
586 HANDLE self = _GetCurrentThread();
587 HANDLE cirpThread = ListDictionary_GetItemValue(list, (
void*)
id);
588 if (self == cirpThread)
589 WLog_Print(log, WLOG_DEBUG,
"Skipping termination of own IRP thread");
591 ListDictionary_Remove(list, (
void*)
id);
594static void close_terminated_irp_thread(wListDictionary* list, wLog* log, ULONG_PTR
id)
598 HANDLE cirpThread = ListDictionary_GetItemValue(list, (
void*)
id);
601 const DWORD waitResult = WaitForSingleObject(cirpThread, 0);
603 if (waitResult == WAIT_OBJECT_0)
604 ListDictionary_Remove(list, (
void*)
id);
605 else if (waitResult != WAIT_TIMEOUT)
608 WLog_Print(log, WLOG_WARN,
"WaitForSingleObject, got an unexpected result=0x%" PRIX32
"\n",
613void close_terminated_irp_thread_handles(SERIAL_DEVICE* serial, BOOL forceClose)
615 WINPR_ASSERT(serial);
617 EnterCriticalSection(&serial->TerminatingIrpThreadsLock);
619 ListDictionary_Lock(serial->IrpThreads);
620 ULONG_PTR* ids =
nullptr;
621 const size_t nbIds = ListDictionary_GetKeys(serial->IrpThreads, &ids);
623 for (
size_t i = 0; i < nbIds; i++)
625 ULONG_PTR
id = ids[i];
627 close_unterminated_irp_thread(serial->IrpThreads, serial->log,
id);
629 close_terminated_irp_thread(serial->IrpThreads, serial->log,
id);
633 ListDictionary_Unlock(serial->IrpThreads);
635 LeaveCriticalSection(&serial->TerminatingIrpThreadsLock);
638static void create_irp_thread(SERIAL_DEVICE* serial, IRP* irp)
640 IRP_THREAD_DATA* data =
nullptr;
641 HANDLE irpThread =
nullptr;
642 HANDLE previousIrpThread =
nullptr;
645 WINPR_ASSERT(serial);
648 close_terminated_irp_thread_handles(serial, FALSE);
660 key = irp->CompletionId + 1ull;
662 ListDictionary_Lock(serial->IrpThreads);
663 previousIrpThread = ListDictionary_GetItemValue(serial->IrpThreads, (
void*)key);
664 ListDictionary_Unlock(serial->IrpThreads);
666 if (previousIrpThread)
669 WLog_Print(serial->log, WLOG_DEBUG,
670 "IRP recall: IRP with the CompletionId=%" PRIu32
" not yet completed!",
691 data = (IRP_THREAD_DATA*)calloc(1,
sizeof(IRP_THREAD_DATA));
695 WLog_Print(serial->log, WLOG_WARN,
"Could not allocate a new IRP_THREAD_DATA.");
699 data->serial = serial;
702 irpThread = CreateThread(
nullptr, 0, irp_thread_func, (
void*)data, CREATE_SUSPENDED,
nullptr);
704 if (irpThread == INVALID_HANDLE_VALUE)
706 WLog_Print(serial->log, WLOG_WARN,
"Could not allocate a new IRP thread.");
710 key = irp->CompletionId + 1ull;
712 ListDictionary_Lock(serial->IrpThreads);
713 if (ListDictionary_Count(serial->IrpThreads) >= MAX_IRP_THREADS)
715 WLog_Print(serial->log, WLOG_WARN,
716 "Number of IRP threads threshold reached: %" PRIuz
", keep on anyway",
717 ListDictionary_Count(serial->IrpThreads));
727 const BOOL added = ListDictionary_Add(serial->IrpThreads, (
void*)key, irpThread);
732 ResumeThread(irpThread);
733 ListDictionary_Unlock(serial->IrpThreads);
737 WLog_Print(serial->log, WLOG_ERROR,
"ListDictionary_Add failed!");
745 (void)CloseHandle(irpThread);
746 irp->IoStatus = STATUS_NO_MEMORY;
747 WINPR_ASSERT(irp->Complete);
748 const UINT rc = irp->Complete(irp);
749 if (rc != CHANNEL_RC_OK)
750 WLog_Print(serial->log, WLOG_WARN,
"irp->Complete failed with %" PRIu32, rc);
754static DWORD WINAPI serial_thread_func(LPVOID arg)
757 wMessage message = WINPR_C_ARRAY_INIT;
758 SERIAL_DEVICE* serial = (SERIAL_DEVICE*)arg;
759 UINT error = CHANNEL_RC_OK;
761 WINPR_ASSERT(serial);
765 if (!MessageQueue_Wait(serial->MainIrpQueue))
767 WLog_Print(serial->log, WLOG_ERROR,
"MessageQueue_Wait failed!");
768 error = ERROR_INTERNAL_ERROR;
772 if (!MessageQueue_Peek(serial->MainIrpQueue, &message, TRUE))
774 WLog_Print(serial->log, WLOG_ERROR,
"MessageQueue_Peek failed!");
775 error = ERROR_INTERNAL_ERROR;
779 if (message.id == WMQ_QUIT)
782 irp = (IRP*)message.wParam;
785 create_irp_thread(serial, irp);
788 ListDictionary_Lock(serial->IrpThreads);
789 ListDictionary_Clear(serial->IrpThreads);
790 ListDictionary_Unlock(serial->IrpThreads);
792 if (error && serial->rdpcontext)
793 setChannelError(serial->rdpcontext, error,
"serial_thread_func reported an error");
804static UINT serial_irp_request(DEVICE* device, IRP* irp)
806 SERIAL_DEVICE* serial = (SERIAL_DEVICE*)device;
807 WINPR_ASSERT(irp !=
nullptr);
808 WINPR_ASSERT(serial);
815 if (!MessageQueue_Post(serial->MainIrpQueue,
nullptr, 0, (
void*)irp,
nullptr))
817 WLog_Print(serial->log, WLOG_ERROR,
"MessageQueue_Post failed!");
819 return ERROR_INTERNAL_ERROR;
822 return CHANNEL_RC_OK;
830static UINT serial_free(DEVICE* device)
833 SERIAL_DEVICE* serial = (SERIAL_DEVICE*)device;
835 return CHANNEL_RC_OK;
837 WLog_Print(serial->log, WLOG_DEBUG,
"freeing");
838 if (serial->MainIrpQueue)
839 MessageQueue_PostQuit(serial->MainIrpQueue, 0);
841 if (serial->MainThread)
843 if (WaitForSingleObject(serial->MainThread, INFINITE) == WAIT_FAILED)
845 error = GetLastError();
846 WLog_Print(serial->log, WLOG_ERROR,
847 "WaitForSingleObject failed with error %" PRIu32
"!", error);
849 (void)CloseHandle(serial->MainThread);
853 (void)CloseHandle(serial->hComm);
856 Stream_Free(serial->device.data, TRUE);
857 MessageQueue_Free(serial->MainIrpQueue);
858 ListDictionary_Free(serial->IrpThreads);
859 DeleteCriticalSection(&serial->TerminatingIrpThreadsLock);
861 return CHANNEL_RC_OK;
864static void serial_message_free(
void* obj)
872 IRP* irp = (IRP*)msg->wParam;
875 WINPR_ASSERT(irp->Discard);
879static void irp_thread_close(
void* arg)
884 HANDLE thz = _GetCurrentThread();
886 WLog_WARN(TAG,
"closing self, ignoring...");
889 (void)TerminateThread(hdl, 0);
890 (void)WaitForSingleObject(hdl, INFINITE);
891 (void)CloseHandle(hdl);
902 UINT VCAPITYPE serial_DeviceServiceEntry(PDEVICE_SERVICE_ENTRY_POINTS pEntryPoints))
905 SERIAL_DEVICE* serial =
nullptr;
906 UINT error = CHANNEL_RC_OK;
908 WINPR_ASSERT(pEntryPoints);
911 WINPR_ASSERT(device);
913 wLog* log = WLog_Get(TAG);
914 const char* name = device->device.Name;
915 const char* path = device->Path;
916 const char* driver = device->Driver;
918 if (!name || (name[0] ==
'*'))
921 WLog_Print(log, WLOG_WARN,
922 "Serial port autodetection not implemented, nothing will be redirected!");
923 return CHANNEL_RC_OK;
926 if ((name && name[0]) && (path && path[0]))
928 WLog_Print(log, WLOG_DEBUG,
"Defining %s as %s", name, path);
930 if (!DefineCommDevice(name , path ))
932 DWORD status = GetLastError();
933 WLog_Print(log, WLOG_ERROR,
"DefineCommDevice failed with %08" PRIx32, status);
934 return ERROR_INTERNAL_ERROR;
937 serial = (SERIAL_DEVICE*)calloc(1,
sizeof(SERIAL_DEVICE));
941 WLog_Print(log, WLOG_ERROR,
"calloc failed!");
942 return CHANNEL_RC_NO_MEMORY;
946 serial->device.type = RDPDR_DTYP_SERIAL;
947 serial->device.name = name;
948 serial->device.IRPRequest = serial_irp_request;
949 serial->device.Free = serial_free;
950 serial->rdpcontext = pEntryPoints->rdpcontext;
952 serial->device.data = Stream_New(
nullptr, len + 1);
954 if (!serial->device.data)
956 WLog_Print(serial->log, WLOG_ERROR,
"calloc failed!");
957 error = CHANNEL_RC_NO_MEMORY;
961 for (
size_t i = 0; i <= len; i++)
962 Stream_Write_INT8(serial->device.data, name[i] < 0 ?
'_' : name[i]);
964 if (driver !=
nullptr)
966 if (_stricmp(driver,
"Serial") == 0)
967 serial->ServerSerialDriverId = SerialDriverSerialSys;
968 else if (_stricmp(driver,
"SerCx") == 0)
969 serial->ServerSerialDriverId = SerialDriverSerCxSys;
970 else if (_stricmp(driver,
"SerCx2") == 0)
971 serial->ServerSerialDriverId = SerialDriverSerCx2Sys;
974 WLog_Print(serial->log, WLOG_WARN,
"Unknown server's serial driver: %s.", driver);
975 WLog_Print(serial->log, WLOG_WARN,
976 "Valid options are: 'Serial' (default), 'SerCx' and 'SerCx2'");
983 serial->ServerSerialDriverId = SerialDriverSerialSys;
986 if (device->Permissive !=
nullptr)
988 if (_stricmp(device->Permissive,
"permissive") == 0)
990 serial->permissive = TRUE;
994 WLog_Print(serial->log, WLOG_WARN,
"Unknown flag: %s", device->Permissive);
999 WLog_Print(serial->log, WLOG_DEBUG,
"Server's serial driver: %s (id: %u)", driver,
1000 serial->ServerSerialDriverId);
1002 serial->MainIrpQueue = MessageQueue_New(
nullptr);
1004 if (!serial->MainIrpQueue)
1006 WLog_Print(serial->log, WLOG_ERROR,
"MessageQueue_New failed!");
1007 error = CHANNEL_RC_NO_MEMORY;
1012 wObject* obj = MessageQueue_Object(serial->MainIrpQueue);
1014 obj->fnObjectFree = serial_message_free;
1018 serial->IrpThreads = ListDictionary_New(FALSE);
1020 if (!serial->IrpThreads)
1022 WLog_Print(serial->log, WLOG_ERROR,
"ListDictionary_New failed!");
1023 error = CHANNEL_RC_NO_MEMORY;
1028 wObject* obj = ListDictionary_ValueObject(serial->IrpThreads);
1030 obj->fnObjectFree = irp_thread_close;
1033 InitializeCriticalSection(&serial->TerminatingIrpThreadsLock);
1035 error = pEntryPoints->RegisterDevice(pEntryPoints->devman, &serial->device);
1036 if (error != CHANNEL_RC_OK)
1038 WLog_Print(serial->log, WLOG_ERROR,
1039 "EntryPoints->RegisterDevice failed with error %" PRIu32
"!", error);
1043 serial->MainThread = CreateThread(
nullptr, 0, serial_thread_func, serial, 0,
nullptr);
1044 if (!serial->MainThread)
1046 WLog_Print(serial->log, WLOG_ERROR,
"CreateThread failed!");
1047 error = ERROR_INTERNAL_ERROR;
1055 serial_free(&serial->device);
This struct contains function pointer to initialize/free objects.