Make sure HANDLE on Windows has a correct size

Previously, the type of various HANDLEs are native Python integer types.
The ctypes library will treat them as 4-byte integer when used in function
arguments. On 64-bit Windows, HANDLE is 8-byte and usually a small integer.
Depending on whether the extra 4 bytes are zero-ed out or not, things can
happen to work, or break.

This patch adds explicit type casts so ctypes uses 8-byte integers for
HANDLEs on 64-bit Windows.

Thanks to @quark-zju for providing this patch to the 1.0 branch. This patch
contains similar changes for the the 3.0 branch.

Author: jonathanslenders

prompt_toolkit/eventloop/win32.py

@@ -14,11 +14,22 @@
 INFINITE = -1
 
 
-def wait_for_handles(handles: List[int], timeout: int = INFINITE) -> Optional[HANDLE]:
+def wait_for_handles(handles: List[HANDLE], timeout: int = INFINITE) -> Optional[HANDLE]:
     """
     Waits for multiple handles. (Similar to 'select') Returns the handle which is ready.
     Returns `None` on timeout.
     http://msdn.microsoft.com/en-us/library/windows/desktop/ms687025(v=vs.85).aspx
+
+    Note that handles should be a list of `HANDLE` objects, not integers. See
+    this comment in the patch by @quark-zju for the reason why:
+
+        ''' Make sure HANDLE on Windows has a correct size
+
+        Previously, the type of various HANDLEs are native Python integer
+        types. The ctypes library will treat them as 4-byte integer when used
+        in function arguments. On 64-bit Windows, HANDLE is 8-byte and usually
+        a small integer. Depending on whether the extra 4 bytes are zero-ed out
+        or not, things can happen to work, or break. '''
     """
     arrtype = HANDLE * len(handles)
     handle_array = arrtype(*handles)
