dwipe 2.0.2__py3-none-any.whl → 3.0.1__py3-none-any.whl

dwipe/Utils.py

@@ -3,6 +3,7 @@ Utils class - Utility functions for dwipe
 """
 import os
 import sys
+import pwd
 import datetime
 from pathlib import Path
 from .StructuredLogger import StructuredLogger
@@ -81,7 +82,6 @@ class Utils:
         real_user = os.environ.get('SUDO_USER')
         if real_user:
             # Running with sudo - get the real user's home directory
-            import pwd
             real_home = pwd.getpwnam(real_user).pw_dir
             config_dir = Path(real_home) / '.config' / 'dwipe'
         else:
@@ -93,7 +93,6 @@ class Utils:
         # Fix ownership if running with sudo
         if real_user:
             try:
-                import pwd
                 pw_record = pwd.getpwnam(real_user)
                 uid, gid = pw_record.pw_uid, pw_record.pw_gid
                 os.chown(config_dir, uid, gid)
@@ -112,7 +111,6 @@ class Utils:
         real_user = os.environ.get('SUDO_USER')
         if real_user:
             try:
-                import pwd
                 pw_record = pwd.getpwnam(real_user)
                 uid, gid = pw_record.pw_uid, pw_record.pw_gid
                 os.chown(file_path, uid, gid)
@@ -207,8 +205,19 @@ class Utils:
         result_str = summary['result']
         size_str = device['size']
         time_str = summary['total_elapsed']
-        # Get rate from first step (wipe step)
-        rate_str = summary['steps'][0]['rate'] if summary['steps'] else 'N/A'
+        # Get rate from wipe step (skip precheck/verify steps for firmware wipes)
+        rate_str = 'N/A'
+        for step in summary['steps']:
+            step_name = step.get('step', '').lower()
+            # Look for actual wipe steps: firmware wipes start with "firmware",
+            # software wipes have "writing" in the step name
+            # Skip precheck, pre-verify, post-verify steps
+            if step_name.startswith('firmware') or 'writing' in step_name:
+                rate_str = step.get('rate', 'N/A')
+                break
+        # Fallback to first step if no wipe step found
+        if rate_str == 'N/A' and summary['steps']:
+            rate_str = summary['steps'][0].get('rate', 'N/A')
 
         # Build base message
         operation = plan['operation'].capitalize()
@@ -305,3 +314,181 @@ class Utils:
             Utils.fix_file_ownership(log_path)
         except Exception:
             pass  # Don't fail if logging fails
+
+    @staticmethod
+    def parse_nvme_sanitize_capabilities(id_ctrl_data: dict) -> dict:
+        """Parse NVMe sanitize capabilities from id-ctrl JSON data.
+
+        Extracts the sanicap field and interprets the capability bits according
+        to the NVMe specification:
+        - Bit 0: Crypto Erase
+        - Bit 1: Block Erase
+        - Bit 2: Overwrite
+
+        Args:
+            id_ctrl_data: Dictionary from nvme id-ctrl command (with -o json)
+
+        Returns:
+            dict: Maps capability names to method names, e.g.,
+                  {'Crypto': 'sanitize_crypto', 'Block': 'sanitize_block'}
+        """
+        modes = {}
+        sanicap = id_ctrl_data.get('sanicap', 0)
+
+        if sanicap > 0:
+            if sanicap & 0x01:
+                modes['Crypto'] = 'sanitize_crypto'
+            if sanicap & 0x02:
+                modes['Block'] = 'sanitize_block'
+            if sanicap & 0x04:
+                modes['Ovwr'] = 'sanitize_overwrite'
+
+        return modes
+
+    @staticmethod
+    def parse_nvme_sanitize_flags(id_ctrl_data: dict) -> tuple:
+        """Parse NVMe sanitize capabilities into individual boolean flags.
+
+        Interprets sanicap bits according to NVMe specification:
+        - Bit 0: Crypto Erase
+        - Bit 1: Block Erase
+        - Bit 2: Overwrite
+
+        Args:
+            id_ctrl_data: Dictionary from nvme id-ctrl command (with -o json)
+
+        Returns:
+            tuple: (has_sanitize, crypto_erase_supported, block_erase_supported,
+                    overwrite_supported)
+        """
+        sanicap = id_ctrl_data.get('sanicap', 0)
+        has_sanitize = sanicap > 0
+        crypto_erase_supported = bool(sanicap & 0x01)
+        block_erase_supported = bool(sanicap & 0x02)
+        overwrite_supported = bool(sanicap & 0x04)
+
+        return has_sanitize, crypto_erase_supported, block_erase_supported, overwrite_supported
+
+
+class ClipboardHelper:
+    """Helper for copying text to clipboard across different Linux environments.
+
+    Supports:
+    - OSC 52 escape sequence (works over SSH if terminal supports it)
+    - Wayland (wl-copy)
+    - X11 (xclip, xsel)
+    - Terminal fallback (print to screen when clipboard unavailable)
+
+    Detection priority:
+    1. If SSH session detected -> use OSC 52 (terminal clipboard escape sequence)
+    2. If WAYLAND_DISPLAY set -> try wl-copy
+    3. If DISPLAY set -> try xclip, then xsel
+    4. Fallback -> terminal mode (manual copy)
+    """
+    import subprocess
+    import shutil
+
+    # Singleton instance for caching probe results
+    _instance = None
+    _probed = False
+    _clipboard_cmd = None  # e.g., ['wl-copy'] or ['xclip', '-selection', 'clipboard']
+    _use_osc52 = False     # Use OSC 52 terminal escape sequence
+    _is_ssh = False
+    _method_name = None  # Human-readable method name
+
+    @classmethod
+    def _probe(cls):
+        """Probe available clipboard methods (called once, results cached)."""
+        if cls._probed:
+            return
+
+        cls._probed = True
+        import shutil
+
+        # Check for SSH session - use OSC 52 escape sequence
+        cls._is_ssh = bool(os.environ.get('SSH_CLIENT') or os.environ.get('SSH_TTY')
+                          or os.environ.get('SSH_CONNECTION'))
+
+        if cls._is_ssh:
+            # OSC 52 works through terminal emulators that support it
+            # (iTerm2, kitty, alacritty, Windows Terminal, tmux with set-clipboard)
+            cls._use_osc52 = True
+            cls._method_name = 'OSC 52 (terminal escape sequence)'
+            return
+
+        # Check Wayland first
+        if os.environ.get('WAYLAND_DISPLAY'):
+            if shutil.which('wl-copy'):
+                cls._clipboard_cmd = ['wl-copy']
+                cls._method_name = 'wl-copy (Wayland)'
+                return
+
+        # Check X11
+        if os.environ.get('DISPLAY'):
+            if shutil.which('xclip'):
+                cls._clipboard_cmd = ['xclip', '-selection', 'clipboard']
+                cls._method_name = 'xclip (X11)'
+                return
+            if shutil.which('xsel'):
+                cls._clipboard_cmd = ['xsel', '--clipboard', '--input']
+                cls._method_name = 'xsel (X11)'
+                return
+
+        cls._method_name = 'terminal (no clipboard tool found)'
+
+    @classmethod
+    def get_method_name(cls):
+        """Return human-readable description of clipboard method."""
+        cls._probe()
+        return cls._method_name
+
+    @classmethod
+    def has_clipboard(cls):
+        """Return True if a clipboard method is available (tool or OSC 52)."""
+        cls._probe()
+        return cls._clipboard_cmd is not None or cls._use_osc52
+
+    @classmethod
+    def copy(cls, text):
+        """Copy text to clipboard.
+
+        Args:
+            text: String to copy
+
+        Returns:
+            tuple: (success: bool, error_message: str or None)
+        """
+        cls._probe()
+        import subprocess
+        import base64
+
+        # Try OSC 52 escape sequence (works over SSH with supporting terminals)
+        if cls._use_osc52:
+            try:
+                encoded = base64.b64encode(text.encode('utf-8')).decode('ascii')
+                # OSC 52: \033]52;c;<base64>\a
+                # 'c' = clipboard selection
+                osc52 = f'\033]52;c;{encoded}\a'
+                sys.stdout.write(osc52)
+                sys.stdout.flush()
+                return True, None
+            except Exception as e:
+                return False, f"OSC 52 failed: {e}"
+
+        if not cls._clipboard_cmd:
+            return False, "No clipboard available"
+
+        try:
+            proc = subprocess.run(
+                cls._clipboard_cmd,
+                input=text.encode('utf-8'),
+                capture_output=True,
+                timeout=5
+            )
+            if proc.returncode == 0:
+                return True, None
+            return False, proc.stderr.decode('utf-8', errors='replace').strip()
+        except subprocess.TimeoutExpired:
+            return False, "Clipboard command timed out"
+        except Exception as e:
+            return False, str(e)

dwipe/VerifyTask.py

@@ -310,7 +310,9 @@ class VerifyTask(WipeTask):
     def get_status(self):
         """Get current progress status (thread-safe, called from main thread)
 
