flashpod 0.2.1__tar.gz → 0.2.3__tar.gz

{flashpod-0.2.1 → flashpod-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flashpod
-Version: 0.2.1
+Version: 0.2.3
 Summary: Command-line iPod sync + card-flashing tooling for early FireWire-era iPods, pure Python
 Author: David Barnhart
 License-Expression: MIT

{flashpod-0.2.1 → flashpod-0.2.3}/flashpod/ipod_flash.py

@@ -397,10 +397,44 @@ def device_mountpoints(dev):
 # ----------------------------------------------------------------------------
 # Interactive selection + confirmation
 # ----------------------------------------------------------------------------
-def choose_device():
-    cands = list_candidates()
-    if not cands:
-        sys.exit(color("No removable/USB disks found. Plug in the card and retry.", C_RED))
+def pick_device(scan, render, path_of, empty_msg):
+    """Interactive device chooser shared by every platform backend.
+
+    ``scan()`` returns the candidate list (called again on each refresh),
+    ``render(items)`` prints the table, ``path_of(item)`` yields the device path
+    to return.
+
+    The loop accepts 'r' to re-scan. Without it, a reader plugged in — or a card
+    inserted — after the list was drawn stays invisible until you quit and start
+    the whole command over, which is a long way back when you've already picked
+    a model and firmware.
+    """
+    items = scan()
+    if not items:
+        sys.exit(color(empty_msg, C_RED))
+    render(items)
+    while True:
+        try:
+            sel = input(color("Select device number "
+                              "('r' to rescan, 'q' to quit): ", C_CYN)).strip().lower()
+        except (EOFError, KeyboardInterrupt):
+            print(file=sys.stderr)
+            sys.exit("Aborted.")
+        if sel in ("q", "quit", ""):
+            sys.exit("Aborted.")
+        if sel in ("r", "refresh", "rescan"):
+            items = scan()
+            if not items:
+                print(color("  " + empty_msg, C_YEL), file=sys.stderr)
+            else:
+                render(items)
+            continue
+        if sel.isdigit() and int(sel) < len(items):
+            return path_of(items[int(sel)])
+        print(color("  invalid selection", C_RED), file=sys.stderr)
+
+
+def _render_candidates(cands):
     print(color("\nAttached removable storage:\n", C_CYN), file=sys.stderr)
     # Multi-slot readers expose one /dev/sdX per slot, all with the same
     # identity strings; number the slots so they can be told apart.
@@ -442,13 +476,13 @@ def choose_device():
         if r["warn"]:
             print(color(" " * sub + "⚠ " + r["warn"], C_YEL), file=sys.stderr)
     print(file=sys.stderr)
-    while True:
-        sel = input(color("Select device number (or 'q' to quit): ", C_CYN)).strip()
-        if sel.lower() in ("q", "quit", ""):
-            sys.exit("Aborted.")
-        if sel.isdigit() and int(sel) < len(cands):
-            return "/dev/" + cands[int(sel)]["name"]
-        print(color("  invalid selection", C_RED), file=sys.stderr)
+
+
+def choose_device():
+    return pick_device(
+        list_candidates, _render_candidates,
+        lambda d: "/dev/" + d["name"],
+        "No removable/USB disks found. Plug in the card and retry.")
 
 def device_label(dev):
     """Short, typeable name for a device, used in the ERASE confirmation.

{flashpod-0.2.1 → flashpod-0.2.3}/flashpod/platform/macos.py

@@ -73,26 +73,22 @@ class MacOSPlatform(Platform):
     def choose_device(self):
         from .. import ipod_flash
         color = ipod_flash.color
-        disks = self._external_disks()
-        if not disks:
-            sys.exit(color("No external disks found. Plug in the card reader and retry.",
-                           ipod_flash.C_RED))
-        print(color("\nAttached external disks:\n", ipod_flash.C_CYN), file=sys.stderr)
-        for i, (d, info) in enumerate(disks):
-            size = int(info.get("TotalSize") or info.get("Size") or 0)
-            name = (info.get("MediaName") or info.get("IORegistryEntryName")
-                    or "").strip() or "disk"
-            print("  [%d] /dev/%-7s  %10s  %s" %
-                  (i, d, ipod_flash.fmt_size(size), name), file=sys.stderr)
-        print(file=sys.stderr)
-        while True:
-            sel = input(color("Select device number (or 'q' to quit): ",
-                              ipod_flash.C_CYN)).strip()
-            if sel.lower() in ("q", "quit", ""):
-                sys.exit("Aborted.")
-            if sel.isdigit() and int(sel) < len(disks):
-                return "/dev/" + disks[int(sel)][0]
-            print(color("  invalid selection", ipod_flash.C_RED), file=sys.stderr)
+
+        def render(disks):
+            print(color("\nAttached external disks:\n", ipod_flash.C_CYN),
+                  file=sys.stderr)
+            for i, (d, info) in enumerate(disks):
+                size = int(info.get("TotalSize") or info.get("Size") or 0)
+                name = (info.get("MediaName") or info.get("IORegistryEntryName")
+                        or "").strip() or "disk"
+                print("  [%d] /dev/%-7s  %10s  %s" %
+                      (i, d, ipod_flash.fmt_size(size), name), file=sys.stderr)
+            print(file=sys.stderr)
+
+        return ipod_flash.pick_device(
+            self._external_disks, render,
+            lambda item: "/dev/" + item[0],
+            "No external disks found. Plug in the card reader and retry.")
 
     def device_sectors(self, dev):
         # real file/image -> just its size

{flashpod-0.2.1 → flashpod-0.2.3}/flashpod/platform/windows.py

@@ -35,7 +35,38 @@ GENERIC_WRITE = 0x40000000
 FILE_SHARE_READ = 0x00000001
 FILE_SHARE_WRITE = 0x00000002
 OPEN_EXISTING = 3
-INVALID_HANDLE_VALUE = ctypes.c_void_p(-1).value if False else (2 ** 64 - 1)
+# INVALID_HANDLE_VALUE is (HANDLE)-1, so its unsigned value is pointer-sized:
+# 2**64-1 on 64-bit Python, 2**32-1 on 32-bit. Derive it rather than assuming.
+INVALID_HANDLE_VALUE = (1 << (8 * ctypes.sizeof(ctypes.c_void_p))) - 1
+
+
+def _k32():
+    """kernel32 with correct prototypes for the handle APIs.
+
+    Declaring these matters: ctypes defaults restype to ``c_int``, but a HANDLE
+    is pointer-sized. On 64-bit Windows that truncates the handle, and — far
+    worse — a *failed* CreateFileW returns INVALID_HANDLE_VALUE, which as a
+    signed int is -1 and never equals the unsigned constant we compare against.
+    The failure then goes unnoticed and the bogus handle reaches
+    msvcrt.open_osfhandle, whose fd raises EBADF ("Bad file descriptor") on
+    first use — hiding the actual Windows error.
+
+    Re-declaring on every call is harmless and keeps this import-safe on
+    non-Windows (nothing here runs until a method is called).
+    """
+    k = ctypes.windll.kernel32
+    k.CreateFileW.restype = ctypes.c_void_p
+    k.CreateFileW.argtypes = [ctypes.c_wchar_p, ctypes.c_uint32,
+                              ctypes.c_uint32, ctypes.c_void_p,
+                              ctypes.c_uint32, ctypes.c_uint32,
+                              ctypes.c_void_p]
+    k.CloseHandle.argtypes = [ctypes.c_void_p]
+    k.DeviceIoControl.argtypes = [ctypes.c_void_p, ctypes.c_uint32,
+                                  ctypes.c_void_p, ctypes.c_uint32,
+                                  ctypes.c_void_p, ctypes.c_uint32,
+                                  ctypes.POINTER(ctypes.c_ulong),
+                                  ctypes.c_void_p]
+    return k
 
 
 def _powershell(script):
@@ -73,24 +104,28 @@ class WindowsPlatform(Platform):
 
     # -- low-level handle helpers -----------------------------------------
     def _open_handle(self, path, write):
+        k = _k32()
         access = GENERIC_READ | (GENERIC_WRITE if write else 0)
-        h = ctypes.windll.kernel32.CreateFileW(
-            ctypes.c_wchar_p(path), access,
-            FILE_SHARE_READ | FILE_SHARE_WRITE, None, OPEN_EXISTING, 0, None)
-        if h == INVALID_HANDLE_VALUE or h is None:
-            raise OSError("CreateFileW failed for %s (err %d)"
-                          % (path, ctypes.windll.kernel32.GetLastError()))
+        h = k.CreateFileW(path, access,
+                          FILE_SHARE_READ | FILE_SHARE_WRITE, None,
+                          OPEN_EXISTING, 0, None)
+        if h is None or h == INVALID_HANDLE_VALUE:
+            # Report what Windows actually said: error 5 (access denied) and 32
+            # (sharing violation) are the usual causes here, and both mean a
+            # volume on this disk is mounted and holding the sectors.
+            raise OSError("CreateFileW failed for %s: %s"
+                          % (path, ctypes.WinError(k.GetLastError())))
         return h
 
     def _ioctl(self, handle, code, out_size=0):
+        k = _k32()
         buf = ctypes.create_string_buffer(out_size) if out_size else None
         returned = ctypes.c_ulong(0)
-        ok = ctypes.windll.kernel32.DeviceIoControl(
-            handle, code, None, 0, buf, out_size,
-            ctypes.byref(returned), None)
+        ok = k.DeviceIoControl(handle, code, None, 0, buf, out_size,
+                               ctypes.byref(returned), None)
         if not ok:
-            raise OSError("DeviceIoControl 0x%X failed (err %d)"
-                          % (code, ctypes.windll.kernel32.GetLastError()))
+            raise OSError("DeviceIoControl 0x%X failed: %s"
+                          % (code, ctypes.WinError(k.GetLastError())))
         return buf.raw[:returned.value] if buf else b""
 
     # -- device discovery / selection -------------------------------------
@@ -109,29 +144,31 @@ class WindowsPlatform(Platform):
                           f[4].strip().lower() == "true" or f[5].strip().lower() == "true"))
         return disks
 
+    def _removable_disks(self):
+        """Removable/USB disks worth offering, falling back to every non-system
+        disk when nothing matches the removable bus types."""
+        disks = self._disks()
+        cands = [d for d in disks
+                 if not d[4] and d[3] in ("USB", "SD", "MMC", "1394")]
+        return cands or [d for d in disks if not d[4]]
+
     def choose_device(self):
         from .. import ipod_flash
         color = ipod_flash.color
-        cands = [d for d in self._disks()
-                 if not d[4] and d[3] in ("USB", "SD", "MMC", "1394")]
-        if not cands:
-            cands = [d for d in self._disks() if not d[4]]
-        if not cands:
-            sys.exit(color("No removable disks found. Plug in the card and retry.",
-                           ipod_flash.C_RED))
-        print(color("\nAttached removable disks:\n", ipod_flash.C_CYN), file=sys.stderr)
-        for i, (num, size, name, bus, _sys) in enumerate(cands):
-            print("  [%d] \\\\.\\PhysicalDrive%-3d %10s  %s (%s)" %
-                  (i, num, ipod_flash.fmt_size(size), name.strip(), bus), file=sys.stderr)
-        print(file=sys.stderr)
-        while True:
-            sel = input(color("Select device number (or 'q' to quit): ",
-                              ipod_flash.C_CYN)).strip()
-            if sel.lower() in ("q", "quit", ""):
-                sys.exit("Aborted.")
-            if sel.isdigit() and int(sel) < len(cands):
-                return "\\\\.\\PhysicalDrive%d" % cands[int(sel)][0]
-            print(color("  invalid selection", ipod_flash.C_RED), file=sys.stderr)
+
+        def render(cands):
+            print(color("\nAttached removable disks:\n", ipod_flash.C_CYN),
+                  file=sys.stderr)
+            for i, (num, size, name, bus, _sys) in enumerate(cands):
+                print("  [%d] \\\\.\\PhysicalDrive%-3d %10s  %s (%s)" %
+                      (i, num, ipod_flash.fmt_size(size), name.strip(), bus),
+                      file=sys.stderr)
+            print(file=sys.stderr)
+
+        return ipod_flash.pick_device(
+            self._removable_disks, render,
+            lambda d: "\\\\.\\PhysicalDrive%d" % d[0],
+            "No removable disks found. Plug in the card and retry.")
 
     def device_sectors(self, dev):
         if os.path.isfile(dev):
@@ -237,7 +274,15 @@ class WindowsPlatform(Platform):
         if os.path.isfile(dev):
             return open(dev, mode)
         import msvcrt
-        h = self._open_handle(dev, write=("w" in mode or "+" in mode or "a" in mode))
+        write = ("w" in mode or "+" in mode or "a" in mode)
+        if write:
+            # FSCTL_LOCK_VOLUME only holds while the locking handle is open, so
+            # the dismount done before write_layout is already undone by now:
+            # writing the new MBR makes Windows rescan and re-mount the data
+            # partition, and it then refuses writes into those sectors. Dismount
+            # again immediately before each write open.
+            self.unmount_all(dev, False)
+        h = self._open_handle(dev, write=write)
         fd = msvcrt.open_osfhandle(h, os.O_BINARY)
         return AlignedRawIO(os.fdopen(fd, mode, buffering=0))
 

{flashpod-0.2.1 → flashpod-0.2.3}/flashpod.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flashpod
-Version: 0.2.1
+Version: 0.2.3
 Summary: Command-line iPod sync + card-flashing tooling for early FireWire-era iPods, pure Python
 Author: David Barnhart
 License-Expression: MIT

{flashpod-0.2.1 → flashpod-0.2.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "flashpod"
-version = "0.2.1"
+version = "0.2.3"
 description = "Command-line iPod sync + card-flashing tooling for early FireWire-era iPods, pure Python"
 readme = "README.md"
 requires-python = ">=3.6"