@@ -30,17 +41,17 @@ def wait_for_handles(handles: List[int], timeout: int = INFINITE) -> Optional[HA
         return None
     else:
         h = handle_array[ret]
-        return h
+        return HANDLE(h)
 
 
 def create_win32_event():
     """
     Creates a Win32 unnamed Event .
     http://msdn.microsoft.com/en-us/library/windows/desktop/ms682396(v=vs.85).aspx
     """
-    return windll.kernel32.CreateEventA(
+    return HANDLE(windll.kernel32.CreateEventA(
         pointer(SECURITY_ATTRIBUTES()),
         BOOL(True),  # Manual reset event.
         BOOL(False),  # Initial state.
         None  # Unnamed event object.
-    )
+    ))

prompt_toolkit/input/win32.py

@@ -5,7 +5,7 @@
 from asyncio import get_event_loop
 from contextlib import contextmanager
 from ctypes import pointer, windll
-from ctypes.wintypes import DWORD
+from ctypes.wintypes import DWORD, HANDLE
 from typing import Callable, ContextManager, Dict, Iterable, Optional
 
 from prompt_toolkit.eventloop import run_in_executor_with_context
@@ -43,7 +43,7 @@ def __init__(self) -> None:
 
     @property
     @abstractmethod
-    def handle(self) -> int:
+    def handle(self) -> HANDLE:
         pass
 
 
@@ -100,7 +100,7 @@ def close(self) -> None:
         self.console_input_reader.close()
 
     @property
-    def handle(self) -> int:
+    def handle(self) -> HANDLE:
         return self.console_input_reader.handle
 
 
@@ -192,12 +192,12 @@ def __init__(self, recognize_paste: bool = True) -> None:
 
         # When stdin is a tty, use that handle, otherwise, create a handle from
         # CONIN$.
-        self.handle: int
+        self.handle: HANDLE
         if sys.stdin.isatty():
-            self.handle = windll.kernel32.GetStdHandle(STD_INPUT_HANDLE)
+            self.handle = HANDLE(windll.kernel32.GetStdHandle(STD_INPUT_HANDLE))
         else:
             self._fdcon = os.open('CONIN$', os.O_RDWR | os.O_BINARY)
-            self.handle = msvcrt.get_osfhandle(self._fdcon)
+            self.handle = HANDLE(msvcrt.get_osfhandle(self._fdcon))
 
     def close(self) -> None:
         " Close fdcon. "
@@ -428,12 +428,12 @@ class _Win32Handles:
     def __init__(self) -> None:
         self._handle_callbacks: Dict[int, Callable[[], None]] = {}
 
-    def add_win32_handle(self, handle: int, callback: Callable[[], None]) -> None:
+    def add_win32_handle(self, handle: HANDLE, callback: Callable[[], None]) -> None:
         """
         Add a Win32 handle to the event loop.
         """
         loop = get_event_loop()
-        self._handle_callbacks[handle] = callback
+        self._handle_callbacks[handle.value] = callback
 
         # Add reader.
         def ready() -> None:
@@ -447,20 +447,20 @@ def ready() -> None:
         # (Use an executor for this, the Windows asyncio event loop doesn't
         # allow us to wait for handles like stdin.)
         def wait() -> None:
-            if self._handle_callbacks.get(handle) != callback:
+            if self._handle_callbacks.get(handle.value) != callback:
                 return
 
             wait_for_handles([handle])
             loop.call_soon_threadsafe(ready)
 
         run_in_executor_with_context(wait, loop=loop)
 
-    def remove_win32_handle(self, handle: int) -> None:
+    def remove_win32_handle(self, handle: HANDLE) -> None:
         """
         Remove a Win32 handle from the event loop.
         """
-        if handle in self._handle_callbacks:
-            del self._handle_callbacks[handle]
+        if handle.value in self._handle_callbacks:
+            del self._handle_callbacks[handle.value]
 
 
 @contextmanager
@@ -475,7 +475,7 @@ def attach_win32_input(input: _Win32InputBase, callback: Callable[[], None]):
     handle = input.handle
 
     # Add reader.
-    previous_callback = win32_handles._handle_callbacks.get(handle)
+    previous_callback = win32_handles._handle_callbacks.get(handle.value)
     win32_handles.add_win32_handle(handle, callback)
 
     try:
@@ -492,7 +492,7 @@ def detach_win32_input(input: _Win32InputBase):
     win32_handles = input.win32_handles
     handle = input.handle
 
-    previous = win32_handles._handle_callbacks.get(handle)
+    previous = win32_handles._handle_callbacks.get(handle.value)
     if previous:
         win32_handles.remove_win32_handle(handle)
 
@@ -514,7 +514,7 @@ class raw_mode:
     `raw_input` method of `.vt100_input`.
     """
     def __init__(self, fileno=None):
-        self.handle = windll.kernel32.GetStdHandle(STD_INPUT_HANDLE)
+        self.handle = HANDLE(windll.kernel32.GetStdHandle(STD_INPUT_HANDLE))
 
     def __enter__(self):
         # Remember original mode.

prompt_toolkit/output/win32.py

@@ -9,7 +9,7 @@
     pointer,
     windll,
 )
-from ctypes.wintypes import DWORD
+from ctypes.wintypes import DWORD, HANDLE
 from typing import Dict, List, TextIO, Tuple
 
 from prompt_toolkit.data_structures import Size
@@ -86,7 +86,7 @@ def __init__(self, stdout: TextIO, use_complete_width: bool = False) -> None:
 
         self._buffer: List[str] = []
         self.stdout = stdout
-        self.hconsole = windll.kernel32.GetStdHandle(STD_OUTPUT_HANDLE)
+        self.hconsole = HANDLE(windll.kernel32.GetStdHandle(STD_OUTPUT_HANDLE))
 
         self._in_alternate_screen = False
         self._hidden = False
@@ -367,8 +367,8 @@ def enter_alternate_screen(self) -> None:
             GENERIC_WRITE = 0x40000000
 
             # Create a new console buffer and activate that one.
-            handle = self._winapi(windll.kernel32.CreateConsoleScreenBuffer, GENERIC_READ|GENERIC_WRITE,
-                                  DWORD(0), None, DWORD(1), None)
+            handle = HANDLE(self._winapi(windll.kernel32.CreateConsoleScreenBuffer, GENERIC_READ|GENERIC_WRITE,
+                                         DWORD(0), None, DWORD(1), None))
 
             self._winapi(windll.kernel32.SetConsoleActiveScreenBuffer, handle)
             self.hconsole = handle
@@ -379,23 +379,23 @@ def quit_alternate_screen(self) -> None:
         Make stdout again the active buffer.
         """
         if self._in_alternate_screen:
-            stdout = self._winapi(windll.kernel32.GetStdHandle, STD_OUTPUT_HANDLE)
+            stdout = HANDLE(self._winapi(windll.kernel32.GetStdHandle, STD_OUTPUT_HANDLE))
             self._winapi(windll.kernel32.SetConsoleActiveScreenBuffer, stdout)
             self._winapi(windll.kernel32.CloseHandle, self.hconsole)
             self.hconsole = stdout
             self._in_alternate_screen = False
 
     def enable_mouse_support(self) -> None:
         ENABLE_MOUSE_INPUT = 0x10
-        handle = windll.kernel32.GetStdHandle(STD_INPUT_HANDLE)
+        handle = HANDLE(windll.kernel32.GetStdHandle(STD_INPUT_HANDLE))
 
         original_mode = DWORD()
         self._winapi(windll.kernel32.GetConsoleMode, handle, pointer(original_mode))
         self._winapi(windll.kernel32.SetConsoleMode, handle, original_mode.value | ENABLE_MOUSE_INPUT)
 
     def disable_mouse_support(self) -> None:
         ENABLE_MOUSE_INPUT = 0x10
-        handle = windll.kernel32.GetStdHandle(STD_INPUT_HANDLE)
+        handle = HANDLE(windll.kernel32.GetStdHandle(STD_INPUT_HANDLE))
 
         original_mode = DWORD()
         self._winapi(windll.kernel32.GetConsoleMode, handle, pointer(original_mode))
@@ -417,7 +417,7 @@ def win32_refresh_window(cls) -> None:
         to a bug in the Windows Console. Sending a repaint request solves it.
         """
         # Get console handle
-        handle = windll.kernel32.GetConsoleWindow()
+        handle = HANDLE(windll.kernel32.GetConsoleWindow())
 
         RDW_INVALIDATE = 0x0001
         windll.user32.RedrawWindow(handle, None, None, c_uint(RDW_INVALIDATE))

prompt_toolkit/output/windows10.py

@@ -1,5 +1,5 @@
 from ctypes import byref, windll
-from ctypes.wintypes import DWORD
+from ctypes.wintypes import DWORD, HANDLE
 from typing import Any, TextIO
 
 from prompt_toolkit.data_structures import Size
@@ -26,7 +26,7 @@ class Windows10_Output:
     def __init__(self, stdout: TextIO) -> None:
         self.win32_output = Win32Output(stdout)
         self.vt100_output = Vt100_Output(stdout, lambda: Size(0, 0))
-        self._hconsole = windll.kernel32.GetStdHandle(STD_OUTPUT_HANDLE)
+        self._hconsole = HANDLE(windll.kernel32.GetStdHandle(STD_OUTPUT_HANDLE))
 
     def flush(self) -> None:
         """
@@ -68,7 +68,7 @@ def is_win_vt100_enabled() -> bool:
     if not is_windows():
         return False
 
-    hconsole = windll.kernel32.GetStdHandle(STD_OUTPUT_HANDLE)
+    hconsole = HANDLE(windll.kernel32.GetStdHandle(STD_OUTPUT_HANDLE))
 
     # Get original console mode.
     original_mode = DWORD(0)