-        Returns verification percentage with 'v' prefix (e.g., "v45%")
+        Returns:
+            tuple: (elapsed_str, pct_str, rate_str, eta_str, more_state)
+            - pct_str has 'v' prefix (e.g., "v45%")
         """
         mono = time.monotonic()
         elapsed_time = mono - self.start_mono
@@ -347,7 +349,7 @@ class VerifyTask(WipeTask):
         else:
             when_str = '0'
 
-        return Utils.ago_str(int(round(elapsed_time))), pct_str, rate_str, when_str
+        return Utils.ago_str(int(round(elapsed_time))), pct_str, rate_str, when_str, self.more_state
 
     def get_summary_dict(self):
         """Get final summary for this verify task

dwipe/WipeJob.py

@@ -18,6 +18,7 @@ from .Utils import Utils
 from .WipeTask import WipeTask
 from .WriteTask import WriteTask, WriteZeroTask, WriteRandTask
 from .VerifyTask import VerifyTask, VerifyZeroTask, VerifyRandTask
+from .FirmwareWipeTask import FirmwareWipeTask
 
 
 class WipeJob:
@@ -166,7 +167,7 @@ class WipeJob:
 
         ## SLOWDOWN / STALL DETECTION/ABORT FEATURE (proxied from tasks)
         ##
