qserialport_win.cpp

qt/qtserialport/src/serialport/qserialport_win.cpp

Enable keyboard shortcuts

Revision control

++ // Copyright (C) 2012 Denis Shienkov <denis.shienkov@gmail.com>

++ // Copyright (C) 2012 Laszlo Papp <lpapp@kde.org>

++ // Copyright (C) 2012 Andre Hartmann <aha_1980@gmx.de>

++ // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only

++ // Qt-Security score:significant reason:default

++

++ #include "qserialport_p.h"

++ #include "qwinoverlappedionotifier_p.h"

++

++ #include <QtCore/qcoreevent.h>

++ #include <QtCore/qelapsedtimer.h>

++ #include <QtCore/qlist.h>

++ #include <QtCore/qmutex.h>

++ #include <QtCore/qtimer.h>

++ #include <algorithm>

++

++ #ifndef CTL_CODE

++ #  define CTL_CODE(DeviceType, Function, Method, Access) ( \

++     ((DeviceType) << 16) | ((Access) << 14) | ((Function) << 2) | (Method) \

++     )

++ #endif

++

++ #ifndef FILE_DEVICE_SERIAL_PORT

++ #  define FILE_DEVICE_SERIAL_PORT  27

++ #endif

++

++ #ifndef METHOD_BUFFERED

++ #  define METHOD_BUFFERED  0

++ #endif

++

++ #ifndef FILE_ANY_ACCESS

++ #  define FILE_ANY_ACCESS  0x00000000

++ #endif

++

++ #ifndef IOCTL_SERIAL_GET_DTRRTS

++ #  define IOCTL_SERIAL_GET_DTRRTS \

++     CTL_CODE(FILE_DEVICE_SERIAL_PORT, 30, METHOD_BUFFERED, FILE_ANY_ACCESS)

++ #endif

++

++ #ifndef SERIAL_DTR_STATE

++ #  define SERIAL_DTR_STATE  0x00000001

++ #endif

++

++ #ifndef SERIAL_RTS_STATE

++ #  define SERIAL_RTS_STATE  0x00000002

++ #endif

++

++ QT_BEGIN_NAMESPACE

++

++ static inline void qt_set_common_props(DCB *dcb)

++ {

++     dcb->fBinary = TRUE;

++     dcb->fAbortOnError = FALSE;

++     dcb->fNull = FALSE;

++     dcb->fErrorChar = FALSE;

++

++     if (dcb->fDtrControl == DTR_CONTROL_HANDSHAKE)

++         dcb->fDtrControl = DTR_CONTROL_DISABLE;

++

++     if (dcb->fRtsControl != RTS_CONTROL_HANDSHAKE)

++         dcb->fRtsControl = RTS_CONTROL_DISABLE;

++ }

++

++ static inline void qt_set_baudrate(DCB *dcb, qint32 baudrate)

++ {

++     dcb->BaudRate = baudrate;

++ }

++

++ static inline void qt_set_databits(DCB *dcb, QSerialPort::DataBits databits)

++ {

++     dcb->ByteSize = databits;

++ }

++

++ static inline void qt_set_parity(DCB *dcb, QSerialPort::Parity parity)

++ {

++     dcb->fParity = TRUE;

++     switch (parity) {

++     case QSerialPort::NoParity:

++         dcb->Parity = NOPARITY;

++         dcb->fParity = FALSE;

++         break;

++     case QSerialPort::OddParity:

++         dcb->Parity = ODDPARITY;

++         break;

++     case QSerialPort::EvenParity:

++         dcb->Parity = EVENPARITY;

++         break;

++     case QSerialPort::MarkParity:

++         dcb->Parity = MARKPARITY;

++         break;

++     case QSerialPort::SpaceParity:

++         dcb->Parity = SPACEPARITY;

++         break;

++     default:

++         dcb->Parity = NOPARITY;

++         dcb->fParity = FALSE;

++         break;

++     }

++ }

++

