add comments

fixes #95

Reviewed-on: #96
Co-authored-by: localhorst <localhorst@mosad.xyz>
Co-committed-by: localhorst <localhorst@mosad.xyz>

README.md

@@ -9,16 +9,16 @@
 * process multiple drives at once
 
 ## Download USB Image ##
-[2.5GB image v1.0.0](https://schuttercloud.com/s/ggxGH9sA326aRfK)   (`wget` is your friend)
+See reHDD-Bootable how the live image created: https://git.mosad.xyz/localhorst/reHDD-Bootable
 
 Use [Etcher](https://www.balena.io/etcher/#download) or `dd` to create an bootable USB drive .
 
 ## Screenshot 
 ![Screenshot of reHDD with multiple drives in different states](https://git.mosad.xyz/localhorst/reHDD/raw/commit/c40dfe2cbb8f86490b49caf82db70a10015f06f9/doc/screenshot.png "Screenshot")
 
-## Debian Build Notes
+## openSUSE Build Notes
 
-* `apt-get install ncurses-dev git make g++`
+* `zypper install ncurses-devel git make gcc-c++`
 * `git submodule init`
 * `git submodule update`
 * `make release`
@@ -28,16 +28,8 @@ Use [Etcher](https://www.balena.io/etcher/#download) or `dd` to create an bootab
 Just install [reHDDPrinter](https://git.mosad.xyz/localhorst/reHDDPrinter).
 No further settings needed.
 
-## Create Standalone with Debian 11
-
-Instructions how to create a standalone machine that boots directly to reHDD. This is aimed for production use, like several drives a day shredding.
-* Start reHDD after boot without login (as a tty1 shell)
-* Start dmesg after boot without login (as a tty2 shell)
-* Start htop after boot without login (as a tty3 shell)
-* Upload reHDD log every 12h if wanted
-
 ### Software requirements
-* `apt-get install hwinfo smartmontools curl htop sudo`
+* `zypper install hwinfo smartmontools curl htop sudo`
 
 ### Installation
 
@@ -56,7 +48,7 @@ git submodule update
 
 If you want to upload the logs, edit `scripts/reHDDLogUploader.bash` with your nextcloud token
 
-Add your system drive in `/root/reHDD/ignoreDrives.conf` like:
+Add ignored drives in `/root/reHDD/ignoreDrives.conf` like:
 ```e102f49d```
 Get the first 8 Bytes from your UUID via `blkid /dev/sdX`
 

astyle.sh

@@ -1,17 +0,0 @@
-#! /bin/bash
-
-echo starting astyle for $PWD
-
-astyle --style=gnu src/*.cpp
-rm -f src/*.orig
-
-astyle --style=gnu src/logger/*.cpp
-rm -f src/logger/*.orig
-
-astyle --style=gnu include/*.h
-rm -f include/*.orig
-
-astyle --style=gnu include/logger/*.h
-rm -f include//logger/*.orig
-
-echo finished astyle for $PWD

include/delete.h

@@ -13,13 +13,11 @@
 class Delete
 {
 protected:
-
 public:
-    static void deleteDrive(Drive* drive);
+    static void deleteDrive(Drive *drive);
 
 private:
     Delete(void);
-
 };
 
-#endif  // DELETE_H_
+#endif // DELETE_H_

include/drive.h

@@ -14,84 +14,123 @@ class Drive
 {
 
 public:
-    enum TaskState {NONE,
+    enum class TaskState
-                    SHRED_SELECTED,
+    {
-                    SHRED_ACTIVE, //shred iterations active
+        NONE,
-                    CHECK_ACTIVE, //optional checking active
+        SHRED_SELECTED,
-                    DELETE_SELECTED,
+        SHRED_ACTIVE, // shred iterations active
-                    DELETE_ACTIVE,
+        CHECK_ACTIVE, // optional checking active
-                    FROZEN
+        CHECK_SUCCESSFUL,
-                   } state;
+        CHECK_FAILED,
+        DELETE_SELECTED,
+        DELETE_ACTIVE,
+        FROZEN
+    };
 
-    struct
+    enum class ConnectionType
+    {
+        UNKNOWN,
+        USB,
+        SATA,
+        NVME
+    };
+
+    struct ShredSpeed
     {
         time_t u32ShredTimeDelta;
-        std::chrono::time_point<std::chrono::system_clock> chronoShredTimestamp;
+        std::chrono::time_point<std::chrono::system_clock>
+            chronoShredTimestamp;
         unsigned long ulWrittenBytes;
         unsigned long ulSpeedMetricBytesWritten;
-    } sShredSpeed;
+    };
 
-    bool bWasShredded = false; //all shred iterations done
+    std::atomic<TaskState> state;
-    bool bWasChecked = false; //all shred iterations and optional checking done
+    std::atomic<ConnectionType> connectionType;
+    std::atomic<ShredSpeed> sShredSpeed;
+
+    bool bWasShredded = false;     // all shred iterations done
+    bool bWasShredStarted = false; // shred was atleast once started
+    bool bWasChecked = false;      // all shred iterations and optional checking done
     bool bWasDeleted = false;
     bool bIsOffline = false;
     uint32_t u32DriveChecksumAfterShredding = 0U;
+    uint16_t u16DriveIndex = 0U; // Index of TUI list
 
 private:
-    string sPath;
+    std::string sPath;
-    time_t u32Timestamp = 0U; //unix timestamp for detecting a frozen drive
+    time_t u32Timestamp = 0U;          // unix timestamp for detecting a frozen drive
-    double d32TaskPercentage = 0U; //in percent for Shred (1 to 100)
+    double d32TaskPercentage = 0U;     // in percent for Shred (1 to 100)
-    time_t u32TimestampTaskStart = 0U; //unix timestamp for duration of an action
+    time_t u32TimestampTaskStart = 0U; // unix timestamp for duration of an action
-    time_t u32TaskDuration = 0U; //time needed to complete the task
+    time_t u32TaskDuration = 0U;       // time needed to complete the task
 
     struct
     {
-        string sModelFamily;
+        std::string sModelFamily;
-        string sModelName;
+        std::string sModelName;
-        string sSerial;
+        std::string sSerial;
-        uint64_t u64Capacity = 0U; //in byte
+        uint64_t u64Capacity = 0U; // in byte
         uint32_t u32ErrorCount = 0U;
-        uint32_t u32PowerOnHours = 0U; //in hours
+        uint32_t u32PowerOnHours = 0U; // in hours
         uint32_t u32PowerCycles = 0U;
-        uint32_t u32Temperature = 0U; //in Fahrenheit, just kidding: degree Celsius
+        uint32_t u32Temperature = 0U;          // in Fahrenheit, just kidding: degree Celsius
+        uint32_t u32ReallocatedSectors = 0U;   // ID 0x05 - Reallocated Sectors Count
+        uint32_t u32PendingSectors = 0U;       // ID 0xC5 - Current Pending Sector Count
+        uint32_t u32UncorrectableSectors = 0U; // ID 0xC6 - Offline Uncorrectable Sector Count
     } sSmartData;
 
 private:
     void setTimestamp();
 
 protected:
-
 public:
-    Drive(string path)
+    // Copy constructor
+    Drive(const Drive &other);
+
+    // Copy assignment operator
+    Drive &operator=(const Drive &other);
+
+    // Move constructor
+    Drive(Drive &&other) noexcept;
+
+    // Move assignment operator
+    Drive &operator=(Drive &&other) noexcept;
+
+    Drive(std::string path)
     {
         this->sPath = path;
     }
 
-    string getPath(void);
+    std::string getPath(void);
-    string getModelFamily(void);
+    std::string getModelFamily(void);
-    string getModelName(void);
+    std::string getModelName(void);
-    string getSerial(void);
+    std::string getSerial(void);
-    uint64_t getCapacity(void); //in byte
+    uint64_t getCapacity(void); // in byte
     uint32_t getErrorCount(void);
-    uint32_t getPowerOnHours(void); //in hours
+    uint32_t getPowerOnHours(void); // in hours
     uint32_t getPowerCycles(void);
-    uint32_t getTemperature(void); //in Fahrenheit, just kidding: degree Celsius
+    uint32_t getTemperature(void); // in Fahrenheit, just kidding: degree Celsius
+    uint32_t getReallocatedSectors(void);
+    uint32_t getPendingSectors(void);
+    uint32_t getUncorrectableSectors(void);
     void checkFrozenDrive(void);
 
-    void setDriveSMARTData( string modelFamily,
+    void setDriveSMARTData(std::string modelFamily,
-                            string modelName,
+                           std::string modelName,
-                            string serial,
+                           std::string serial,
-                            uint64_t capacity,
+                           uint64_t capacity,
-                            uint32_t errorCount,
+                           uint32_t errorCount,
-                            uint32_t powerOnHours,
+                           uint32_t powerOnHours,
-                            uint32_t powerCycles,
+                           uint32_t powerCycles,
-                            uint32_t temperature);
+                           uint32_t temperature,
+                           uint32_t reallocatedSectors,
+                           uint32_t pendingSectors,
+                           uint32_t uncorrectableSectors);
 
-    string sCapacityToText();
+    std::string sCapacityToText();
-    string sErrorCountToText();
+    std::string sErrorCountToText();
-    string sPowerOnHoursToText();
+    std::string sPowerOnHoursToText();
-    string sPowerCyclesToText();
+    std::string sPowerCyclesToText();
-    string sTemperatureToText();
+    std::string sTemperatureToText();
 
     void setTaskPercentage(double d32TaskPercentage);
     double getTaskPercentage(void);
@@ -101,7 +140,6 @@ public:
 
     void calculateTaskDuration();
     time_t getTaskDuration();
-
 };
 
-#endif  // DRIVE_H_
+#endif // DRIVE_H_

include/logger/logger.h

@@ -16,6 +16,10 @@
 #include <sys/socket.h>
 #include <arpa/inet.h>
 #include <netinet/in.h>
+#include <ifaddrs.h>
+#include <netpacket/packet.h>
+#include <cstring>
+#include <string>
 #include <errno.h>
 #include <stdlib.h>
 #include <sys/ioctl.h>
@@ -28,26 +32,26 @@
 
 using namespace std;
 
-#define MENU_LINE_SIZE 110 //Size of menu lines
+#define MENU_LINE_SIZE 110 // Size of menu lines
 
 #ifndef LOG_PATH
-//#define LOG_PATH "./test.txt"
+// #define LOG_PATH "./test.txt"
 #endif
 
 #ifndef DESCRIPTION
-#define DESCRIPTION "Software-Name - Copyright Company 2020"        //use your values here
+#define DESCRIPTION "Software-Name - Copyright Company 2020" // use your values here
 #endif
 
 #ifndef DEVICE_ID
-#define DEVICE_ID  "Device-Name"                                    //use your values here
+#define DEVICE_ID "Device-Name" // use your values here
 #endif
 
 #ifndef SOFTWARE_VERSION
-#define SOFTWARE_VERSION  "0.1.1.8"                                 //use your values here
+#define SOFTWARE_VERSION "0.1.1.8" // use your values here
 #endif
 
 #ifndef HARDWARE_VERSION
-#define HARDWARE_VERSION  "7.77.9"                                  //use your values here
+#define HARDWARE_VERSION "7.77.9" // use your values here
 #endif
 
 class Logger
@@ -68,13 +72,12 @@ private:
     ~Logger();
 
 public:
-
     void info(string s);
     void warning(string s);
     void error(string s);
     void newLine();
 
-    static Logger* logThis();
+    static Logger *logThis();
 };
 
-#endif  // LOGGER_H_
+#endif // LOGGER_H_

include/printer.h

@@ -26,27 +26,25 @@ typedef struct
     char caDriveShredDuration[STR_BUFFER_SIZE];
     char caDriveCapacity[STR_BUFFER_SIZE];
     char caDriveState[STR_BUFFER_SIZE];
+    char caDriveConnectionType[STR_BUFFER_SIZE];
     char caDriveModelFamily[STR_BUFFER_SIZE];
     char caDriveModelName[STR_BUFFER_SIZE];
     char caDriveSerialnumber[STR_BUFFER_SIZE];
     char caDriveReHddVersion[STR_BUFFER_SIZE];
-
 } t_driveData;
 
 typedef struct
 {
-    long  msg_queue_type;
+    long msg_queue_type;
     t_driveData driveData;
 } t_msgQueueData;
 
-
 class Printer
 {
 protected:
-
 public:
-    static Printer* getPrinter();
+    static Printer *getPrinter();
-    void print(Drive* drive);
+    void print(Drive *drive);
 
 private:
     static bool instanceFlag;
@@ -54,7 +52,5 @@ private:
     int msqid;
     Printer();
     ~Printer();
-
-
 };
-#endif  // PRINTER_H_
+#endif // PRINTER_H_

include/reHDD.h

@@ -8,34 +8,34 @@
 #ifndef REHDD_H_
 #define REHDD_H_
 
-#define REHDD_VERSION "bV1.1.0"
+#define REHDD_VERSION "V1.4.0-dev"
 
 // Drive handling Settings
-#define WORSE_HOURS   19200 //mark drive if at this limit or beyond
+#define WORSE_HOURS 19200    // mark drive if at this limit or beyond
-#define WORSE_POWERUP 10000  //mark drive if at this limit or beyond
+#define WORSE_POWERUP 10000  // mark drive if at this limit or beyond
-#define WORSE_TEMPERATURE 55 //mark drive if at this limit or beyond
+#define WORSE_TEMPERATURE 55 // mark drive if at this limit or beyond
 #define SHRED_ITERATIONS 3U
-#define FROZEN_TIMEOUT 20 //After this timeout (minutes) the drive will be marked as frozen, if no progress
+#define FROZEN_TIMEOUT 20                           // After this timeout (minutes) the drive will be marked as frozen, if no progress
-#define METRIC_THRESHOLD 3L*1000L*1000L*1000L //calc shred speed with this minimum of time delta
+#define METRIC_THRESHOLD 3L * 1000L * 1000L * 1000L // calc shred speed with this minimum of time delta
 
 // Logger Settings
 #define LOG_PATH "./reHDD.log"
-#define DESCRIPTION "reHDD - Copyright Hendrik Schutter 2022"
+#define DESCRIPTION "reHDD - Copyright Hendrik Schutter 2026"
-#define DEVICE_ID  "generic"
+#define DEVICE_ID "generic"
-#define SOFTWARE_VERSION  "alpha"
+#define SOFTWARE_VERSION REHDD_VERSION
-#define HARDWARE_VERSION  "generic"
+#define HARDWARE_VERSION "generic"
 
-//#define LOG_LEVEL_HIGH  //log everything, like drive scan thread
+// #define LOG_LEVEL_HIGH // log everything, like drive scan thread
 #ifndef LOG_LEVEL_HIGH
-#define LOG_LEVEL_LOW   //log only user actions and tasks 
+#define LOG_LEVEL_LOW // log only user actions and tasks
 #endif
 
 // Logic
-//#define DRYRUN //don´t touch the drives
+// #define DRYRUN       // don't touch the drives
-#define FROZEN_ALERT //show alert if drive is frozen
+#define FROZEN_ALERT // show alert if drive is frozen
-#define ZERO_CHECK //check drive after shred if all bytes are zero, show alert if this fails
+#define ZERO_CHECK   // check drive after shred if all bytes are zero, show alert if this fails
 
-//IPC pipes
+// IPC pipes
 #define READ 0
 #define WRITE 1
 
@@ -56,9 +56,7 @@
 #include <sstream>
 #include <iomanip>
 #include <signal.h>
-
+#include <atomic>
-using namespace std;
-
 #include "drive.h"
 #include "smart.h"
 #include "shred.h"
@@ -67,9 +65,10 @@ using namespace std;
 #include "printer.h"
 #include "logger/logger.h"
 
-extern Logger* logging;
+extern Logger *logging;
 
-template <typename T, typename I> T* iterator_to_pointer(I i)
+template <typename T, typename I>
+T *iterator_to_pointer(I i)
 {
     return (&(*i));
 }
@@ -77,30 +76,33 @@ template <typename T, typename I> T* iterator_to_pointer(I i)
 class reHDD
 {
 protected:
-
 public:
     reHDD(void);
     static void app_logic();
 
 private:
-
+    static void searchDrives(list<Drive> *plistDrives);
-    static void searchDrives(list <Drive>* plistDrives);
+    static void printDrives(list<Drive> *plistDrives);
-    static void printDrives(list <Drive>* plistDrives);
+    static void startShredAllDrives(list<Drive> *plistDrives);
-    static void startShredAllDrives(list <Drive>* plistDrives);
+    static void stopShredAllDrives(list<Drive> *plistDrives);
-    static void updateShredMetrics(list <Drive>* plistDrives);
+    static void updateShredMetrics(list<Drive> *plistDrives);
-    static void filterIgnoredDrives(list <Drive>* plistDrives);
+    static void filterIgnoredDrives(list<Drive> *plistDrives);
-    static void filterNewDrives(list <Drive>* plistOldDrives, list <Drive>* plistNewDrives);
+    static void filterInvalidDrives(list<Drive> *plistDrives);
-    static void addSMARTData(list <Drive>* plistDrives);
+    static void filterNewDrives(list<Drive> *plistOldDrives, list<Drive> *plistNewDrives);
+    static void addSMARTData(list<Drive> *plistDrives);
+    static void printAllDrives(list<Drive> *plistDrives);
+    static void printDrive(Drive *const pDrive);
     static void ThreadScanDevices();
     static void ThreadUserInput();
-    static void ThreadShred(Drive* const pDrive);
+    static void ThreadShred(Drive *const pDrive);
-    static void ThreadDelete();
+    static void ThreadDelete(Drive *const pDrive);
     static void ThreadCheckFrozenDrives();
     static void handleArrowKey(TUI::UserInput userInput);
     static void handleEnter();
     static void handleESC();
     static void handleAbort();
-    static Drive* getSelectedDrive();
+    static Drive *getSelectedDrive();
+    static bool getSystemDrive(string &systemDrive);
 };
 
-#endif  // REHDD_H_
+#endif // REHDD_H_

include/shred.h

@@ -16,24 +16,40 @@
 #include <fcntl.h>
 #include <unistd.h>
 #include <string.h>
+#include <chrono>
 
+// Adaptive chunk size optimization - uncomment to enable
+#define ADAPTIVE_CHUNK_SIZE
 
-#define CHUNK_SIZE 1024*1024*32 //amount of bytes that are overwritten at once --> 32MB
+// Chunk size configuration
-#define TFNG_DATA_SIZE CHUNK_SIZE //amount of bytes used by tfng
+#define CHUNK_SIZE_START 1024 * 1024 * 32 // Starting chunk size: 32MB
+#define CHUNK_SIZE_MIN 1024 * 1024 * 4 // Minimum chunk size: 4MB
+#define CHUNK_SIZE_MAX 1024 * 1024 * 128 // Maximum chunk size: 128MB
+#define CHUNK_SIZE_STEP_UP 1024 * 1024 * 2 // Increase step: 2MB
+#define CHUNK_SIZE_STEP_DOWN 1024 * 1024 * 4 // Decrease step: 4MB
+#define CHUNK_MEASURE_INTERVAL 64 // Measure performance every 64 chunks
 
-//#define DEMO_DRIVE_SIZE 1024*1024*256L // 256MB
+#ifdef ADAPTIVE_CHUNK_SIZE
-//#define DEMO_DRIVE_SIZE 1024*1024*1024L // 1GB
+// Use max buffer size when adaptive mode is enabled
-//#define DEMO_DRIVE_SIZE 5*1024*1024*1024L // 5GB
+#define CHUNK_SIZE CHUNK_SIZE_MAX
-//#define DEMO_DRIVE_SIZE 1024*1024*1024*10L // 10GB
+#define TFNG_DATA_SIZE CHUNK_SIZE_MAX
+#else
+// Use fixed chunk size when adaptive mode is disabled
+#define CHUNK_SIZE CHUNK_SIZE_START
+#define TFNG_DATA_SIZE CHUNK_SIZE
+#endif
+
+// #define DEMO_DRIVE_SIZE 1024*1024*256L // 256MB
+// #define DEMO_DRIVE_SIZE 1024*1024*1024L // 1GB
+// #define DEMO_DRIVE_SIZE 5*1024*1024*1024L // 5GB
+// #define DEMO_DRIVE_SIZE 1024*1024*1024*10L // 10GB
 
 typedef int fileDescriptor;
 
 class Shred
 {
 protected:
-
 public:
-
     Shred();
     ~Shred();
     int shredDrive(Drive* drive, int* ipSignalFd);
@@ -41,19 +57,43 @@ public:
 private:
     fileDescriptor randomSrcFileDiscr;
     fileDescriptor driveFileDiscr;
+
+#ifdef ADAPTIVE_CHUNK_SIZE
+    unsigned char* caTfngData; // Dynamic buffer allocation for adaptive mode
+    unsigned char* caReadBuffer; // Dynamic buffer allocation for adaptive mode
+#else
     unsigned char caTfngData[TFNG_DATA_SIZE];
     unsigned char caReadBuffer[CHUNK_SIZE];
+#endif
+
     unsigned long ulDriveByteSize;
-    unsigned long ulDriveByteOverallCount = 0; //all bytes shredded in all iterations + checking -> used for progress calculation
+    unsigned long ulDriveByteOverallCount = 0; // all bytes shredded in all iterations + checking -> used for progress calculation
     double d32Percent = 0.0;
     double d32TmpPercent = 0.0;
 
+#ifdef ADAPTIVE_CHUNK_SIZE
+    // Adaptive chunk size optimization members
+    size_t currentChunkSize;
+    size_t bestChunkSize;
+    unsigned int chunkCounter;
+    std::chrono::high_resolution_clock::time_point measurementStartTime;
+    double bestThroughputMBps;
+    double lastThroughputMBps;
+    unsigned long bytesWrittenInMeasurement;
+    bool throughputIncreasing;
+
+    // Adaptive methods
+    void startMeasurement();
+    void evaluateThroughput(Drive* drive);
+    void adjustChunkSize(Drive* drive);
+    size_t getCurrentChunkSize() const;
+#endif
+
     inline double calcProgress();
     int iRewindDrive(fileDescriptor file);
-    unsigned long getDriveSizeInBytes(fileDescriptor file);
+    long getDriveSizeInBytes(fileDescriptor file);
     unsigned int uiCalcChecksum(fileDescriptor file, Drive* drive, int* ipSignalFd);
     void cleanup();
-
 };
 
-#endif  // SHRED_H_
+#endif // SHRED_H_

include/smart.h

@@ -10,33 +10,29 @@
 
 #include "reHDD.h"
 
+/**
+ * @brief SMART data reader for drives
+ *
+ * Parses smartctl JSON output to extract:
+ * - Device information (model, serial, capacity)
+ * - Power statistics (hours, cycles)
+ * - Temperature
+ * - Critical sector counts (reallocated, pending, uncorrectable)
+ *
+ * Uses deterministic state machine parser for reliable multi-line JSON parsing.
+ */
 class SMART
 {
 protected:
-
 public:
-    static void readSMARTData(Drive* drive);
+    /**
+     * @brief Read S.M.A.R.T. data from drive and populate Drive object
+     * @param drive Pointer to Drive instance to populate with SMART data
+     */
+    static void readSMARTData(Drive *drive);
 
 private:
-    SMART(void);
+    SMART(void); // Utility class - no instances
-
-    static void parseModelFamily(string sLine);
-    static void parseModelName(string sLine);
-    static void parseSerial(string sLine);
-    static void parseCapacity(string sLine);
-    static void parseErrorCount(string sLine);
-    static void parsePowerOnHours(string sLine);
-    static void parsePowerCycle(string sLine);
-    static void parseTemperature(string sLine);
-
-    static  string modelFamily;
-    static  string modelName;
-    static  string serial;
-    static  uint64_t capacity;
-    static  uint32_t errorCount;
-    static  uint32_t powerOnHours;
-    static  uint32_t powerCycle;
-    static  uint32_t temperature;
 };
 
-#endif  // SMART_H_
+#endif // SMART_H_

include/tui.h

@@ -20,10 +20,22 @@
 class TUI
 {
 protected:
-
 public:
-
+    enum UserInput
-    enum UserInput { UpKey, DownKey, Abort, Shred, ShredAll, Delete, Enter, ESC, Undefined};
+    {
+        UpKey,
+        DownKey,
+        Abort,
+        Shred,
+        ShredAll,
+        Delete,
+        Enter,
+        ESC,
+        Terminate,
+        Print,
+        PrintAll,
+        Undefined
+    };
     struct MenuState
     {
         bool bAbort;
@@ -37,37 +49,39 @@ public:
 
     static void initTUI();
 
-    void updateTUI(list <Drive>* plistDrives,  uint8_t u8SelectedEntry);
+    void updateTUI(std::list<Drive> *plistDrives, uint8_t u8SelectedEntry);
 
     static enum UserInput readUserInput();
 
+    static void terminateTUI();
+
 private:
-    static string sCpuUsage;
+    static std::string sCpuUsage;
-    static string sRamUsage;
+    static std::string sRamUsage;
-    static string sLocalTime;
+    static std::string sLocalTime;
 
-    WINDOW* overview;
+    WINDOW *overview;
-    WINDOW* systemview;
+    WINDOW *systemview;
-    WINDOW* detailview;
+    WINDOW *detailview;
-    WINDOW* menuview;
+    WINDOW *menuview;
-    WINDOW* dialog;
+    WINDOW *dialog;
-    WINDOW* smartWarning;
+    WINDOW *smartWarning;
 
-    static void centerTitle(WINDOW* pwin, const char* title);
+    static void centerTitle(WINDOW *pwin, const char *title);
-    static WINDOW *createOverViewWindow( int iXSize, int iYSize);
+    static WINDOW *createOverViewWindow(int iXSize, int iYSize);
-    static WINDOW *createDetailViewWindow( int iXSize, int iYSize, int iXStart, Drive drive);
+    static WINDOW *createDetailViewWindow(int iXSize, int iYSize, int iXStart, Drive &drive);
-    static WINDOW *overwriteDetailViewWindow( int iXSize, int iYSize, int iXStart);
+    static WINDOW *overwriteDetailViewWindow(int iXSize, int iYSize, int iXStart);
-    static WINDOW *createEntryWindow(int iXSize, int iYSize, int iXStart, int iYStart, int iListIndex, string sModelFamily, string sSerial, string sCapacity, string sState, string sTime, string sSpeed, string sTemp, bool bSelected);
+    static WINDOW *createEntryWindow(int iXSize, int iYSize, int iXStart, int iYStart, int iListIndex, std::string sModelFamily, std::string sSerial, std::string sCapacity, std::string sState, std::string sTime, std::string sSpeed, std::string sTemp, std::string sConnection, bool bSelected);
     static WINDOW *createSystemStats(int iXSize, int iYSize, int iXStart, int iYStart);
     static WINDOW *createMenuView(int iXSize, int iYSize, int iXStart, int iYStart, struct MenuState menustate);
-    static WINDOW *createDialog(int iXSize, int iYSize, int iXStart, int iYStart, string selectedTask, string optionA, string optionB);
+    static WINDOW *createDialog(int iXSize, int iYSize, int iXStart, int iYStart, std::string selectedTask, std::string optionA, std::string optionB);
-    static WINDOW* createFrozenWarning(int iXSize, int iYSize, int iXStart, int iYStart, string sPath, string sModelFamily, string sModelName, string sSerial, string sProgress);
+    static WINDOW *createFrozenWarning(int iXSize, int iYSize, int iXStart, int iYStart, std::string sPath, std::string sModelFamily, std::string sModelName, std::string sSerial, std::string sProgress);
-    static WINDOW* createSmartWarning(int iXSize, int iYSize, int iXStart, int iYStart, string sPath, uint32_t u32PowerOnHours, uint32_t u32PowerCycles,  uint32_t u32ErrorCount, uint32_t u32Temperature);
+    static WINDOW *createSmartWarning(int iXSize, int iYSize, int iXStart, int iYStart, std::string sPath, uint32_t u32PowerOnHours, uint32_t u32PowerCycles, uint32_t u32ErrorCount, uint32_t u32Temperature, uint32_t u32ReallocatedSectors, uint32_t u32PendingSectors, uint32_t u32UncorrectableSectors);
-    static WINDOW* createZeroChecksumWarning(int iXSize, int iYSize, int iXStart, int iYStart, string sPath, string sModelFamily, string sModelName, string sSerial, uint32_t u32Checksum);
+    static WINDOW *createZeroChecksumWarning(int iXSize, int iYSize, int iXStart, int iYStart, std::string sPath, std::string sModelFamily, std::string sModelName, std::string sSerial, uint32_t u32Checksum);
 
-    void displaySelectedDrive(Drive drive, int stdscrX, int stdscrY);
+    void displaySelectedDrive(Drive &drive, int stdscrX, int stdscrY);
-    string formatTimeDuration(time_t u32Duration);
+    std::string formatTimeDuration(time_t u32Duration);
-    string formatSpeed(time_t u32ShredTimeDelta, unsigned long ulWrittenBytes);
+    std::string formatSpeed(time_t u32ShredTimeDelta, unsigned long ulWrittenBytes);
-    static void vTruncateText(string* psText, uint16_t u16MaxLenght);
+    static void vTruncateText(std::string *psText, uint16_t u16MaxLenght);
 };
-#endif  // TUI_H_
+#endif // TUI_H_

makefile

@@ -10,15 +10,15 @@ SRC_PATH = src
 # Space-separated pkg-config libraries used by this project
 LIBS = lib
 # General compiler flags
-COMPILE_FLAGS = -std=c++17 -Wall -Wextra -g
+COMPILE_FLAGS = -std=c++23 -Wall -Wextra -g
 # Additional release-specific flags
-RCOMPILE_FLAGS = -D NDEBUG -O3
+RCOMPILE_FLAGS = -D NDEBUG -Ofast
 # Additional debug-specific flags
 DCOMPILE_FLAGS = -D DEBUG
 # Add additional include paths
 INCLUDES = include
 # General linker settings
-LINK_FLAGS = -Llib -lpthread -lncurses -ltfng
+LINK_FLAGS = -Llib -lpthread -lncurses -ltfng -latomic
 
 # Doc
 DOCDIR = doc

src/delete.cpp

@@ -6,17 +6,18 @@
  */
 
 #include "../include/reHDD.h"
+using namespace std;
 
 /**
  * \brief   delete drive with wipefs
  * \param	pointer of Drive instance
  * \return  void
  */
-void Delete::deleteDrive(Drive* drive)
+void Delete::deleteDrive(Drive *drive)
 
 {
-    size_t len = 0; //lenght of found line
+    size_t len = 0;     // lenght of found line
-    char* cLine = NULL; //found line
+    char *cLine = NULL; // found line
 
 #ifndef DRYRUN
     string sCMD = ("wipefs -af ");
@@ -25,18 +26,24 @@ void Delete::deleteDrive(Drive* drive)
 #endif
 
 #ifdef DRYRUN
-    //cout << "dryrun for " << drive->getPath() << endl;
+    // cout << "dryrun for " << drive->getPath() << endl;
     string sCMD = ("echo");
 #endif
 
-    const char* cpComand = sCMD.c_str();
+    const char *cpComand = sCMD.c_str();
-    //cout << "delete: " << cpComand << endl;
+    // cout << "delete: " << cpComand << endl;
 
-    FILE* deleteCmdOutput = popen(cpComand, "r");
+    if (drive->bWasShredStarted == false)
+    {
+        // only start delete if the drive was not shredded before
+        FILE *deleteCmdOutput = popen(cpComand, "r");
 
-    while ((getline(&cLine, &len, deleteCmdOutput)) != -1)
+        while ((getline(&cLine, &len, deleteCmdOutput)) != -1)
         {
-            //wipefs running
+            // wipefs running
         }
-    pclose(deleteCmdOutput);
+
+        free(cLine);
+        pclose(deleteCmdOutput);
+    }
 }

src/drive.cpp

@@ -6,6 +6,95 @@
  */
 
 #include "../include/reHDD.h"
+using namespace std;
+
+// Copy constructor
+Drive::Drive(const Drive &other)
+    : state(other.state.load()),
+      connectionType(other.connectionType.load()),
+      sShredSpeed(other.sShredSpeed.load()),
+      bWasShredded(other.bWasShredded),
+      bWasShredStarted(other.bWasShredStarted),
+      bWasChecked(other.bWasChecked),
+      bWasDeleted(other.bWasDeleted),
+      bIsOffline(other.bIsOffline),
+      u32DriveChecksumAfterShredding(other.u32DriveChecksumAfterShredding),
+      sPath(other.sPath),
+      u32Timestamp(other.u32Timestamp),
+      d32TaskPercentage(other.d32TaskPercentage),
+      u32TimestampTaskStart(other.u32TimestampTaskStart),
+      u32TaskDuration(other.u32TaskDuration),
+      sSmartData(other.sSmartData)
+{
+}
+
+// Copy assignment operator
+Drive &Drive::operator=(const Drive &other)
+{
+    if (this != &other)
+    {
+        state = other.state.load();
+        connectionType = other.connectionType.load();
+        sShredSpeed = other.sShredSpeed.load();
+        bWasShredded = other.bWasShredded;
+        bWasShredStarted = other.bWasShredStarted;
+        bWasChecked = other.bWasChecked;
+        bWasDeleted = other.bWasDeleted;
+        bIsOffline = other.bIsOffline;
+        u32DriveChecksumAfterShredding = other.u32DriveChecksumAfterShredding;
+        sPath = other.sPath;
+        u32Timestamp = other.u32Timestamp;
+        d32TaskPercentage = other.d32TaskPercentage;
+        u32TimestampTaskStart = other.u32TimestampTaskStart;
+        u32TaskDuration = other.u32TaskDuration;
+        sSmartData = other.sSmartData;
+    }
+    return *this;
+}
+
+// Move constructor
+Drive::Drive(Drive &&other) noexcept
+    : state(other.state.load()),
+      connectionType(other.connectionType.load()),
+      sShredSpeed(other.sShredSpeed.load()),
+      bWasShredded(other.bWasShredded),
+      bWasShredStarted(other.bWasShredStarted),
+      bWasChecked(other.bWasChecked),
+      bWasDeleted(other.bWasDeleted),
+      bIsOffline(other.bIsOffline),
+      u32DriveChecksumAfterShredding(other.u32DriveChecksumAfterShredding),
+      sPath(std::move(other.sPath)),
+      u32Timestamp(other.u32Timestamp),
+      d32TaskPercentage(other.d32TaskPercentage),
+      u32TimestampTaskStart(other.u32TimestampTaskStart),
+      u32TaskDuration(other.u32TaskDuration),
+      sSmartData(std::move(other.sSmartData))
+{
+}
+
+// Move assignment operator
+Drive &Drive::operator=(Drive &&other) noexcept
+{
+    if (this != &other)
+    {
+        state = other.state.load();
+        connectionType = other.connectionType.load();
+        sShredSpeed = other.sShredSpeed.load();
+        bWasShredded = other.bWasShredded;
+        bWasShredStarted = other.bWasShredStarted;
+        bWasChecked = other.bWasChecked;
+        bWasDeleted = other.bWasDeleted;
+        bIsOffline = other.bIsOffline;
+        u32DriveChecksumAfterShredding = other.u32DriveChecksumAfterShredding;
+        sPath = std::move(other.sPath);
+        u32Timestamp = other.u32Timestamp;
+        d32TaskPercentage = other.d32TaskPercentage;
+        u32TimestampTaskStart = other.u32TimestampTaskStart;
+        u32TaskDuration = other.u32TaskDuration;
+        sSmartData = std::move(other.sSmartData);
+    }
+    return *this;
+}
 
 string Drive::getPath(void)
 {
@@ -51,19 +140,38 @@ uint32_t Drive::getTemperature(void)
     return sSmartData.u32Temperature;
 }
 
+uint32_t Drive::getReallocatedSectors(void)
+{
+    return sSmartData.u32ReallocatedSectors;
+}
+
+uint32_t Drive::getPendingSectors(void)
+{
+    return sSmartData.u32PendingSectors;
+}
+
+uint32_t Drive::getUncorrectableSectors(void)
+{
+    return sSmartData.u32UncorrectableSectors;
+}
+
 string Drive::sCapacityToText()
 {
     char acBuffer[16];
-    double dSize = (double) getCapacity();
+    double dSize = (double)getCapacity();
     uint16_t u16UnitIndex = 0;
-    const char* units[] = {"B", "kB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"};
+    const char *units[] = {"B", "kB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"};
-    while (dSize >= 1000)   //using the marketing capacity
+    while (dSize >= 1000) // using the marketing capacity
-        {
+    {
-            dSize /= 1000;
+        dSize /= 1000;
-            u16UnitIndex++;
+        u16UnitIndex++;
-        }
+    }
-
+    if (u16UnitIndex >= 9)
-    sprintf(acBuffer, "%.*f %s", u16UnitIndex-3, dSize, units[u16UnitIndex]);
+    {
+        u16UnitIndex = 8;
+    }
+    int precision = (u16UnitIndex >= 3) ? (u16UnitIndex - 3) : 0;
+    sprintf(acBuffer, "%.*f %s", precision, dSize, units[u16UnitIndex]);
     return acBuffer;
 }
 
@@ -80,8 +188,8 @@ string Drive::sPowerOnHoursToText()
     stringstream streamDays;
     stringstream streamYears;
 
-    dDays = (double) ((double)u32Hours/(double)24U);
+    dDays = (double)((double)u32Hours / (double)24U);
-    dYears = (double) ((double)u32Hours/(double)8760U);
+    dYears = (double)((double)u32Hours / (double)8760U);
 
     streamDays << fixed << setprecision(0) << dDays;
     streamYears << fixed << setprecision(1) << dYears;
@@ -98,23 +206,22 @@ string Drive::sPowerCyclesToText()
 
 string Drive::sTemperatureToText()
 {
-    return to_string(getTemperature())+" C";;
+    return to_string(getTemperature()) + " C";
 }
 
 void Drive::setTaskPercentage(double d32TaskPercentage)
 {
-    if(d32TaskPercentage <= 100)
+    if (d32TaskPercentage <= 100)
-        {
+    {
-            this->d32TaskPercentage = d32TaskPercentage;
+        this->d32TaskPercentage = d32TaskPercentage;
-            this->setTimestamp(); //set timestamp for this progress for detecting a frozen drive
+        this->setTimestamp(); // set timestamp for this progress for detecting a frozen drive
-        }
+    }
 }
 double Drive::getTaskPercentage(void)
 {
     return this->d32TaskPercentage;
 }
 
-
 /**
  * \brief   set S.M.A.R.T. values in model
  * \param	string modelFamily
@@ -127,14 +234,17 @@ double Drive::getTaskPercentage(void)
  * \param   uint32_t temperature
  * \return  void
  */
-void Drive::setDriveSMARTData( string modelFamily,
+void Drive::setDriveSMARTData(string modelFamily,
-                               string modelName,
+                              string modelName,
-                               string serial,
+                              string serial,
-                               uint64_t capacity,
+                              uint64_t capacity,
-                               uint32_t errorCount,
+                              uint32_t errorCount,
-                               uint32_t powerOnHours,
+                              uint32_t powerOnHours,
-                               uint32_t powerCycle,
+                              uint32_t powerCycle,
-                               uint32_t temperature)
+                              uint32_t temperature,
+                              uint32_t reallocatedSectors,
+                              uint32_t pendingSectors,
+                              uint32_t uncorrectableSectors)
 {
     this->sSmartData.sModelFamily = modelFamily;
     this->sSmartData.sModelName = modelName;
@@ -144,16 +254,27 @@ void Drive::setDriveSMARTData( string modelFamily,
     this->sSmartData.u32PowerOnHours = powerOnHours;
     this->sSmartData.u32PowerCycles = powerCycle;
     this->sSmartData.u32Temperature = temperature;
+    this->sSmartData.u32ReallocatedSectors = reallocatedSectors;
+    this->sSmartData.u32PendingSectors = pendingSectors;
+    this->sSmartData.u32UncorrectableSectors = uncorrectableSectors;
 }
 
 void Drive::setTimestamp()
 {
-    time(&this->u32Timestamp);
+    if (time(&this->u32Timestamp) == -1)
+    {
+        // handle error
+        this->u32Timestamp = 0U;
+    }
 }
 
 void Drive::setActionStartTimestamp()
 {
-    time(&this->u32TimestampTaskStart);
+    if (time(&this->u32TimestampTaskStart) == -1)
+    {
+        // handle error
+        this->u32TimestampTaskStart = 0U;
+    }
 }
 
 time_t Drive::getActionStartTimestamp()
@@ -164,7 +285,11 @@ time_t Drive::getActionStartTimestamp()
 void Drive::calculateTaskDuration()
 {
     time_t u32localtime;
-    time(&u32localtime);
+    if (time(&u32localtime) == -1)
+    {
+        // handle error
+        u32localtime = 0U;
+    }
 
     this->u32TaskDuration = u32localtime - this->u32TimestampTaskStart;
 }
@@ -178,12 +303,17 @@ void Drive::checkFrozenDrive(void)
 {
     time_t u32localtime;
     time(&u32localtime);
+    if (time(&u32localtime) == -1)
+    {
+        // handle error
+        u32localtime = 0U;
+    }
 
-    if((u32localtime - this->u32Timestamp) >= (FROZEN_TIMEOUT*60) && (this->u32Timestamp > 0) && (this->getTaskPercentage() < 100.0))
+    if ((u32localtime - this->u32Timestamp) >= (FROZEN_TIMEOUT * 60) && (this->u32Timestamp > 0) && (this->getTaskPercentage() < 100.0))
-        {
+    {
-            Logger::logThis()->warning("Drive Frozen: " + this->getModelName() + " " + this->getSerial());
+        Logger::logThis()->warning("Drive Frozen: " + this->getModelName() + " " + this->getSerial());
-            this->bWasDeleted = false;
+        this->bWasDeleted = false;
-            this->bWasShredded = false;
+        this->bWasShredded = false;
-            this->state = Drive::FROZEN;
+        this->state = Drive::TaskState::FROZEN;
-        }
+    }
 }

src/logger/logger.cpp

@@ -5,16 +5,15 @@
  * @date    04.09.2020
  */
 
-
 #include "../../include/reHDD.h" //for logger settings
 #include "../../include/logger/logger.h"
 
 using namespace std;
 
-string version =  "0.2.1"; //logger version
+string version = "0.2.1"; // logger version
 
 bool Logger::instanceFlag = false;
-Logger* Logger::single = NULL;
+Logger *Logger::single = NULL;
 
 /**
  * \brief   create new logger instance
@@ -95,13 +94,13 @@ void Logger::error(string s)
 void Logger::writeLog(string s)
 {
     ofstream logFile;
-    Logger::mtxLog.lock(); //lock this section for other threads
+    Logger::mtxLog.lock(); // lock this section for other threads
     logFile.open(this->logPath, ios_base::app);
 
-    logFile << (s + "\n"); //append to existing file
+    logFile << (s + "\n"); // append to existing file
 
     logFile.close();
-    Logger::mtxLog.unlock(); //unlock this section for other threads
+    Logger::mtxLog.unlock(); // unlock this section for other threads
 }
 
 /**
@@ -120,22 +119,22 @@ void Logger::newLine()
  */
 string Logger::getTimestamp()
 {
-    struct tm * timeinfo;
+    struct tm *timeinfo;
     struct timeval tv;
     int millisec;
-    char cpDate [80];
+    char cpDate[80];
-    char buffer [120];
+    char buffer[120];
 
     gettimeofday(&tv, NULL);
-    millisec = lrint(tv.tv_usec/1000.0); // Round to nearest millisec
+    millisec = lrint(tv.tv_usec / 1000.0); // Round to nearest millisec
-    if (millisec>=1000)   // Allow for rounding up to nearest second
+    if (millisec >= 1000)                  // Allow for rounding up to nearest second
-        {
+    {
-            millisec -=1000;
+        millisec -= 1000;
-            tv.tv_sec++;
+        tv.tv_sec++;
-        }
+    }
     timeinfo = localtime(&tv.tv_sec);
-    strftime (cpDate,80,"%d/%m/%Y %T",timeinfo);
+    strftime(cpDate, 80, "%d/%m/%Y %T", timeinfo);
-    sprintf(buffer, "%s.%03d", cpDate, millisec);
+    snprintf(buffer, sizeof(buffer), "%s.%03d", cpDate, millisec);
     return buffer;
 }
 
@@ -144,25 +143,44 @@ string Logger::getTimestamp()
  * \param	void
  * \return  string MAC address (formatted)
  */
-string Logger::getMacAddress()
+std::string Logger::getMacAddress()
 {
-    struct ifreq ifr;
+    struct ifaddrs *ifaddr, *ifa;
-    int s = socket(AF_INET, SOCK_STREAM,0);
 
-    strcpy(ifr.ifr_name, "eth0");
+    // default MAC if none found
-    if (ioctl(s, SIOCGIFHWADDR, &ifr) < 0)
+    std::string result = "00:00:00:00:00:00";
+
+    if (getifaddrs(&ifaddr) == -1)
+        return result;
+
+    for (ifa = ifaddr; ifa != nullptr; ifa = ifa->ifa_next)
+    {
+        if (!ifa->ifa_addr)
+            continue;
+
+        // We want AF_PACKET interfaces (Ethernet)
+        if (ifa->ifa_addr->sa_family == AF_PACKET &&
+            !(ifa->ifa_flags & IFF_LOOPBACK) && // skip loopback interface
+            (ifa->ifa_flags & IFF_UP))          // must be up
         {
-            strcpy(ifr.ifr_name, "eno1");
+            struct sockaddr_ll *s = (struct sockaddr_ll *)ifa->ifa_addr;
 
+            if (s->sll_halen == 6)
+            {
+                char buf[32];
+                snprintf(buf, sizeof(buf),
+                         "%02X:%02X:%02X:%02X:%02X:%02X",
+                         s->sll_addr[0], s->sll_addr[1], s->sll_addr[2],
+                         s->sll_addr[3], s->sll_addr[4], s->sll_addr[5]);
+
+                freeifaddrs(ifaddr);
+                return std::string(buf);
+            }
         }
+    }
 
-    unsigned char *hwaddr = (unsigned char *)ifr.ifr_hwaddr.sa_data;
+    freeifaddrs(ifaddr);
-    char buffer [80];
+    return result;
-    sprintf(buffer,"%02X:%02X:%02X:%02X:%02X:%02X", hwaddr[0], hwaddr[1], hwaddr[2],
-            hwaddr[3], hwaddr[4], hwaddr[5]);
-    close(s);
-    string tmp = buffer;
-    return tmp;
 }
 
 /**
@@ -174,22 +192,22 @@ string Logger::getMacAddress()
  */
 string Logger::padStringMenu(char cBorder, string text, uint8_t u8LineLenght)
 {
-    string result(1,cBorder);
+    string result(1, cBorder);
     uint8_t u8TextSize = text.length();
-    uint8_t u8Padding = ((u8LineLenght-u8TextSize)/2);
+    uint8_t u8Padding = ((u8LineLenght - u8TextSize) / 2);
 
-    for(uint8_t i = 0 ; i < u8Padding; i++)
+    for (uint8_t i = 0; i < u8Padding; i++)
-        {
+    {
-            result.append(" ");
+        result.append(" ");
-        }
+    }
 
     result.append(text);
 
-    while((uint8_t)result.length() < (u8LineLenght-1))
+    while ((uint8_t)result.length() < (u8LineLenght - 1))
-        {
+    {
 
-            result.append(" ");
+        result.append(" ");
-        }
+    }
 
     result.append(string(1, cBorder));
     return result;
@@ -203,12 +221,12 @@ string Logger::padStringMenu(char cBorder, string text, uint8_t u8LineLenght)
  */
 string Logger::menuLine(char cBorder, uint8_t u8LineLenght)
 {
-    string result(1,cBorder);
+    string result(1, cBorder);
 
-    while((uint8_t)result.length() < u8LineLenght)
+    while ((uint8_t)result.length() < u8LineLenght)
-        {
+    {
-            result.append(string(1, cBorder));
+        result.append(string(1, cBorder));
-        }
+    }
     return result;
 }
 
@@ -216,18 +234,16 @@ string Logger::menuLine(char cBorder, uint8_t u8LineLenght)
  * \brief   return a instance of the logger
  * \return  logger obj
  */
-Logger* Logger::logThis()
+Logger *Logger::logThis()
 {
     if (!instanceFlag)
-        {
+    {
-            single = new Logger(); //create new obj
+        single = new Logger(); // create new obj
-            instanceFlag = true;
+        instanceFlag = true;
-            return single;
+        return single;
-        }
+    }
     else
-        {
+    {
-            return single; //return existing obj
+        return single; // return existing obj
-        }
+    }
 }
-
-

src/main.cpp

@@ -6,6 +6,7 @@
  */
 
 #include "../include/reHDD.h"
+using namespace std;
 
 /**
  * \brief   app entry point
@@ -16,7 +17,7 @@ int main(void)
 {
     // cout << "refurbishingHddTool" << endl;
 
-    reHDD* app = new reHDD();
+    reHDD app;
-    app->app_logic();
+    app.app_logic();
     return EXIT_SUCCESS;
 }

src/printer.cpp

@@ -8,7 +8,7 @@
 #include "../include/reHDD.h"
 
 bool Printer::instanceFlag = false;
-Printer* Printer::single = NULL;
+Printer *Printer::single = NULL;
 
 /**
  * \brief   create new Printer instance
@@ -19,9 +19,9 @@ Printer* Printer::single = NULL;
 Printer::Printer()
 {
     if (-1 == (this->msqid = msgget((key_t)IPC_MSG_QUEUE_KEY, IPC_CREAT | 0666)))
-        {
+    {
-            Logger::logThis()->error("Printer: Create mgs queue failed!");
+        Logger::logThis()->error("Printer: Create mgs queue failed!");
-        }
+    }
 }
 
 /**
@@ -37,47 +37,65 @@ Printer::~Printer()
  * \brief   send data to msg queue
  * \return  void
  */
-void Printer::print(Drive* drive)
+void Printer::print(Drive *drive)
 {
-    t_msgQueueData   msgQueueData;
+    t_msgQueueData msgQueueData;
     msgQueueData.msg_queue_type = 1;
 
-    sprintf(msgQueueData.driveData.caDriveIndex, "%i",42); //TODO: get from tui
+    snprintf(msgQueueData.driveData.caDriveIndex, STR_BUFFER_SIZE, "%i", drive->u16DriveIndex);
-    sprintf(msgQueueData.driveData.caDriveState, "shredded");
+    snprintf(msgQueueData.driveData.caDriveState, STR_BUFFER_SIZE, "shredded");
-    strcpy(msgQueueData.driveData.caDriveModelFamily, drive->getModelFamily().c_str());
+    snprintf(msgQueueData.driveData.caDriveModelFamily, STR_BUFFER_SIZE, "%s", drive->getModelFamily().c_str());
-    strcpy(msgQueueData.driveData.caDriveModelName, drive->getModelName().c_str());
+    snprintf(msgQueueData.driveData.caDriveModelName, STR_BUFFER_SIZE, "%s", drive->getModelName().c_str());
-    sprintf(msgQueueData.driveData.caDriveCapacity, "%li", drive->getCapacity());
+    snprintf(msgQueueData.driveData.caDriveCapacity, STR_BUFFER_SIZE, "%li", drive->getCapacity());
-    strcpy(msgQueueData.driveData.caDriveSerialnumber, drive->getSerial().c_str());
+    snprintf(msgQueueData.driveData.caDriveSerialnumber, STR_BUFFER_SIZE, "%s", drive->getSerial().c_str());
-    sprintf(msgQueueData.driveData.caDriveHours, "%i",drive->getPowerOnHours());
+    snprintf(msgQueueData.driveData.caDriveHours, STR_BUFFER_SIZE, "%i", drive->getPowerOnHours());
-    sprintf(msgQueueData.driveData.caDriveCycles, "%i",drive->getPowerCycles());
+    snprintf(msgQueueData.driveData.caDriveCycles, STR_BUFFER_SIZE, "%i", drive->getPowerCycles());
-    sprintf(msgQueueData.driveData.caDriveErrors, "%i",drive->getErrorCount());
+    snprintf(msgQueueData.driveData.caDriveErrors, STR_BUFFER_SIZE, "%i", drive->getErrorCount());
-    sprintf(msgQueueData.driveData.caDriveShredTimestamp, "%li",drive->getActionStartTimestamp());
+    snprintf(msgQueueData.driveData.caDriveShredTimestamp, STR_BUFFER_SIZE, "%li", drive->getActionStartTimestamp());
-    sprintf(msgQueueData.driveData.caDriveShredDuration, "%li",drive->getTaskDuration());
+    snprintf(msgQueueData.driveData.caDriveShredDuration, STR_BUFFER_SIZE, "%li", drive->getTaskDuration());
-    sprintf(msgQueueData.driveData.caDriveReHddVersion, REHDD_VERSION);
+
+    switch (drive->connectionType)
+    {
+    case Drive::ConnectionType::USB:
+        strncpy(msgQueueData.driveData.caDriveConnectionType, "usb", STR_BUFFER_SIZE);
+        break;
+    case Drive::ConnectionType::SATA:
+        strncpy(msgQueueData.driveData.caDriveConnectionType, "sata", STR_BUFFER_SIZE);
+        break;
+    case Drive::ConnectionType::NVME:
+        strncpy(msgQueueData.driveData.caDriveConnectionType, "nvme", STR_BUFFER_SIZE);
+        break;
+    case Drive::ConnectionType::UNKNOWN:
+    default:
+        strncpy(msgQueueData.driveData.caDriveConnectionType, "na", STR_BUFFER_SIZE);
+    }
+
+    snprintf(msgQueueData.driveData.caDriveReHddVersion, STR_BUFFER_SIZE, "%s", REHDD_VERSION);
 
     if (-1 == msgsnd(this->msqid, &msgQueueData, sizeof(t_msgQueueData) - sizeof(long), 0))
-        {
+    {
-            Logger::logThis()->error("Printer: Send mgs queue failed!");
+        Logger::logThis()->error("Printer: Send mgs queue failed!");
-        }else{
+    }
-            Logger::logThis()->info("Printer: print triggered - Drive: " + drive->getSerial());
+    else
-        }
+    {
+        Logger::logThis()->info("Printer: print triggered - Drive: " + drive->getSerial());
+    }
 }
 
-
 /**
  * \brief   return a instance of the printer
  * \return  printer obj
  */
-Printer* Printer::getPrinter()
+Printer *Printer::getPrinter()
 {
     if (!instanceFlag)
-        {
+    {
-            single = new Printer(); //create new obj
+        single = new Printer(); // create new obj
-            instanceFlag = true;
+        instanceFlag = true;
-            return single;
+        return single;
-        }
+    }
     else
-        {
+    {
-            return single; //return existing obj
+        return single; // return existing obj
-        }
+    }
 }

src/shred.cpp

@@ -6,211 +6,558 @@
  */
 
 #include "../include/reHDD.h"
+using namespace std;
 
 #ifdef __cplusplus
-extern "C" {
+extern "C"
+{
 #endif
 #include "../tfnoisegen/tfprng.h"
 #ifdef __cplusplus
 }
 #endif
 
-const static char *randomsrc = (char*) "/dev/urandom";
+const static char *randomsrc = (char *)"/dev/urandom";
 
 Shred::Shred()
 {
+#ifdef ADAPTIVE_CHUNK_SIZE
+    // Allocate aligned buffers for maximum chunk size
+    if (posix_memalign((void **)&caTfngData, 4096, CHUNK_SIZE_MAX) != 0)
+    {
+        Logger::logThis()->error("Failed to allocate aligned buffer for tfng data");
+        caTfngData = nullptr;
+    }
+
+    if (posix_memalign((void **)&caReadBuffer, 4096, CHUNK_SIZE_MAX) != 0)
+    {
+        Logger::logThis()->error("Failed to allocate aligned buffer for read buffer");
+        caReadBuffer = nullptr;
+    }
+
+    // Initialize adaptive tracking variables
+    currentChunkSize = CHUNK_SIZE_START;
+    bestChunkSize = CHUNK_SIZE_START;
+    chunkCounter = 0;
+    bestThroughputMBps = 0.0;
+    lastThroughputMBps = 0.0;
+    bytesWrittenInMeasurement = 0;
+    throughputIncreasing = true;
+
+    Logger::logThis()->info("Adaptive chunk size optimization ENABLED - Starting with " +
+                            to_string(currentChunkSize / (1024 * 1024)) + " MB chunks");
+#endif
 }
 
 Shred::~Shred()
 {
+#ifdef ADAPTIVE_CHUNK_SIZE
+    if (caTfngData != nullptr)
+    {
+        free(caTfngData);
+        caTfngData = nullptr;
+    }
+    if (caReadBuffer != nullptr)
+    {
+        free(caReadBuffer);
+        caReadBuffer = nullptr;
+    }
+#endif
+}
+
+#ifdef ADAPTIVE_CHUNK_SIZE
+/**
+ * \brief   Start performance measurement interval
+ * \return  void
+ */
+void Shred::startMeasurement()
+{
+    measurementStartTime = std::chrono::high_resolution_clock::now();
+    bytesWrittenInMeasurement = 0;
+    chunkCounter = 0;
 }
 
 /**
  * \brief   shred drive with shred
- * \param	pointer of Drive instance
+ * \param   pointer of Drive instance
+ * \param   file descriptor for signaling
+ * \return  0 on success, -1 on error
+ */
+void Shred::evaluateThroughput(Drive *drive)
+{
+    auto measurementEndTime = std::chrono::high_resolution_clock::now();
+    std::chrono::duration<double> elapsed = measurementEndTime - measurementStartTime;
+    double elapsedSeconds = elapsed.count();
+
+    if (elapsedSeconds > 0.0)
+    {
+        double throughputMBps = (bytesWrittenInMeasurement / (1024.0 * 1024.0)) / elapsedSeconds;
+        lastThroughputMBps = throughputMBps;
+
+        Logger::logThis()->info("Throughput measurement - ChunkSize: " +
+                                to_string(currentChunkSize / (1024 * 1024)) + " MB, " +
+                                "Throughput: " + to_string((int)throughputMBps) + " MB/s, " +
+                                "Best: " + to_string((int)bestThroughputMBps) + " MB/s" +
+                                " - Drive: " + drive->getSerial());
+
+        // Check if this is better than our best
+        if (throughputMBps > bestThroughputMBps)
+        {
+            bestThroughputMBps = throughputMBps;
+            bestChunkSize = currentChunkSize;
+            throughputIncreasing = true;
+
+            Logger::logThis()->info("NEW BEST throughput: " + to_string((int)bestThroughputMBps) +
+                                    " MB/s with " + to_string(currentChunkSize / (1024 * 1024)) +
+                                    " MB chunks - Drive: " + drive->getSerial());
+        }
+        else
+        {
+            throughputIncreasing = false;
+        }
+    }
+
+    // Adjust chunk size for next measurement interval
+    adjustChunkSize(drive);
+
+    // Start new measurement
+    startMeasurement();
+}
+
+/**
+ * \brief   Adjust chunk size based on throughput trend
+ * \param   pointer to Drive instance
  * \return  void
  */
-int Shred::shredDrive(Drive* drive, int* ipSignalFd)
+void Shred::adjustChunkSize(Drive *drive)
+{
+    size_t oldChunkSize = currentChunkSize;
+
+    if (throughputIncreasing)
+    {
+        // Throughput is improving - increase chunk size
+        currentChunkSize += CHUNK_SIZE_STEP_UP;
+
+        // Clamp to maximum
+        if (currentChunkSize > CHUNK_SIZE_MAX)
+        {
+            currentChunkSize = CHUNK_SIZE_MAX;
+            Logger::logThis()->info("Reached maximum chunk size: " +
+                                    to_string(currentChunkSize / (1024 * 1024)) + " MB" +
+                                    " - Drive: " + drive->getSerial());
+        }
+    }
+    else
+    {
+        // Throughput decreased - decrease chunk size to find sweet spot
+        if (currentChunkSize > CHUNK_SIZE_STEP_DOWN)
+        {
+            currentChunkSize -= CHUNK_SIZE_STEP_DOWN;
+        }
+
+        // Clamp to minimum
+        if (currentChunkSize < CHUNK_SIZE_MIN)
+        {
+            currentChunkSize = CHUNK_SIZE_MIN;
+            Logger::logThis()->info("Reached minimum chunk size: " +
+                                    to_string(currentChunkSize / (1024 * 1024)) + " MB" +
+                                    " - Drive: " + drive->getSerial());
+        }
+    }
+
+    if (oldChunkSize != currentChunkSize)
+    {
+        Logger::logThis()->info("Adjusted chunk size: " +
+                                to_string(oldChunkSize / (1024 * 1024)) + " MB -> " +
+                                to_string(currentChunkSize / (1024 * 1024)) + " MB" +
+                                " - Drive: " + drive->getSerial());
+    }
+}
+
+/**
+ * \brief   Get current chunk size for adaptive mode
+ * \return  current chunk size in bytes
+ */
+size_t Shred::getCurrentChunkSize() const
+{
+    return currentChunkSize;
+}
+#endif
+
+/**
+ * \brief   shred drive with shred
+ * \param   pointer of Drive instance
+ * \param   file descriptor for signaling
+ * \return  0 on success, -1 on error
+ */
+int Shred::shredDrive(Drive *drive, int *ipSignalFd)
 {
     ostringstream address;
     address << (void const *)&(*drive);
     Logger::logThis()->info("Shred-Task started - Drive: " + drive->getModelName() + "-" + drive->getSerial() + " @" + address.str());
 
+    // Mark as started but NOT shredded yet
+    drive->bWasShredStarted = true;
+    drive->bWasShredded = false;
+    drive->bWasChecked = false;
+    drive->setTaskPercentage(0.0);
+    drive->u32DriveChecksumAfterShredding = UINT32_MAX;
+    drive->state = Drive::TaskState::SHRED_ACTIVE;
+
 #ifdef DRYRUN
-    for(int i = 0; i<=500; i++)
+    for (int i = 0; i <= 100; i++)
+    {
+        if (drive->state.load() != Drive::TaskState::SHRED_ACTIVE)
         {
-            if(drive->state != Drive::SHRED_ACTIVE)
+            Logger::logThis()->info("Shred-Task aborted during DRYRUN - Drive: " + drive->getSerial());
-                {
+            drive->setTaskPercentage(i + 0.05);
-                    return 0;
+            drive->state = Drive::TaskState::NONE;
-                }
+            drive->bWasShredded = false; // CRITICAL: Mark as NOT shredded on abort
-            drive->setTaskPercentage(i+0.05);
+            return -1;
-            write(*ipSignalFd, "A",1);
-            usleep(20000);
         }
+        drive->setTaskPercentage((double)i);
+        write(*ipSignalFd, "A", 1);
+        usleep(20000);
+    }
+
+    // Only mark as shredded if DRYRUN completed successfully
+    drive->bWasShredded = true;
+    drive->setTaskPercentage(0.0);
+    drive->state = Drive::TaskState::NONE;
+    Logger::logThis()->info("DRYRUN completed - Drive: " + drive->getSerial());
+    return 0;
 #endif
 
 #ifndef DRYRUN
-    const char *cpDrivePath = drive->getPath().c_str();
+    string sDrivePath = drive->getPath();
+    const char *cpDrivePath = sDrivePath.c_str();
     unsigned char ucKey[TFNG_KEY_SIZE];
 
-    //open random source
+#ifdef ADAPTIVE_CHUNK_SIZE
+    // Validate buffers were allocated
+    if (caTfngData == nullptr || caReadBuffer == nullptr)
+    {
+        Logger::logThis()->error("Shred-Task: Aligned buffers not allocated! - Drive: " + drive->getSerial());
+        return -1;
+    }
+#endif
+
+    // Open random source
+    Logger::logThis()->info("Shred-Task: Opening random source: " + string(randomsrc) + " - Drive: " + drive->getSerial());
     randomSrcFileDiscr = open(randomsrc, O_RDONLY | O_LARGEFILE);
     if (randomSrcFileDiscr == -1)
-        {
+    {
-            std::string errorMsg(strerror(randomSrcFileDiscr));
+        int savedErrno = errno;
-            Logger::logThis()->error("Shred-Task: Open random source failed! " + errorMsg + " - Drive: " + drive->getSerial());
+        Logger::logThis()->error("Shred-Task: Open random source failed! Path: " + string(randomsrc) +
-            perror(randomsrc);
+                                 " - Error: " + strerror(savedErrno) + " (errno: " + to_string(savedErrno) + ")" +
-            cleanup();
+                                 " - Drive: " + drive->getSerial());
-            return -1;
-        }
 
-    //open disk
+        // Reset drive state on error - NOT shredded
+        drive->state = Drive::TaskState::NONE;
+        drive->setTaskPercentage(0.0);
+        drive->bWasShredStarted = false;
+        drive->bWasShredded = false;
+        return -1;
+    }
+    Logger::logThis()->info("Shred-Task: Random source opened successfully (fd: " + to_string(randomSrcFileDiscr) + ") - Drive: " + drive->getSerial());
+
+    // Open disk
     driveFileDiscr = open(cpDrivePath, O_RDWR | O_LARGEFILE);
     if (driveFileDiscr == -1)
+    {
+        int savedErrno = errno;
+        string errorDetail;
+
+        switch (savedErrno)
         {
-            std::string errorMsg(strerror(driveFileDiscr));
+        case ENOMEDIUM:
-            Logger::logThis()->error("Shred-Task: Open drive failed! " + errorMsg + " - Drive: " + drive->getSerial());
+            errorDetail = "No medium found (drive may be empty or disconnected)";
-            perror(cpDrivePath);
+            break;
-            cleanup();
+        case EACCES:
-            return -1;
+            errorDetail = "Permission denied (need root/sudo?)";
+            break;
+        case ENOENT:
+            errorDetail = "Drive not found (device may have been removed)";
+            break;
+        case EROFS:
+            errorDetail = "Read-only file system";
+            break;
+        case EBUSY:
+            errorDetail = "Drive is busy (may be mounted or in use)";
+            break;
+        case EINVAL:
+            errorDetail = "Invalid argument";
+            break;
+        default:
+            errorDetail = strerror(savedErrno);
+            break;
         }
 
-    //read key for random generator
+        Logger::logThis()->error("Shred-Task: Open drive failed! Path: " + string(cpDrivePath) +
-    ssize_t readRet = read(randomSrcFileDiscr, ucKey, sizeof(ucKey)) ;
+                                 " - Error: " + errorDetail + " (errno: " + to_string(savedErrno) + ")" +
+                                 " - Drive: " + drive->getSerial() + " - Model: " + drive->getModelName());
+
+        // Close random source before returning
+        close(randomSrcFileDiscr);
+        randomSrcFileDiscr = -1;
+
+        // Reset drive state on error - NOT shredded
+        drive->state = Drive::TaskState::NONE;
+        drive->setTaskPercentage(0.0);
+        drive->bWasShredStarted = false;
+        drive->bWasShredded = false;
+        return -1;
+    }
+    Logger::logThis()->info("Shred-Task: Drive opened successfully (fd: " + to_string(driveFileDiscr) + ") - Drive: " + drive->getSerial());
+
+    // Read key for random generator
+    Logger::logThis()->info("Shred-Task: Reading random key - Drive: " + drive->getSerial());
+    ssize_t readRet = read(randomSrcFileDiscr, ucKey, sizeof(ucKey));
     if (readRet <= 0)
-        {
+    {
-            std::string errorMsg(strerror(readRet));
+        int savedErrno = errno;
-            Logger::logThis()->error("Shred-Task: Read random key failed! " + errorMsg + " - Drive: " + drive->getSerial());
+        Logger::logThis()->error("Shred-Task: Read random key failed! Expected: " + to_string(sizeof(ucKey)) +
-            perror(randomsrc);
+                                 " bytes, Got: " + to_string(readRet) + " bytes" +
-            cleanup();
+                                 " - Error: " + strerror(savedErrno) + " (errno: " + to_string(savedErrno) + ")" +
-            return -1;
+                                 " - Drive: " + drive->getSerial());
-        }
+        cleanup();
+
+        // Reset drive state on error - NOT shredded
+        drive->state = Drive::TaskState::NONE;
+        drive->setTaskPercentage(0.0);
+        drive->bWasShredStarted = false;
+        drive->bWasShredded = false;
+        return -1;
+    }
+    Logger::logThis()->info("Shred-Task: Random key read successfully (" + to_string(readRet) + " bytes) - Drive: " + drive->getSerial());
 
     tfng_prng_seedkey(ucKey);
 
     this->ulDriveByteSize = getDriveSizeInBytes(driveFileDiscr);
-    drive->sShredSpeed.chronoShredTimestamp = std::chrono::system_clock::now();; //set inital timestamp for speed metric
+    if (this->ulDriveByteSize == 0)
-    drive->sShredSpeed.ulSpeedMetricBytesWritten = 0U; //uses to calculate speed metric
+    {
+        Logger::logThis()->error("Shred-Task: Drive size is 0 bytes! Drive may be empty or size detection failed - Drive: " + drive->getSerial());
+        cleanup();
+
+        // Reset drive state on error - NOT shredded
+        drive->state = Drive::TaskState::NONE;
+        drive->setTaskPercentage(0.0);
+        drive->bWasShredStarted = false;
+        drive->bWasShredded = false;
+        return -1;
+    }
+
+    Drive::ShredSpeed shredSpeed = drive->sShredSpeed.load();
+    shredSpeed.chronoShredTimestamp = std::chrono::system_clock::now();
+    shredSpeed.ulSpeedMetricBytesWritten = 0U;
+    drive->sShredSpeed.store(shredSpeed);
 
 #ifdef LOG_LEVEL_HIGH
     Logger::logThis()->info("Shred-Task: Bytes-Size of Drive: " + to_string(this->ulDriveByteSize) + " - Drive: " + drive->getSerial());
 #endif
 
+#ifdef ADAPTIVE_CHUNK_SIZE
+    // Start first measurement interval
+    startMeasurement();
+#endif
+    // Main shredding loop
     for (unsigned int uiShredIterationCounter = 0U; uiShredIterationCounter < SHRED_ITERATIONS; uiShredIterationCounter++)
+    {
+        // Logger::logThis()->info("Shred-Task: Starting iteration " + to_string(uiShredIterationCounter + 1) + "/" + to_string(SHRED_ITERATIONS) + " - Drive: " + drive->getSerial());
+
+        unsigned long ulDriveByteCounter = 0U;
+
+        if (uiShredIterationCounter == (SHRED_ITERATIONS - 1))
         {
-            unsigned long ulDriveByteCounter = 0U; //used for one shred-iteration to keep track of the current drive position
+            // last shred iteration --> overwrite (just the write chunk) bytes with zeros instead with random data
+#ifdef ADAPTIVE_CHUNK_SIZE
+            memset(caTfngData, 0U, CHUNK_SIZE_MAX);
+#else
+            memset(caTfngData, 0U, CHUNK_SIZE);
+#endif
+        }
 
-            if(uiShredIterationCounter == (SHRED_ITERATIONS-1))
+        while (ulDriveByteCounter < ulDriveByteSize)
-                {
+        {
-                    //last shred iteration --> overwrite (just the write chunk) bytes with zeros instead with random data
+#ifdef ADAPTIVE_CHUNK_SIZE
-                    memset(caTfngData, 0U, CHUNK_SIZE);
+            size_t activeChunkSize = getCurrentChunkSize();
-                }
+#else
+            size_t activeChunkSize = CHUNK_SIZE;
+#endif
 
-            while (ulDriveByteCounter < ulDriveByteSize)
+            int iBytesToShred = 0;
-                {
-                    int iBytesToShred = 0; //Bytes that will be overwritten in this chunk-iteration
 
-                    if(uiShredIterationCounter != (SHRED_ITERATIONS-1))
+            if (uiShredIterationCounter != (SHRED_ITERATIONS - 1))
-                        {
+            {
-                            //NOT last shred iteration --> generate new random data
+#ifdef ADAPTIVE_CHUNK_SIZE
-                            tfng_prng_genrandom(caTfngData, TFNG_DATA_SIZE);
+                tfng_prng_genrandom(caTfngData, activeChunkSize);
-                        }
+#else
+                tfng_prng_genrandom(caTfngData, TFNG_DATA_SIZE);
+#endif
+            }
 
-                    if((ulDriveByteSize-ulDriveByteCounter) < CHUNK_SIZE)
+            if ((ulDriveByteSize - ulDriveByteCounter) < activeChunkSize)
-                        {
+            {
-                            iBytesToShred = (ulDriveByteSize-ulDriveByteCounter);
+                iBytesToShred = (ulDriveByteSize - ulDriveByteCounter);
-                        }
+            }
-                    else
+            else
-                        {
+            {
-                            iBytesToShred = CHUNK_SIZE;
+                iBytesToShred = activeChunkSize;
-                        }
+            }
 
-                    int iByteShredded = write(driveFileDiscr, caTfngData, iBytesToShred);
+            int iByteShredded = write(driveFileDiscr, caTfngData, iBytesToShred);
 
-                    if(iByteShredded <= 0)
+            if (iByteShredded <= 0)
-                        {
+            {
-                            std::string errorMsg(strerror(iByteShredded));
+                int savedErrno = errno;
-                            Logger::logThis()->error("Shred-Task: Write to drive failed! " + errorMsg + " - Drive: " + drive->getSerial());
+                Logger::logThis()->error("Shred-Task: Write to drive failed! Attempted: " + to_string(iBytesToShred) +
-                            perror("unable to write random data");
+                                         " bytes, Written: " + to_string(iByteShredded) + " bytes" +
-                            cleanup();
+                                         " - Position: " + to_string(ulDriveByteCounter) + "/" + to_string(ulDriveByteSize) +
-                            return -1;
+                                         " - Iteration: " + to_string(uiShredIterationCounter + 1) + "/" + to_string(SHRED_ITERATIONS) +
-                        }
+                                         " - Error: " + strerror(savedErrno) + " (errno: " + to_string(savedErrno) + ")" +
+                                         " - Drive: " + drive->getSerial());
+                cleanup();
 
-                    ulDriveByteCounter += iByteShredded;
+                // CRITICAL: Mark as NOT shredded on write failure
-                    ulDriveByteOverallCount += iByteShredded;
+                drive->state = Drive::TaskState::NONE;
-                    d32Percent = this->calcProgress();
+                drive->setTaskPercentage(0.0);
-                    drive->sShredSpeed.ulSpeedMetricBytesWritten += iByteShredded;
+                drive->bWasShredded = false;
+                drive->bWasChecked = false;
+                return -1;
+            }
+
+            auto shredSpeed = drive->sShredSpeed.load();
+            shredSpeed.ulSpeedMetricBytesWritten += iByteShredded;
+            drive->sShredSpeed.store(shredSpeed);
+
+            ulDriveByteCounter += iByteShredded;
+            ulDriveByteOverallCount += iByteShredded;
+
+#ifdef ADAPTIVE_CHUNK_SIZE
+            bytesWrittenInMeasurement += iByteShredded;
+            chunkCounter++;
+
+            // Evaluate throughput after measurement interval
+            if (chunkCounter >= CHUNK_MEASURE_INTERVAL)
+            {
+                evaluateThroughput(drive);
+            }
+#endif
+
+            d32Percent = this->calcProgress();
 
 #ifdef LOG_LEVEL_HIGH
-                    Logger::logThis()->info("Shred-Task: ByteCount: " + to_string(ulDriveByteCounter) +  " - iteration: " + to_string((uiShredIterationCounter+1)) + " - progress: " + to_string(d32Percent) + " - Drive: " + drive->getSerial());
+            Logger::logThis()->info("Shred-Task: ByteCount: " + to_string(ulDriveByteCounter) +
+                                    " - iteration: " + to_string((uiShredIterationCounter + 1)) +
+                                    " - progress: " + to_string(d32Percent) + "%" +
+                                    " - Drive: " + drive->getSerial());
 #endif
-                    if((d32Percent-d32TmpPercent) >= 0.01)
-                        {
-                            //set shred percantage
-                            drive->setTaskPercentage(d32TmpPercent);
-                            d32TmpPercent = d32Percent;
-                            //signal process in shreding
-                            write(*ipSignalFd, "A",1);
-                        }
 
-                    if(drive->state != Drive::SHRED_ACTIVE)
+            if ((d32Percent - d32TmpPercent) >= 0.01)
-                        {
+            {
-                            drive->setTaskPercentage(0);
+                // set shred percentage
-                            d32Percent = 0.00;
+                drive->setTaskPercentage(d32TmpPercent);
-                            d32TmpPercent = 0.00;
+                d32TmpPercent = d32Percent;
-                            ulDriveByteCounter = 0U;
+                // signal process in shredding
-                            Logger::logThis()->info("Aborted shred  for: " + drive->getModelName() + "-" +  drive->getSerial());
+                write(*ipSignalFd, "A", 1);
-                            cleanup();
+            }
-                            return -1;
+
-                        }
+            if (drive->state != Drive::TaskState::SHRED_ACTIVE)
-                    //end one chunk write
+            {
-                }
+                drive->setTaskPercentage(0);
-            if(0 != iRewindDrive(driveFileDiscr))
+                d32Percent = 0.00;
-                {
+                d32TmpPercent = 0.00;
-                    Logger::logThis()->error("Shred-Task: Unable to rewind drive! - Drive: " + drive->getSerial());
+                ulDriveByteCounter = 0U;
-                    cleanup();
+                Logger::logThis()->info("Aborted shred for: " + drive->getModelName() + "-" + drive->getSerial());
-                    return -1;
+                cleanup();
-                }
+                return -1;
-            //end one shred iteration
+            }
         }
-    //end of all shred iteratio
 
-    tfng_prng_seedkey(NULL); //reset random generator
+        Logger::logThis()->info("Shred-Task: Iteration " + to_string(uiShredIterationCounter + 1) + "/" +
+                                to_string(SHRED_ITERATIONS) + " completed - Drive: " + drive->getSerial());
 
+        // Rewind drive for next iteration
+        if (0 != iRewindDrive(driveFileDiscr))
+        {
+            Logger::logThis()->error("Shred-Task: Unable to rewind drive after iteration " +
+                                     to_string(uiShredIterationCounter + 1) + " - Drive: " + drive->getSerial());
+            cleanup();
+
+            // CRITICAL: Mark as NOT shredded on rewind failure
+            drive->state = Drive::TaskState::NONE;
+            drive->setTaskPercentage(0.0);
+            drive->bWasShredded = false;
+            drive->bWasChecked = false;
+            return -1;
+        }
+    }
+
+#ifdef ADAPTIVE_CHUNK_SIZE
+    Logger::logThis()->info("Shred completed - Optimal chunk size: " +
+                            to_string(bestChunkSize / (1024 * 1024)) + " MB, " +
+                            "Best throughput: " + to_string((int)bestThroughputMBps) + " MB/s" +
+                            " - Drive: " + drive->getSerial());
+#endif
+
+    // All shred iterations completed successfully
+    tfng_prng_seedkey(NULL);
+
+    // ONLY mark as shredded if ALL iterations completed AND fsync succeeded
     drive->bWasShredded = true;
     Logger::logThis()->info("Shred-Task finished - Drive: " + drive->getModelName() + "-" + drive->getSerial() + " @" + address.str());
+
 #ifdef ZERO_CHECK
-    drive->state=Drive::CHECK_ACTIVE;
+    drive->state = Drive::TaskState::CHECK_ACTIVE;
     Logger::logThis()->info("Check-Task started - Drive: " + drive->getModelName() + "-" + drive->getSerial() + " @" + address.str());
     drive->u32DriveChecksumAfterShredding = uiCalcChecksum(driveFileDiscr, drive, ipSignalFd);
-#ifdef LOG_LEVEL_HIGH
+
-    if (drive->u32DriveChecksumAferShredding != 0)
+    if (drive->u32DriveChecksumAfterShredding != 0)
-        {
+    {
-            Logger::logThis()->info("Shred-Task: Checksum not zero: " + to_string(drive->u32DriveChecksumAfterShredding) + " - Drive: " + drive->getSerial());
+        drive->state = Drive::TaskState::CHECK_FAILED;
-        }
+        Logger::logThis()->error("Check-Task: Checksum verification failed! Expected: 0, Got: " +
+                                 to_string(drive->u32DriveChecksumAfterShredding) + " - Drive: " + drive->getSerial());
+    }
     else
-        {
+    {
-            Logger::logThis()->info("Shred-Task: Checksum zero: " + to_string(drive->u32DriveChecksumAfterShredding) + " - Drive: " + drive->getSerial());
+        drive->state = Drive::TaskState::CHECK_SUCCESSFUL;
-        }
+        drive->bWasChecked = true;
-#endif
+        Logger::logThis()->info("Check-Task: Checksum verification passed (zero) - Drive: " + drive->getSerial());
-#endif
+    }
 #endif
 
     cleanup();
+#endif
 
-    if((drive->state == Drive::SHRED_ACTIVE) || (drive->state == Drive::CHECK_ACTIVE))
+    // Final state handling - ONLY process if shred actually completed
+    Drive::TaskState finalState = drive->state.load();
+
+    // Only do final processing if we reached a completion state
+    // (not if we returned early with errors)
+    if ((finalState == Drive::TaskState::SHRED_ACTIVE) ||
+        (finalState == Drive::TaskState::CHECK_SUCCESSFUL) ||
+        (finalState == Drive::TaskState::CHECK_FAILED))
+    {
+        if (finalState != Drive::TaskState::CHECK_FAILED)
         {
-            drive->state= Drive::NONE;
+            Logger::logThis()->info("Shred-Task: Triggering print for drive - Drive: " + drive->getSerial());
-            drive->setTaskPercentage(0.0);
             Printer::getPrinter()->print(drive);
-            Logger::logThis()->info("Finished shred/check for: " + drive->getModelName() + "-" +  drive->getSerial());
         }
+        else
+        {
+            Logger::logThis()->warning("Shred-Task: Skipping print due to checksum failure - Drive: " + drive->getSerial());
+        }
+
+        drive->state = Drive::TaskState::NONE;
+        drive->setTaskPercentage(0.0);
+        Logger::logThis()->info("Completed shred/check for: " + drive->getModelName() + "-" + drive->getSerial());
+    }
+
     return 0;
 }
+
 /**
  * \brief   calc shredding progress in %
- * \param	current byte index of the drive
- * \param	current shred iteration
  * \return  double percentage
  */
 double Shred::calcProgress()
@@ -218,84 +565,174 @@ double Shred::calcProgress()
     unsigned int uiMaxShredIteration = SHRED_ITERATIONS;
 
 #ifdef ZERO_CHECK
-    uiMaxShredIteration++; //increment because we will check after SHRED_ITERATIONS the drive for non-zero bytes
+    uiMaxShredIteration++; // increment because we will check after SHRED_ITERATIONS the drive for non-zero bytes
 #endif
-    return (double) (((double) ulDriveByteOverallCount) / ((double)this->ulDriveByteSize*uiMaxShredIteration))*100.0f;
+
+    if (this->ulDriveByteSize == 0)
+        return 0.0;
+
+    return (double)(((double)ulDriveByteOverallCount) / ((double)this->ulDriveByteSize * uiMaxShredIteration)) * 100.0;
 }
 
+/**
+ * \brief   rewind drive to beginning
+ * \param   file descriptor
+ * \return  0 on success, -1 on error
+ */
 int Shred::iRewindDrive(fileDescriptor file)
 {
-    if(0 != lseek(file, 0L, SEEK_SET))
+    off_t result = lseek(file, 0L, SEEK_SET);
-        {
+
-            perror("unable to rewind drive");
+    if (result == -1)
-            return -1;
+    {
-        }
+        int savedErrno = errno;
-    else
+        Logger::logThis()->error("Unable to rewind drive! Error: " + string(strerror(savedErrno)) +
-        {
+                                 " (errno: " + to_string(savedErrno) + ") - fileDescriptor: " + to_string(file));
-            return 0;
+        return -1;
-        }
+    }
+    else if (result != 0)
+    {
+        Logger::logThis()->error("Rewind position mismatch! Expected: 0, Got: " + to_string(result) +
+                                 " - fileDescriptor: " + to_string(file));
+        return -1;
+    }
+
+    return 0;
 }
 
-unsigned long Shred::getDriveSizeInBytes(fileDescriptor file)
+/**
+ * \brief   get drive size in bytes
+ * \param   file descriptor
+ * \return  size in bytes, 0 on error
+ */
+long Shred::getDriveSizeInBytes(fileDescriptor file)
 {
-    unsigned long ulDriveSizeTmp = lseek(file, 0L, SEEK_END);
+    off_t liDriveSizeTmp = lseek(file, 0L, SEEK_END);
 
-    if(0 != iRewindDrive(file))
+    if (liDriveSizeTmp == -1)
-        {
+    {
-            ulDriveSizeTmp = 0U;
+        int savedErrno = errno;
-        }
+        Logger::logThis()->error("Unable to get drive size! Error: " + string(strerror(savedErrno)) +
+                                 " (errno: " + to_string(savedErrno) + ") - fileDescriptor: " + to_string(file));
+        return 0L;
+    }
+
+    if (0 != iRewindDrive(file))
+    {
+        Logger::logThis()->error("Unable to rewind after size detection - fileDescriptor: " + to_string(file));
+        return 0L;
+    }
 
 #ifdef DEMO_DRIVE_SIZE
-    ulDriveSizeTmp = DEMO_DRIVE_SIZE;
+    liDriveSizeTmp = DEMO_DRIVE_SIZE;
+    Logger::logThis()->info("DEMO_DRIVE_SIZE active - using size: " + to_string(liDriveSizeTmp) + " bytes");
 #endif
-    return ulDriveSizeTmp;
+
+    return liDriveSizeTmp;
 }
 
-unsigned int Shred::uiCalcChecksum(fileDescriptor file,Drive* drive, int* ipSignalFd)
+/**
+ * \brief   calculate checksum of drive (verify all zeros)
+ * \param   file descriptor
+ * \param   pointer to Drive instance
+ * \param   signal file descriptor
+ * \return  checksum value (0 = all zeros)
+ */
+unsigned int Shred::uiCalcChecksum(fileDescriptor file, Drive *drive, int *ipSignalFd)
 {
     unsigned int uiChecksum = 0;
     unsigned long ulDriveByteCounter = 0U;
+
+    Logger::logThis()->info("Check-Task: Starting checksum verification - Drive: " + drive->getSerial());
+
+#ifdef ADAPTIVE_CHUNK_SIZE
+    size_t checkChunkSize = CHUNK_SIZE_MAX;
+#else
+    size_t checkChunkSize = CHUNK_SIZE;
+#endif
+
     while (ulDriveByteCounter < ulDriveByteSize)
+    {
+        // Check if task was aborted
+        if (drive->state.load() != Drive::TaskState::CHECK_ACTIVE)
         {
-            int iBytesToCheck = 0;
+            Logger::logThis()->info("Check-Task: Aborted by user at " + to_string(d32Percent) + "% - Drive: " + drive->getSerial());
-            if((ulDriveByteSize-ulDriveByteCounter) < CHUNK_SIZE)
+            return UINT32_MAX; // Return non-zero to indicate incomplete check
-                {
-                    iBytesToCheck = (ulDriveByteSize-ulDriveByteCounter);
-                }
-            else
-                {
-                    iBytesToCheck = CHUNK_SIZE;
-                }
-            int iReadBytes = read(file, caReadBuffer, iBytesToCheck);
-            for (int iReadBytesCounter = 0U; iReadBytesCounter < iReadBytes; iReadBytesCounter++)
-                {
-                    uiChecksum += caReadBuffer[iReadBytesCounter];
-                }
-            ulDriveByteCounter += iReadBytes;
-            ulDriveByteOverallCount += iReadBytes;
-            d32Percent = this->calcProgress();
-            drive->sShredSpeed.ulSpeedMetricBytesWritten += iReadBytes;
-
-#ifdef LOG_LEVEL_HIGH
-            Logger::logThis()->info("Shred-Task (Checksum): ByteCount: " + to_string(ulDriveByteCounter) + " - progress: " + to_string(d32Percent) + " - Drive: " + drive->getSerial());
-#endif
-
-            if(((d32Percent-d32TmpPercent) >= 0.01) || (d32Percent == 100.0))
-                {
-                    drive->setTaskPercentage(d32TmpPercent);
-                    d32TmpPercent = d32Percent;
-#ifdef LOG_LEVEL_HIGH
-                    Logger::logThis()->info("send progress signal to main loop (check)");
-#endif
-                    write(*ipSignalFd, "A",1);
-                }
         }
+
+        int iBytesToCheck = 0;
+        if ((ulDriveByteSize - ulDriveByteCounter) < checkChunkSize)
+        {
+            iBytesToCheck = (ulDriveByteSize - ulDriveByteCounter);
+        }
+        else
+        {
+            iBytesToCheck = checkChunkSize;
+        }
+        int iReadBytes = read(file, caReadBuffer, iBytesToCheck);
+
+        if (iReadBytes <= 0)
+        {
+            int savedErrno = errno;
+            Logger::logThis()->error("Check-Task: Read failed! Attempted: " + to_string(iBytesToCheck) +
+                                     " bytes, Read: " + to_string(iReadBytes) + " bytes" +
+                                     " - Position: " + to_string(ulDriveByteCounter) + "/" + to_string(ulDriveByteSize) +
+                                     " - Error: " + strerror(savedErrno) + " (errno: " + to_string(savedErrno) + ")" +
+                                     " - Drive: " + drive->getSerial());
+            return UINT32_MAX; // Return non-zero to indicate read failure
+        }
+
+        for (int iReadBytesCounter = 0U; iReadBytesCounter < iReadBytes; iReadBytesCounter++)
+        {
+            uiChecksum += caReadBuffer[iReadBytesCounter];
+        }
+        ulDriveByteCounter += iReadBytes;
+        ulDriveByteOverallCount += iReadBytes;
+        d32Percent = this->calcProgress();
+        auto shredSpeed = drive->sShredSpeed.load();
+        shredSpeed.ulSpeedMetricBytesWritten += iReadBytes;
+        drive->sShredSpeed.store(shredSpeed);
+
+#ifdef LOG_LEVEL_HIGH
+        Logger::logThis()->info("Check-Task: ByteCount: " + to_string(ulDriveByteCounter) +
+                                " - progress: " + to_string(d32Percent) + "%" +
+                                " - checksum so far: " + to_string(uiChecksum) +
+                                " - Drive: " + drive->getSerial());
+#endif
+
+        if (((d32Percent - d32TmpPercent) >= 0.01) || (d32Percent == 100.0))
+        {
+            drive->setTaskPercentage(d32TmpPercent);
+            d32TmpPercent = d32Percent;
+#ifdef LOG_LEVEL_HIGH
+            Logger::logThis()->info("send progress signal to main loop (check)");
+#endif
+            write(*ipSignalFd, "A", 1);
+        }
+    }
+
+    Logger::logThis()->info("Check-Task: Verification complete - Final checksum: " + to_string(uiChecksum) + " - Drive: " + drive->getSerial());
     drive->bWasChecked = true;
+
     return uiChecksum;
 }
 
+/**
+ * \brief   cleanup - close file descriptors
+ */
 void Shred::cleanup()
 {
-    close(driveFileDiscr);
+    if (driveFileDiscr != -1)
-    close(randomSrcFileDiscr);
+    {
+        Logger::logThis()->info("Shred-Task: Closing drive file descriptor: " + to_string(driveFileDiscr));
+        close(driveFileDiscr);
+        driveFileDiscr = -1;
+    }
+
+    if (randomSrcFileDiscr != -1)
+    {
+        Logger::logThis()->info("Shred-Task: Closing random source file descriptor: " + to_string(randomSrcFileDiscr));
+        close(randomSrcFileDiscr);
+        randomSrcFileDiscr = -1;
+    }
 }

src/smart.cpp

@@ -6,199 +6,382 @@
  */
 
 #include "../include/reHDD.h"
+#include <sys/wait.h> // For WIFSIGNALED, WTERMSIG
+using namespace std;
 
-string SMART::modelFamily;
+/**
-string SMART::modelName;
+ * \brief   Parse context for SMART attribute values
-string SMART::serial;
+ */
-uint64_t SMART::capacity = 0U;
+struct SMARTParseContext
-uint32_t SMART::errorCount = 0U;
+{
-uint32_t SMART::powerOnHours = 0U;
+    // Device information (top-level JSON fields)
-uint32_t SMART::powerCycle = 0U;
+    string modelFamily;
-uint32_t SMART::temperature = 0U;
+    string modelName;
+    string serial;
+    uint64_t capacity;
+
+    // Power and temperature (top-level JSON fields)
+    uint32_t errorCount;
+    uint32_t powerOnHours;
+    uint32_t powerCycles;
+    uint32_t temperature;
+
+    // Critical sector counts (from ata_smart_attributes table)
+    uint32_t reallocatedSectors;   // ID 5
+    uint32_t pendingSectors;       // ID 197
+    uint32_t uncorrectableSectors; // ID 198
+
+    // Parser state machine
+    enum State
+    {
+        SEARCHING,        // Looking for next field
+        IN_ATTRIBUTE_5,   // Inside ID 5 object
+        IN_ATTRIBUTE_197, // Inside ID 197 object
+        IN_ATTRIBUTE_198, // Inside ID 198 object
+        IN_RAW_SECTION    // Inside "raw": { } of current attribute
+    };
+
+    State state;
+    int currentAttributeId; // Which attribute are we parsing? (5, 197, 198)
+
+    SMARTParseContext()
+        : capacity(0),
+          errorCount(0),
+          powerOnHours(0),
+          powerCycles(0),
+          temperature(0),
+          reallocatedSectors(0),
+          pendingSectors(0),
+          uncorrectableSectors(0),
+          state(SEARCHING),
+          currentAttributeId(0)
+    {
+    }
+};
+
+/**
+ * \brief   Extract JSON string value
+ * \param   line containing "key": "value"
+ * \return  extracted string value
+ */
+static string extractStringValue(const string &line)
+{
+    size_t colonPos = line.find(": ");
+    if (colonPos == string::npos)
+        return "";
+
+    size_t firstQuote = line.find('"', colonPos + 2);
+    if (firstQuote == string::npos)
+        return "";
+
+    size_t secondQuote = line.find('"', firstQuote + 1);
+    if (secondQuote == string::npos)
+        return "";
+
+    return line.substr(firstQuote + 1, secondQuote - firstQuote - 1);
+}
+
+/**
+ * \brief   Extract JSON integer value
+ * \param   line containing "key": number
+ * \return  extracted integer value
+ */
+static uint64_t extractIntegerValue(const string &line)
+{
+    size_t colonPos = line.find(": ");
+    if (colonPos == string::npos)
+        return 0;
+
+    string valueStr = line.substr(colonPos + 2);
+
+    // Remove whitespace, commas, braces
+    valueStr.erase(remove_if(valueStr.begin(), valueStr.end(),
+                             [](char c)
+                             { return c == ' ' || c == ',' || c == '}' || c == '\n'; }),
+                   valueStr.end());
+
+    // Verify it's a valid number
+    if (valueStr.empty() || valueStr.find_first_not_of("0123456789") != string::npos)
+        return 0;
+
+    try
+    {
+        return stoull(valueStr);
+    }
+    catch (...)
+    {
+        return 0;
+    }
+}
+
+/**
+ * \brief   Process a single line of JSON output
+ * \param   line from smartctl JSON output
+ * \param   context parsing context with state
+ * \return  void
+ */
+static void processLine(const string &line, SMARTParseContext &ctx)
+{
+    // Trim whitespace for consistent parsing
+    string trimmed = line;
+    size_t firstNonSpace = trimmed.find_first_not_of(" \t\r\n");
+    if (firstNonSpace != string::npos)
+    {
+        trimmed = trimmed.substr(firstNonSpace);
+    }
+
+    // Parse top-level device information
+    if (trimmed.find("\"model_family\":") == 0)
+    {
+        ctx.modelFamily = extractStringValue(line);
+        return;
+    }
+
+    if (trimmed.find("\"model_name\":") == 0)
+    {
+        ctx.modelName = extractStringValue(line);
+        return;
+    }
+
+    if (trimmed.find("\"serial_number\":") == 0)
+    {
+        ctx.serial = extractStringValue(line);
+        return;
+    }
+
+    // Parse capacity from user_capacity.bytes
+    if (trimmed.find("\"bytes\":") == 0)
+    {
+        ctx.capacity = extractIntegerValue(line);
+        return;
+    }
+
+    // Parse error count from self_test log
+    if (trimmed.find("\"error_count_total\":") == 0)
+    {
+        ctx.errorCount = extractIntegerValue(line);
+        return;
+    }
+
+    // Parse power-on hours
+    if (trimmed.find("\"hours\":") == 0)
+    {
+        ctx.powerOnHours = extractIntegerValue(line);
+        return;
+    }
+
+    // Parse power cycle count
+    if (trimmed.find("\"power_cycle_count\":") == 0)
+    {
+        ctx.powerCycles = extractIntegerValue(line);
+        return;
+    }
+
+    // Parse temperature
+    if (trimmed.find("\"current\":") == 0 && ctx.temperature == 0)
+    {
+        // Only parse first occurrence (temperature section, not other "current" fields)
+        ctx.temperature = extractIntegerValue(line);
+        return;
+    }
+
+    // State machine for SMART attributes parsing
+    switch (ctx.state)
+    {
+    case SMARTParseContext::SEARCHING:
+        // Look for critical attribute IDs
+        if (trimmed.find("\"id\": 5,") == 0)
+        {
+            ctx.state = SMARTParseContext::IN_ATTRIBUTE_5;
+            ctx.currentAttributeId = 5;
+        }
+        else if (trimmed.find("\"id\": 197,") == 0)
+        {
+            ctx.state = SMARTParseContext::IN_ATTRIBUTE_197;
+            ctx.currentAttributeId = 197;
+        }
+        else if (trimmed.find("\"id\": 198,") == 0)
+        {
+            ctx.state = SMARTParseContext::IN_ATTRIBUTE_198;
+            ctx.currentAttributeId = 198;
+        }
+        break;
+
+    case SMARTParseContext::IN_ATTRIBUTE_5:
+    case SMARTParseContext::IN_ATTRIBUTE_197:
+    case SMARTParseContext::IN_ATTRIBUTE_198:
+        // Look for "raw": { start
+        if (trimmed.find("\"raw\":") == 0)
+        {
+            ctx.state = SMARTParseContext::IN_RAW_SECTION;
+        }
+        // Look for end of attribute object (more indented closing brace = end of attribute)
+        // "      }," or "      }" at attribute level (6 spaces)
+        else if (line.find("      },") == 0 || line.find("      }") == 0)
+        {
+            ctx.state = SMARTParseContext::SEARCHING;
+            ctx.currentAttributeId = 0;
+        }
+        break;
+
+    case SMARTParseContext::IN_RAW_SECTION:
+        // Look for "value": number inside raw section
+        if (trimmed.find("\"value\":") == 0)
+        {
+            uint64_t value = extractIntegerValue(line);
+
+            // Store value in appropriate field based on current attribute
+            if (ctx.currentAttributeId == 5)
+            {
+                ctx.reallocatedSectors = static_cast<uint32_t>(value);
+            }
+            else if (ctx.currentAttributeId == 197)
+            {
+                ctx.pendingSectors = static_cast<uint32_t>(value);
+            }
+            else if (ctx.currentAttributeId == 198)
+            {
+                ctx.uncorrectableSectors = static_cast<uint32_t>(value);
+            }
+
+            // Stay in raw section - closing brace will exit
+        }
+        // Look for end of raw object (less indented = back to attribute level)
+        // "        }" at raw level (8 spaces)
+        else if (line.find("        }") == 0)
+        {
+            // Return to attribute state (raw section closed)
+            ctx.state = (ctx.currentAttributeId == 5) ? SMARTParseContext::IN_ATTRIBUTE_5 : (ctx.currentAttributeId == 197) ? SMARTParseContext::IN_ATTRIBUTE_197
+                                                                                                                            : SMARTParseContext::IN_ATTRIBUTE_198;
+        }
+        break;
+    }
+}
 
 /**
  * \brief   get and set S.M.A.R.T. values in Drive
- * \param	pointer of Drive instance
+ * \param   pointer of Drive instance
  * \return  void
  */
-void SMART::readSMARTData(Drive* drive)
+void SMART::readSMARTData(Drive *drive)
 {
-    modelFamily.clear();
+    SMARTParseContext ctx;
-    modelName.clear();
+    uint8_t exitStatus = 255U;
-    serial.clear();
-    capacity = 0U;
-    errorCount = 0U;
-    powerOnHours = 0U;
-    powerCycle = 0U;
-    temperature = 0U;
 
-    size_t len = 0; //lenght of found line
+    // Command order optimized for USB adapters
-    char* cLine = NULL; //found line
+    // Standard commands first, then device-specific variants
+    string sSmartctlCommands[] = {
+        " --json -a ",                // Try standard first
+        " --json -d sat -a ",         // SAT (SCSI/ATA Translation) - most USB adapters
+        " --json -d usbjmicron -a ",  // USB JMicron
+        " --json -d usbprolific -a ", // USB Prolific
+        " --json -d usbsunplus -a "   // USB Sunplus
+    };
 
-    string sCMD = ("smartctl --json -a ");
+    for (const string &sSmartctlCommand : sSmartctlCommands)
-    sCMD.append(drive->getPath());
+    {
-    const char* cpComand = sCMD.c_str();
+        // Build command with timeout
+        string sCMD = "timeout 5 smartctl"; // 5 second timeout prevents hanging
+        sCMD.append(sSmartctlCommand);
+        sCMD.append(drive->getPath());
+        // Note: stderr NOT suppressed for debugging
 
-    FILE* outputfileSmart = popen(cpComand, "r");
+        Logger::logThis()->info("SMART: Executing: " + sCMD);
 
-    while ((getline(&cLine, &len, outputfileSmart)) != -1)
+        // Execute smartctl with timeout protection
+        FILE *outputfileSmart = popen(sCMD.c_str(), "r");
+        if (outputfileSmart == nullptr)
         {
-            string sLine = string(cLine);
+            Logger::logThis()->error("SMART: Failed to execute smartctl");
-
+            continue;
-            SMART::parseModelFamily(sLine);
-            SMART::parseModelName(sLine);
-            SMART::parseSerial(sLine);
-            SMART::parseCapacity(sLine);
-            SMART::parseErrorCount(sLine);
-            SMART::parsePowerOnHours(sLine);
-            SMART::parsePowerCycle(sLine);
-            SMART::parseTemperature(sLine);
         }
-    pclose(outputfileSmart);
-    drive->setDriveSMARTData(modelFamily, modelName, serial, capacity, errorCount, powerOnHours, powerCycle, temperature); //wirte data in drive
-}
 
-/**
+        // Reset context for new attempt
- * \brief   parse ModelFamiliy
+        ctx = SMARTParseContext();
- * \param	string output line of smartctl
+
- * \return  void
+        // Parse output line by line
- */
+        char *cLine = nullptr;
-void SMART::parseModelFamily(string sLine)
+        size_t len = 0;
-{
+        int lineCount = 0;
-    string search("\"model_family\": ");
+
-    size_t found = sLine.find(search);
+        while (getline(&cLine, &len, outputfileSmart) != -1)
-    if (found!=string::npos)
         {
-            sLine.erase(0, sLine.find(": ") + 3);
+            string sLine(cLine);
-            sLine.erase(sLine.length()-3, 3);
+            lineCount++;
-            modelFamily = sLine;
-        }
-}
 
-/**
+            // Parse exit status
- * \brief   parse ModelName
+            if (sLine.find("\"exit_status\":") != string::npos)
- * \param	string output line of smartctl
+            {
- * \return  void
+                exitStatus = static_cast<uint8_t>(extractIntegerValue(sLine));
- */
+            }
-void SMART::parseModelName(string sLine)
+
-{
+            // Process this line
-    string search("\"model_name\": ");
+            processLine(sLine, ctx);
-    size_t found = sLine.find(search);
+        }
-    if (found!=string::npos)
+
+        free(cLine);
+        int pcloseStatus = pclose(outputfileSmart);
+
+        Logger::logThis()->info("SMART: Parsed " + to_string(lineCount) + " lines, exit status: " + to_string(exitStatus));
+
+        // Check if timeout killed the process
+        if (WIFSIGNALED(pcloseStatus) && WTERMSIG(pcloseStatus) == SIGTERM)
         {
-            sLine.erase(0, sLine.find(": ") + 3);
+            Logger::logThis()->warning("SMART: Command timed out (5s) - skipping to next variant");
-            sLine.erase(sLine.length()-3, 3);
+            continue;
-            modelName = sLine;
         }
-}
 
-/**
+        // IGNORE exit status - instead check if we got valid data!
- * \brief   parse Serial
+        // Exit status 64 means "error log contains errors" but SMART data is still valid
- * \param	string output line of smartctl
+        // Exit status 4 means "some prefail attributes concerning" but data is valid
- * \return  void
+        // What matters: Did we parse model name and serial?
- */
+        if (!ctx.modelName.empty() && !ctx.serial.empty())
-void SMART::parseSerial(string sLine)
-{
-    string search("\"serial_number\": ");
-    size_t found = sLine.find(search);
-    if (found!=string::npos)
         {
-            sLine.erase(0, sLine.find(": ") + 3);
+            Logger::logThis()->info("SMART: Successfully parsed data");
-            sLine.erase(sLine.length()-3, 3);
+            Logger::logThis()->info("SMART: Model: " + ctx.modelName);
-            serial = sLine;
+            Logger::logThis()->info("SMART: Serial: " + ctx.serial);
-        }
+            Logger::logThis()->info("SMART: Capacity: " + to_string(ctx.capacity) + " bytes");
-}
+            Logger::logThis()->info("SMART: Power-On Hours: " + to_string(ctx.powerOnHours));
+            Logger::logThis()->info("SMART: Temperature: " + to_string(ctx.temperature) + " C");
+            Logger::logThis()->info("SMART: Reallocated Sectors: " + to_string(ctx.reallocatedSectors));
+            Logger::logThis()->info("SMART: Pending Sectors: " + to_string(ctx.pendingSectors));
+            Logger::logThis()->info("SMART: Uncorrectable Sectors: " + to_string(ctx.uncorrectableSectors));
 
-/**
+            if (exitStatus != 0)
- * \brief   parse Capacity
+            {
- * \param	string output line of smartctl
+                Logger::logThis()->info("SMART: Note - exit status " + to_string(exitStatus) + " indicates warnings/errors in SMART log");
- * \return  void
+            }
- */
+
-void SMART::parseCapacity(string sLine)
+            break; // Success - we got data!
-{
+        }
-    string search("\"bytes\": ");
+        else
-    size_t found = sLine.find(search);
-    if (found!=string::npos)
         {
-            sLine.erase(0, sLine.find(": ") + 2);
+            Logger::logThis()->warning("SMART: No valid data parsed (exit status: " + to_string(exitStatus) + ")");
-            sLine.erase(sLine.length()-1, 1);
-            capacity = stol(sLine);
-        }
-}
-
-/**
- * \brief   parse ErrorCount
- * \param	string output line of smartctl
- * \return  void
- */
-void SMART::parseErrorCount(string sLine)
-{
-    string search("\"error_count_total\": ");
-    size_t found = sLine.find(search);
-    if (found!=string::npos)
-        {
-            sLine.erase(0, sLine.find(": ")+2);
-            sLine.erase(sLine.length()-2, 2);
-            errorCount = stol(sLine);
-        }
-}
-
-/**
- * \brief   parse PowerOnHours
- * \param	string output line of smartctl
- * \return  void
- */
-void SMART::parsePowerOnHours(string sLine)
-{
-    string search("\"hours\": ");
-    size_t found = sLine.find(search);
-    if (found!=string::npos)
-        {
-            sLine.erase(0, sLine.find(": ") + 2);
-            sLine.erase(sLine.length()-1, 1);
-            powerOnHours = stol(sLine);
-
-        }
-}
-
-/**
- * \brief   parse PowerCycle
- * \param	string output line of smartctl
- * \return  void
- */
-void SMART::parsePowerCycle(string sLine)
-{
-    string search("\"power_cycle_count\": ");
-    size_t found = sLine.find(search);
-    if (found!=string::npos)
-        {
-            sLine.erase(0, sLine.find(": ") + 2);
-            sLine.erase(sLine.length()-2, 2);
-            powerCycle = stol(sLine);
-
-        }
-}
-
-/**
- * \brief   parse temperature
- * \param	string output line of smartctl
- * \return  void
- */
-void SMART::parseTemperature(string sLine)
-{
-    string search("\"current\": ");
-    size_t found = sLine.find(search);
-    if (found!=string::npos)
-        {
-            sLine.erase(0, sLine.find(": ") + 2);
-            sLine.erase(sLine.length()-1, 2);
-            if(sLine == "{")
-                {
-                    temperature = 0U; // this drive doesn't support temperatur
-                }
-            else
-                {
-                    temperature = stol(sLine);
-                }
         }
+    }
+
+    // Check if we got ANY data
+    if (ctx.modelName.empty() && ctx.serial.empty())
+    {
+        Logger::logThis()->warning("SMART: No SMART data available for this drive - may not support SMART or need root privileges");
+
+        // Try basic device info without SMART (use hdparm or similar as fallback)
+        // For now, just log that SMART is not available
+        ctx.modelName = "SMART not available";
+        ctx.serial = "N/A";
+    }
+
+    // Write parsed data to drive
+    drive->setDriveSMARTData(
+        ctx.modelFamily,
+        ctx.modelName,
+        ctx.serial,
+        ctx.capacity,
+        ctx.errorCount,
+        ctx.powerOnHours,
+        ctx.powerCycles,
+        ctx.temperature,
+        ctx.reallocatedSectors,
+        ctx.pendingSectors,
+        ctx.uncorrectableSectors);
 }