-        self.slowdown_stop = getattr(opts, 'slowdown_stop', 16)
+        self.slowdown_stop = getattr(opts, 'slowdown_stop', 64)
         self.stall_timeout = getattr(opts, 'stall_timeout', 60)
         self.max_slowdown_ratio = 0
         self.max_stall_secs = 0
@@ -230,6 +231,9 @@ class WipeJob:
                 self.current_task = task
                 self.current_task_index = i
 
+                # Set job reference so tasks can access shared state (e.g., for firmware verify)
+                task.job = self
+
                 # Run the task
                 task.run_task()
 
@@ -264,17 +268,22 @@ class WipeJob:
                     summary = task.get_summary_dict()
                     self.verify_result = summary.get('result', None)
 
+                    # Write marker with verify status after verification completes
+                    if not task.exception and not self.do_abort and self.verify_result:
+                        is_random = (self.expected_pattern == "random")
+                        self._write_marker_with_verify_status(is_random)
+
                 # Check for task errors (AFTER proxying state)
                 if task.exception:
-                    self.exception = task.exception
-                    # For write tasks, failure means wipe didn't succeed
-                    if isinstance(task, WriteTask):
+                    # For write tasks and firmware wipe tasks, failure is critical - set exception and break
+                    if isinstance(task, (WriteTask, FirmwareWipeTask)):
+                        self.exception = task.exception
                         # Sync abort state before breaking
                         if task.do_abort:
                             self.do_abort = True
                         break
-                    # For verify tasks, continue but record the exception
-                    # (wipe succeeded but verification failed)
+                    # For other tasks (precheck, pre-verify, post-verify), continue without setting job exception
+                    # (these are support tasks - only the actual wipe matters for job success/failure)
 
                 # Check if task was aborted (sync abort state)
                 if task.do_abort and not self.do_abort:
