Win32SerialOverlappedIO.h

Enable keyboard shortcuts

/* This Source Code Form is subject to the terms of the Mozilla Public

 * License, v. 2.0. If a copy of the MPL was not distributed with this

 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#ifndef mozilla_dom_Win32SerialOverlappedIO_h

#define mozilla_dom_Win32SerialOverlappedIO_h

#include <windows.h>

#include "mozilla/UniquePtrExtensions.h"

namespace mozilla::dom {

// Serial ports are opened with FILE_FLAG_OVERLAPPED, and the same kernel file

// object is shared via DuplicateHandle with a PlatformPipeReader that keeps

// an eventless overlapped ReadFile pending on an IOCP. Issuing synchronous

// (NULL lpOverlapped) calls on such a handle is unsafe: the Win32 wrapper waits

// on the file object's event, which the reader's completion also signals, so

// the wrapper can return while its IRP is still pending. Every operation on the

// port should therefore go through this class, which supplies a private event

// so the wait is only satisfied by our own completion.

class Win32SerialOverlappedIO final {

 public:

  Win32SerialOverlappedIO() = default;

  Win32SerialOverlappedIO(const Win32SerialOverlappedIO&) = delete;

  Win32SerialOverlappedIO& operator=(const Win32SerialOverlappedIO&) = delete;

  // Creates the event. Returns true on success, and on failure

  // GetLastError() describes the error.

  bool Init();

  // Resets the event so the OVERLAPPED can be reused for another operation.

  void Reset();

  OVERLAPPED* Get() { return &mOverlapped; }

  // Blocks until the operation issued with Get() completes. Returns true on

  // success, and on failure GetLastError() describes the error.

  bool Wait(HANDLE aHandle, DWORD* aBytesTransferred);

  // Checks for parity errors on an overlapped handle and blocks until

  // it completes. Returns true on success and false if there was a parity

  // error.

  static bool SyncCheckParity(HANDLE aHandle);

  // Purges the specified buffers on an overlapped handle and blocks

  // until it completes. Returns true on success. aPurgeFlags can be

  // any combination of SERIAL_PURGE_RXCLEAR and SERIAL_PURGE_TXCLEAR.

  static bool SyncPurge(HANDLE aHandle, ULONG aPurgeFlags);

  // Sets or clears the passed-in signal and blocks until it completes.

  // Returns true on success.

  static bool SyncSetSignal(HANDLE aHandle, DWORD aIoControlCode);

  // Gets the signals into aSignals and blocks until it completes.

  // Returns true on success.

  static bool SyncGetSignals(HANDLE aHandle, ULONG& aSignals);

 private:

  // Issues DeviceIoControl on an overlapped handle and blocks until it

  // completes. Returns true on success, and on failure GetLastError()

  // describes the error.

  static bool SyncDeviceIoControl(HANDLE aHandle, DWORD aIoControlCode,

                                  const void* aInBuffer, DWORD aInBufferSize,

                                  void* aOutBuffer, DWORD aOutBufferSize,

                                  DWORD* aBytesReturned = nullptr);

  UniqueFileHandle mEvent;

  OVERLAPPED mOverlapped = {};

};

}  // namespace mozilla::dom

#endif  // mozilla_dom_Win32SerialOverlappedIO_h