++ static inline void qt_set_stopbits(DCB *dcb, QSerialPort::StopBits stopbits)

++ {

++     switch (stopbits) {

++     case QSerialPort::OneStop:

++         dcb->StopBits = ONESTOPBIT;

++         break;

++     case QSerialPort::OneAndHalfStop:

++         dcb->StopBits = ONE5STOPBITS;

++         break;

++     case QSerialPort::TwoStop:

++         dcb->StopBits = TWOSTOPBITS;

++         break;

++     default:

++         dcb->StopBits = ONESTOPBIT;

++         break;

++     }

++ }

++

++ static inline void qt_set_flowcontrol(DCB *dcb, QSerialPort::FlowControl flowcontrol)

++ {

++     dcb->fInX = FALSE;

++     dcb->fOutX = FALSE;

++     dcb->fOutxCtsFlow = FALSE;

++     if (dcb->fRtsControl == RTS_CONTROL_HANDSHAKE)

++         dcb->fRtsControl = RTS_CONTROL_DISABLE;

++     switch (flowcontrol) {

++     case QSerialPort::NoFlowControl:

++         break;

++     case QSerialPort::SoftwareControl:

++         dcb->fInX = TRUE;

++         dcb->fOutX = TRUE;

++         break;

++     case QSerialPort::HardwareControl:

++         dcb->fOutxCtsFlow = TRUE;

++         dcb->fRtsControl = RTS_CONTROL_HANDSHAKE;

++         break;

++     default:

++         break;

++     }

++ }

++

++ bool QSerialPortPrivate::open(QIODevice::OpenMode mode)

++ {

++     DWORD desiredAccess = 0;

++

++     if (mode & QIODevice::ReadOnly)

++         desiredAccess |= GENERIC_READ;

++     if (mode & QIODevice::WriteOnly)

++         desiredAccess |= GENERIC_WRITE;

++

++     handle = ::CreateFile(reinterpret_cast<const wchar_t*>(systemLocation.utf16()),

++                               desiredAccess, 0, nullptr, OPEN_EXISTING, FILE_FLAG_OVERLAPPED, nullptr);

++

++     if (handle == INVALID_HANDLE_VALUE) {

++         setError(getSystemError());

++         return false;

++     }

++

++     if (initialize(mode))

++         return true;

++

++     ::CloseHandle(handle);

++     return false;

++ }

++

++ void QSerialPortPrivate::close()

++ {

++     ::CancelIo(handle);

++

++     delete notifier;

++     notifier = nullptr;

++

++     delete startAsyncWriteTimer;

++     startAsyncWriteTimer = nullptr;

++

++     communicationStarted = false;

++     readStarted = false;

++     writeStarted = false;

++     writeBuffer.clear();

++

++     if (settingsRestoredOnClose) {

++         ::SetCommState(handle, &restoredDcb);

++         ::SetCommTimeouts(handle, &restoredCommTimeouts);

++     }

++

++     ::CloseHandle(handle);

++     handle = INVALID_HANDLE_VALUE;

++ }

++

++ QSerialPort::PinoutSignals QSerialPortPrivate::pinoutSignals()

++ {

++     DWORD modemStat = 0;

++

++     if (!::GetCommModemStatus(handle, &modemStat)) {

++         setError(getSystemError());

++         return QSerialPort::NoSignal;

++     }

++

++     QSerialPort::PinoutSignals ret = QSerialPort::NoSignal;

++

++     if (modemStat & MS_CTS_ON)

++         ret |= QSerialPort::ClearToSendSignal;

++     if (modemStat & MS_DSR_ON)

++         ret |= QSerialPort::DataSetReadySignal;

++     if (modemStat & MS_RING_ON)

++         ret |= QSerialPort::RingIndicatorSignal;

++     if (modemStat & MS_RLSD_ON)

++         ret |= QSerialPort::DataCarrierDetectSignal;

++

++     DWORD bytesReturned = 0;

++     if (!::DeviceIoControl(handle, IOCTL_SERIAL_GET_DTRRTS, nullptr, 0,

++                           &modemStat, sizeof(modemStat),

++                           &bytesReturned, nullptr)) {

++         setError(getSystemError());

++         return ret;

++     }

++

++     if (modemStat & SERIAL_DTR_STATE)

++         ret |= QSerialPort::DataTerminalReadySignal;

++     if (modemStat & SERIAL_RTS_STATE)

++         ret |= QSerialPort::RequestToSendSignal;

++

++     return ret;

++ }

++

++ bool QSerialPortPrivate::setDataTerminalReady(bool set)

++ {

++     if (!::EscapeCommFunction(handle, set ? SETDTR : CLRDTR)) {

++         setError(getSystemError());

++         return false;

++     }

++

++     DCB dcb;

++     if (!getDcb(&dcb))

++         return false;

++

++     dcb.fDtrControl = set ? DTR_CONTROL_ENABLE : DTR_CONTROL_DISABLE;

++     return setDcb(&dcb);

++ }

++

++ bool QSerialPortPrivate::setRequestToSend(bool set)

++ {

++     if (!::EscapeCommFunction(handle, set ? SETRTS : CLRRTS)) {

++         setError(getSystemError());

++         return false;

++     }

++

++     DCB dcb;

++     if (!getDcb(&dcb))

++         return false;

++

++     dcb.fRtsControl = set ? RTS_CONTROL_ENABLE : RTS_CONTROL_DISABLE;

++     return setDcb(&dcb);

++ }

++

++ bool QSerialPortPrivate::flush()

++ {

++     return _q_startAsyncWrite();

++ }

++

++ bool QSerialPortPrivate::clear(QSerialPort::Directions directions)

++ {

++     DWORD flags = 0;

++     if (directions & QSerialPort::Input)

++         flags |= PURGE_RXABORT | PURGE_RXCLEAR;

++     if (directions & QSerialPort::Output)

++         flags |= PURGE_TXABORT | PURGE_TXCLEAR;

++     if (!::PurgeComm(handle, flags)) {

++         setError(getSystemError());

++         return false;

++     }

++

++     // We need start async read because a reading can be stalled. Since the

++     // PurgeComm can abort of current reading sequence, or a port is in hardware

++     // flow control mode, or a port has a limited read buffer size.

++     if (directions & QSerialPort::Input)

++         startAsyncCommunication();

++

++     return true;

++ }

++

++ bool QSerialPortPrivate::sendBreak(int duration)

++ {

++     if (!setBreakEnabled(true))

++         return false;

++

++     ::Sleep(duration);

++

++     if (!setBreakEnabled(false))

++         return false;

++

++     return true;

++ }

++

++ bool QSerialPortPrivate::setBreakEnabled(bool set)

++ {

++     if (set ? !::SetCommBreak(handle) : !::ClearCommBreak(handle)) {

++         setError(getSystemError());

++         return false;

++     }

++

++     return true;

++ }

++

++ bool QSerialPortPrivate::waitForReadyRead(int msecs)

++ {

++     if (!writeStarted && !_q_startAsyncWrite())

++         return false;

++

++     const qint64 initialReadBufferSize = buffer.size();

++     qint64 currentReadBufferSize = initialReadBufferSize;

++

++     QDeadlineTimer deadline(msecs);

++

++     do {

++         const OVERLAPPED *overlapped = waitForNotified(deadline);

++         if (!overlapped)

++             return false;

++

++         if (overlapped == &readCompletionOverlapped) {

++             const qint64 readBytesForOneReadOperation = qint64(buffer.size()) - currentReadBufferSize;

++             if (readBytesForOneReadOperation == QSERIALPORT_BUFFERSIZE) {

++                 currentReadBufferSize = buffer.size();

++             } else if (readBytesForOneReadOperation == 0) {

++                 if (initialReadBufferSize != currentReadBufferSize)

++                     return true;

++             } else {

++                 return true;

++             }

++         }

++

++     } while (!deadline.hasExpired());

++

++     return false;

++ }

++

++ bool QSerialPortPrivate::waitForBytesWritten(int msecs)

++ {

++     if (writeBuffer.isEmpty() && writeChunkBuffer.isEmpty())

++         return false;

++

++     if (!writeStarted && !_q_startAsyncWrite())

++         return false;

++

++     QDeadlineTimer deadline(msecs);

++

++     for (;;) {

++         const OVERLAPPED *overlapped = waitForNotified(deadline);

++         if (!overlapped)

++             return false;

++

++          if (overlapped == &writeCompletionOverlapped)

++             return true;

++     }

++

++     return false;

++ }

++

++ bool QSerialPortPrivate::setBaudRate()

++ {

++     return setBaudRate(inputBaudRate, QSerialPort::AllDirections);

++ }

++

++ bool QSerialPortPrivate::setBaudRate(qint32 baudRate, QSerialPort::Directions directions)

++ {

++     if (directions != QSerialPort::AllDirections) {

++         setError(QSerialPortErrorInfo(QSerialPort::UnsupportedOperationError, QSerialPort::tr("Custom baud rate direction is unsupported")));

++         return false;

++     }

++

++     DCB dcb;

++     if (!getDcb(&dcb))

++         return false;

++

++     qt_set_baudrate(&dcb, baudRate);

++

++     return setDcb(&dcb);

++ }

++

++ bool QSerialPortPrivate::setDataBits(QSerialPort::DataBits dataBits)

++ {

++     DCB dcb;

++     if (!getDcb(&dcb))

++         return false;

++

++     qt_set_databits(&dcb, dataBits);

++

++     return setDcb(&dcb);

++ }

++

++ bool QSerialPortPrivate::setParity(QSerialPort::Parity parity)

++ {

++     DCB dcb;

++     if (!getDcb(&dcb))

++         return false;

++

++     qt_set_parity(&dcb, parity);

++

++     return setDcb(&dcb);

++ }

++

++ bool QSerialPortPrivate::setStopBits(QSerialPort::StopBits stopBits)

++ {

++     DCB dcb;

++     if (!getDcb(&dcb))

++         return false;

++

++     qt_set_stopbits(&dcb, stopBits);

++

++     return setDcb(&dcb);

++ }

++

++ bool QSerialPortPrivate::setFlowControl(QSerialPort::FlowControl flowControl)

++ {

++     DCB dcb;

++     if (!getDcb(&dcb))

++         return false;

++

++     qt_set_flowcontrol(&dcb, flowControl);

++

++     return setDcb(&dcb);

++ }

++

++ bool QSerialPortPrivate::completeAsyncCommunication(qint64 bytesTransferred)

++ {

++     communicationStarted = false;

++

++     if (bytesTransferred == qint64(-1))

++         return false;

++

++     return startAsyncRead();

++ }

++

++ bool QSerialPortPrivate::completeAsyncRead(qint64 bytesTransferred)

++ {

++     if (bytesTransferred == qint64(-1)) {

++         readStarted = false;

++         return false;

++     }

++     if (bytesTransferred > 0)

++         buffer.append(readChunkBuffer.constData(), bytesTransferred);

++

++     readStarted = false;

++

++     bool result = true;

++     if (bytesTransferred == QSERIALPORT_BUFFERSIZE

++             || queuedBytesCount(QSerialPort::Input) > 0) {

++         result = startAsyncRead();

++     } else {

++         result = startAsyncCommunication();

++     }

++

++     if (bytesTransferred > 0)

++         emitReadyRead();

++

++     return result;

++ }

++

++ bool QSerialPortPrivate::completeAsyncWrite(qint64 bytesTransferred)

++ {

++     Q_Q(QSerialPort);

++

++     if (writeStarted) {

++         if (bytesTransferred == qint64(-1)) {

++             writeChunkBuffer.clear();

++             writeStarted = false;

++             return false;

++         }

++         Q_ASSERT(bytesTransferred == writeChunkBuffer.size());

++         writeChunkBuffer.clear();

++         emit q->bytesWritten(bytesTransferred);

++         writeStarted = false;

++     }

++

++     return _q_startAsyncWrite();

++ }

++

++ bool QSerialPortPrivate::startAsyncCommunication()

++ {

++     if (communicationStarted)

++         return true;

++

++     ::ZeroMemory(&communicationOverlapped, sizeof(communicationOverlapped));

++     if (!::WaitCommEvent(handle, &triggeredEventMask, &communicationOverlapped)) {

++         QSerialPortErrorInfo error = getSystemError();

++         if (error.errorCode != QSerialPort::NoError) {

++             if (error.errorCode == QSerialPort::PermissionError)

++                 error.errorCode = QSerialPort::ResourceError;

++             setError(error);

++             return false;

++         }

++     }

++     communicationStarted = true;

++     return true;

++ }

++

++ bool QSerialPortPrivate::startAsyncRead()

++ {

++     if (readStarted)

++         return true;

++

++     qint64 bytesToRead = QSERIALPORT_BUFFERSIZE;

++

++     if (readBufferMaxSize && bytesToRead > (readBufferMaxSize - buffer.size())) {

++         bytesToRead = readBufferMaxSize - buffer.size();

++         if (bytesToRead <= 0) {

++             // Buffer is full. User must read data from the buffer

++             // before we can read more from the port.

++             return false;

++         }

++     }

++

++     Q_ASSERT(int(bytesToRead) <= readChunkBuffer.size());

++

++     ::ZeroMemory(&readCompletionOverlapped, sizeof(readCompletionOverlapped));

++     if (::ReadFile(handle, readChunkBuffer.data(), bytesToRead, nullptr, &readCompletionOverlapped)) {

++         readStarted = true;

++         return true;

++     }

++

++     QSerialPortErrorInfo error = getSystemError();

++     if (error.errorCode != QSerialPort::NoError) {

++         if (error.errorCode == QSerialPort::PermissionError)

++             error.errorCode = QSerialPort::ResourceError;

++         if (error.errorCode != QSerialPort::ResourceError)

++             error.errorCode = QSerialPort::ReadError;

++         setError(error);

++         return false;

++     }

++

++     readStarted = true;

++     return true;

++ }

++

++ bool QSerialPortPrivate::_q_startAsyncWrite()

++ {

++     if (handle == INVALID_HANDLE_VALUE) {

++         // Prevent a crash if the application incorrectly has not called open() before

++         // calling this (QTBUG-120412)

++         return false;

++     }

++

++     if (writeBuffer.isEmpty() || writeStarted)

++         return true;

++

++     writeChunkBuffer = writeBuffer.read();

++     ::ZeroMemory(&writeCompletionOverlapped, sizeof(writeCompletionOverlapped));

++     if (!::WriteFile(handle, writeChunkBuffer.constData(),

++                      writeChunkBuffer.size(), nullptr, &writeCompletionOverlapped)) {

++

++         QSerialPortErrorInfo error = getSystemError();

++         if (error.errorCode != QSerialPort::NoError) {

++             if (error.errorCode != QSerialPort::ResourceError)

++                 error.errorCode = QSerialPort::WriteError;

++             setError(error);

++             return false;

++         }

++     }

++

++     writeStarted = true;

++     return true;

++ }

++

++ void QSerialPortPrivate::_q_notified(DWORD numberOfBytes, DWORD errorCode, OVERLAPPED *overlapped)

++ {

++     const QSerialPortErrorInfo error = getSystemError(errorCode);

++     if (error.errorCode != QSerialPort::NoError) {

++         setError(error);

++         return;

++     }

++

++     if (overlapped == &communicationOverlapped)

++         completeAsyncCommunication(numberOfBytes);

++     else if (overlapped == &readCompletionOverlapped)

++         completeAsyncRead(numberOfBytes);

++     else if (overlapped == &writeCompletionOverlapped)

++         completeAsyncWrite(numberOfBytes);

++     else

++         Q_ASSERT(!"Unknown OVERLAPPED activated");

++ }

++

++ void QSerialPortPrivate::emitReadyRead()

++ {

++     Q_Q(QSerialPort);

++

++     if (!emittedReadyRead) {

++         emittedReadyRead = true;

++         emit q->readyRead();

++         emittedReadyRead = false;

++     }

++ }

++

++ qint64 QSerialPortPrivate::writeData(const char *data, qint64 maxSize)

++ {

++     Q_Q(QSerialPort);

++

++     qint64 toAppend = maxSize;

++

++     if (writeBufferMaxSize && (writeBuffer.size() + toAppend > writeBufferMaxSize))

++         toAppend = writeBufferMaxSize - writeBuffer.size();

++

++     writeBuffer.append(data, toAppend);

++

++     if (!writeBuffer.isEmpty() && !writeStarted) {

++         if (!startAsyncWriteTimer) {

++             startAsyncWriteTimer = new QTimer(q);

++             QObjectPrivate::connect(startAsyncWriteTimer, &QTimer::timeout, this, &QSerialPortPrivate::_q_startAsyncWrite);

++             startAsyncWriteTimer->setSingleShot(true);

++         }

++         if (!startAsyncWriteTimer->isActive())

++             startAsyncWriteTimer->start();

++     }

++     return toAppend;

++ }

++

++ OVERLAPPED *QSerialPortPrivate::waitForNotified(QDeadlineTimer deadline)

++ {

++     OVERLAPPED *overlapped = notifier->waitForAnyNotified(deadline);

++     if (!overlapped) {

++         setError(getSystemError(WAIT_TIMEOUT));

++         return nullptr;

++     }

++     return overlapped;

++ }

++

++ qint64 QSerialPortPrivate::queuedBytesCount(QSerialPort::Direction direction) const

++ {

++     COMSTAT comstat;

++     if (::ClearCommError(handle, nullptr, &comstat) == 0)

++         return -1;

++     return (direction == QSerialPort::Input)

++             ? comstat.cbInQue

++             : ((direction == QSerialPort::Output) ? comstat.cbOutQue : -1);

++ }

++

++ inline bool QSerialPortPrivate::initialize(QIODevice::OpenMode mode)

++ {

++     Q_Q(QSerialPort);

++

++     DCB dcb;

++     if (!getDcb(&dcb))

++         return false;

++

++     restoredDcb = dcb;

++

++     if (!::GetCommTimeouts(handle, &restoredCommTimeouts)) {

++         setError(getSystemError());

++         return false;

++     }

++

++     auto restoreParametersOnError = qScopeGuard([this] {

++         if (settingsRestoredOnClose) {

++             ::SetCommState(handle, &restoredDcb);

++             ::SetCommTimeouts(handle, &restoredCommTimeouts);

++         }

++     });

++

++     qt_set_common_props(&dcb);

++     qt_set_baudrate(&dcb, inputBaudRate);

++     qt_set_databits(&dcb, dataBits);

++     qt_set_parity(&dcb, parity);

++     qt_set_stopbits(&dcb, stopBits);

++     qt_set_flowcontrol(&dcb, flowControl);

++

++     if (!setDcb(&dcb))

++         return false;

++

++     ::ZeroMemory(&currentCommTimeouts, sizeof(currentCommTimeouts));

++     currentCommTimeouts.ReadIntervalTimeout = MAXDWORD;

++

++     if (!::SetCommTimeouts(handle, &currentCommTimeouts)) {

++         setError(getSystemError());

++         return false;

++     }

++

++     const DWORD eventMask = (mode & QIODevice::ReadOnly) ? EV_RXCHAR : 0;

++     if (!::SetCommMask(handle, eventMask)) {

++         setError(getSystemError());

++         return false;

++     }

++

++     notifier = new QWinOverlappedIoNotifier(q);

++     QObjectPrivate::connect(notifier, &QWinOverlappedIoNotifier::notified,

++                this, &QSerialPortPrivate::_q_notified);

++     notifier->setHandle(handle);

++     notifier->setEnabled(true);

++

++     if ((eventMask & EV_RXCHAR) && !startAsyncCommunication()) {

++         delete notifier;

++         notifier = nullptr;

++         return false;

++     }

++

++     restoreParametersOnError.dismiss();

++     return true;

++ }

++

++ bool QSerialPortPrivate::setDcb(DCB *dcb)

++ {

++     if (!::SetCommState(handle, dcb)) {

++         setError(getSystemError());

++         return false;

++     }

++     return true;

++ }

++

++ bool QSerialPortPrivate::getDcb(DCB *dcb)

++ {

++     ::ZeroMemory(dcb, sizeof(DCB));

++     dcb->DCBlength = sizeof(DCB);

++

++     if (!::GetCommState(handle, dcb)) {

++         setError(getSystemError());

++         return false;

++     }

++     return true;

++ }

++

++ QSerialPortErrorInfo QSerialPortPrivate::getSystemError(int systemErrorCode) const

++ {

++     if (systemErrorCode == -1)

++         systemErrorCode = ::GetLastError();

++

++     QSerialPortErrorInfo error;

++     error.errorString = qt_error_string(systemErrorCode);

++

++     switch (systemErrorCode) {

++     case ERROR_SUCCESS:

++         error.errorCode = QSerialPort::NoError;

++         break;

++     case ERROR_IO_PENDING:

++         error.errorCode = QSerialPort::NoError;

++         break;

++     case ERROR_MORE_DATA:

++         error.errorCode = QSerialPort::NoError;

++         break;

++     case ERROR_FILE_NOT_FOUND:

++         error.errorCode = QSerialPort::DeviceNotFoundError;

++         break;

++     case ERROR_PATH_NOT_FOUND:

++         error.errorCode = QSerialPort::DeviceNotFoundError;

++         break;

++     case ERROR_INVALID_NAME:

++         error.errorCode = QSerialPort::DeviceNotFoundError;

++         break;

++     case ERROR_ACCESS_DENIED:

++         error.errorCode = QSerialPort::PermissionError;

++         break;

++     case ERROR_INVALID_HANDLE:

++         error.errorCode = QSerialPort::ResourceError;

++         break;

++     case ERROR_INVALID_PARAMETER:

++         error.errorCode = QSerialPort::UnsupportedOperationError;

++         break;

++     case ERROR_BAD_COMMAND:

++         error.errorCode = QSerialPort::ResourceError;

++         break;

++     case ERROR_DEVICE_REMOVED:

++         error.errorCode = QSerialPort::ResourceError;

++         break;

++     case ERROR_OPERATION_ABORTED:

++         error.errorCode = QSerialPort::ResourceError;

++         break;

++     case WAIT_TIMEOUT:

++         error.errorCode = QSerialPort::TimeoutError;

++         break;

++     default:

++         error.errorCode = QSerialPort::UnknownError;

++         break;

++     }

++     return error;

++ }

++

++ // This table contains standard values of baud rates that

++ // are defined in file winbase.h

++ QList<qint32> QSerialPortPrivate::standardBaudRates()

++ {

++     static const QList<qint32> baudRates = {

++         CBR_110,   CBR_300,   CBR_600,    CBR_1200,   CBR_2400,

++         CBR_4800,  CBR_9600,  CBR_14400,  CBR_19200,  CBR_38400,

++         CBR_56000, CBR_57600, CBR_115200, CBR_128000, CBR_256000

++     };

++

++     return baudRates;

++ }

++

++ QSerialPort::Handle QSerialPort::handle() const

++ {

++     Q_D(const QSerialPort);

++     return d->handle;

++ }

++

++ QT_END_NAMESPACE