@@ -588,12 +597,13 @@ class WipeJob:
                 f"Completed: {percent_complete:.2f}%")
 
     def get_status(self):
-        """Get status tuple: (elapsed, percent, rate, eta)
+        """Get status tuple: (elapsed, percent, rate, eta, more_state)
 
         Returns stats for current phase only:
         - Write phase (0-100%): elapsed/rate/eta for writing
         - Flushing phase: 100% FLUSH while kernel syncs to device
         - Verify phase (v0-v100%): elapsed/rate/eta for verification only
+        - more_state: optional extra status from derived task class
         """
         # NEW: Proxy to current task if using task-based architecture
         if self.current_task is not None:
@@ -646,7 +656,7 @@ class WipeJob:
             else:
                 when_str = '0'
 
-            return Utils.ago_str(int(round(elapsed_time))), pct_str, rate_str, when_str
+            return Utils.ago_str(int(round(elapsed_time))), pct_str, rate_str, when_str, ""
         else:
             # Write phase: 0-100% (across all passes)
             written = self.total_written
@@ -683,7 +693,7 @@ class WipeJob:
             else:
                 when_str = '0'
 
-            return Utils.ago_str(int(round(elapsed_time))), pct_str, rate_str, when_str
+            return Utils.ago_str(int(round(elapsed_time))), pct_str, rate_str, when_str, ""
 
     def get_plan_dict(self, mode=None):
         """Generate plan dictionary for structured logging
@@ -763,7 +773,7 @@ class WipeJob:
 
             # Build top-level summary
             summary = {
-                "result": "stopped" if self.do_abort else "completed",
+                "result": "stopped" if self.do_abort else ("failed" if self.exception else "completed"),
                 "total_elapsed": Utils.ago_str(int(total_elapsed)),
                 "total_errors": total_errors,
                 "pct_complete": round(pct_complete, 1),
@@ -850,7 +860,7 @@ class WipeJob:
 
         # Build top-level summary
         summary = {
-            "result": "stopped" if self.do_abort else "completed",
+            "result": "stopped" if self.do_abort else ("failed" if self.exception else "completed"),
             "total_elapsed": Utils.ago_str(int(total_elapsed)),
             "total_errors": self.total_errors,
             "pct_complete": round(pct_complete, 1),
@@ -1223,8 +1233,10 @@ class WipeJob:
             # Auto-start verification if enabled and write completed successfully
             verify_pct = getattr(self.opts, 'verify_pct', 0)
             auto_verify = getattr(self.opts, 'wipe_mode', "").endswith('+V')
-            if auto_verify and verify_pct > 0 and not self.do_abort and not self.exception:
-                self.verify_partition(verify_pct)
+            if auto_verify and not self.do_abort and not self.exception:
+                # Default to 2% verification if +V mode enabled but verify_pct not set
+                actual_verify_pct = verify_pct if verify_pct > 0 else 2
+                self.verify_partition(actual_verify_pct)
                 # Write marker with verification status after verification completes
                 # Use desired_mode to determine if random or zero
                 is_random = (desired_mode == 'Rand')

dwipe/WipeTask.py

@@ -57,6 +57,7 @@ class WipeTask:
         self.do_abort = False
         self.done = False
         self.exception = None
+        self.more_state = ""  # Optional extra status info from derived classes
 
         # Progress tracking
         self.total_written = 0  # Bytes processed (write or verify)
@@ -80,11 +81,12 @@ class WipeTask:
         """Get current progress status (thread-safe, called from main thread)
 
         Returns:
-            tuple: (elapsed_str, pct_str, rate_str, eta_str)
+            tuple: (elapsed_str, pct_str, rate_str, eta_str, more_state)
                 - elapsed_str: e.g., "5m23s"
                 - pct_str: e.g., "45%" or "v23%" (for verify)
                 - rate_str: e.g., "450MB/s"
                 - eta_str: e.g., "2m15s"
+                - more_state: optional extra status from derived class
         """
         mono = time.monotonic()
         elapsed_time = mono - self.start_mono
@@ -116,7 +118,7 @@ class WipeTask:
         else:
             when_str = '0'
 
-        return Utils.ago_str(int(round(elapsed_time))), pct_str, rate_str, when_str
+        return Utils.ago_str(int(round(elapsed_time))), pct_str, rate_str, when_str, self.more_state
 
     def get_summary_dict(self):
         """Get final summary after task completion

dwipe/WriteTask.py

@@ -54,7 +54,7 @@ class WriteTask(WipeTask):
         self.marker_update_interval = 30  # Update every 30 seconds
 
         # Performance monitoring
-        self.slowdown_stop = getattr(opts, 'slowdown_stop', 16)
+        self.slowdown_stop = getattr(opts, 'slowdown_stop', 64)
         self.stall_timeout = getattr(opts, 'stall_timeout', 60)
         self.max_slowdown_ratio = 0
         self.max_stall_secs = 0

dwipe/main.py

@@ -16,18 +16,41 @@ from .DiskWipe import DiskWipe
 from .DeviceInfo import DeviceInfo
 from .Utils import Utils
 from .Prereqs import Prereqs
+from .PersistentState import PersistentState
 
 
 def main():
     """Main entry point"""
     import argparse
+    from pathlib import Path
+
+    # Load persistent state first so we can use previous values as defaults
+    config_dir = Utils.get_config_dir()
+    config_path = config_dir / 'state.json'
+    persist = PersistentState(config_path=config_path)
+
     parser = argparse.ArgumentParser()
     parser.add_argument('--dump-lsblk', action='store_true',
                         help='dump parsed lsblk and exit for debugging')
-    parser.add_argument('-F', '--firmware-wipes', action='store_true',
-                        help='enable experimental (alpha) firmware wipes')
+    parser.add_argument('--mode', choices=['-V', '+V'], default=persist.state['wipe_mode'],
+                        help='verification mode: -V (none) or +V (verify after wipe)')
+    parser.add_argument('--passes', type=int, choices=[1, 2, 4], default=persist.state['passes'],
+                        help='number of passes for software wipes (1, 2, or 4)')
+    parser.add_argument('--verify-pct', type=int, choices=[1, 3, 10, 30, 100], default=persist.state['verify_pct'],
+                        help='verification percentage after wipe (1, 3, 10, 30, or 100)')
+    parser.add_argument('--port-serial', choices=['Auto', 'On', 'Off'], default=persist.state['port_serial'],
+                        help='display mode for disk port/serial info (Auto, On, or Off)')
+    parser.add_argument('--slowdown-stop', type=int, choices=[0, 4, 16, 64, 256], default=persist.state['slowdown_stop'],
+                        help='stop wipe if disk slows down (0 = disabled, else check interval in ms)')
+    parser.add_argument('--stall-timeout', type=int, choices=[0, 60, 120, 300, 600], default=persist.state['stall_timeout'],
+                        help='stall timeout in seconds (0 = disabled)')
+    parser.add_argument('--dense', choices=['True', 'False'], default='True' if persist.state['dense'] else 'False',
+                        help='dense view: True (compact) or False (spaced lines)')
     opts = parser.parse_args()
 
+    # Convert string booleans to actual booleans
+    opts.dense = opts.dense == 'True'
+
     dwipe = None  # Initialize to None so exception handler can reference it
     try:
         if os.geteuid() != 0:
@@ -35,14 +58,11 @@ def main():
             Utils.rerun_module_as_root('dwipe.main')
 
         prereqs = Prereqs(verbose=True)
-        # lsblk is critical for everything; hdparm and nvme only needed for firmware wipes
-        if opts.firmware_wipes:
-            prereqs.check_all(['lsblk', 'hdparm', 'nvme'])
-        else:
-            prereqs.check_all(['lsblk'])
+        # blkid for filesystem detection; hdparm and nvme for firmware wipes
+        prereqs.check_all(['blkid', 'hdparm', 'nvme'])
         prereqs.report_and_exit_if_failed()
 
-        dwipe = DiskWipe(opts=opts)  # opts=opts)
+        dwipe = DiskWipe(opts=opts, persistent_state=persist)
 
         dwipe.main_loop()
     except Exception as exce: