Show HDD warnings based on sectors (#97)

If one of the following metrics is >0 an warning is shown

* Reallocated_Sector_Count
* Current_Pending_Sector
* Offline_Uncorrectable

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

include/drive.h

@@ -72,7 +72,10 @@ private:
         uint32_t u32ErrorCount = 0U;
         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:
@@ -106,6 +109,9 @@ public:
     uint32_t getPowerOnHours(void); // in hours
     uint32_t getPowerCycles(void);
     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(std::string modelFamily,
@@ -115,7 +121,10 @@ public:
                            uint32_t errorCount,
                            uint32_t powerOnHours,
                            uint32_t powerCycles,
-                           uint32_t temperature);
+                           uint32_t temperature,
+                           uint32_t reallocatedSectors,
+                           uint32_t pendingSectors,
+                           uint32_t uncorrectableSectors);
 
     std::string sCapacityToText();
     std::string sErrorCountToText();

include/reHDD.h

@@ -8,7 +8,7 @@
 #ifndef REHDD_H_
 #define REHDD_H_
 
-#define REHDD_VERSION "V1.3.1"
+#define REHDD_VERSION "V1.4.0-dev"
 
 // Drive handling Settings
 #define WORSE_HOURS 19200    // mark drive if at this limit or beyond
@@ -20,7 +20,7 @@
 
 // Logger Settings
 #define LOG_PATH "./reHDD.log"
-#define DESCRIPTION "reHDD - Copyright Hendrik Schutter 2025"
+#define DESCRIPTION "reHDD - Copyright Hendrik Schutter 2026"
 #define DEVICE_ID "generic"
 #define SOFTWARE_VERSION REHDD_VERSION
 #define HARDWARE_VERSION "generic"

include/smart.h

@@ -10,24 +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:
+    /**
+     * @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 bool parseExitStatus(std::string sLine, uint8_t &status);
-    static bool parseModelFamily(std::string sLine, std::string &modelFamily);
-    static bool parseModelName(std::string sLine, std::string &modelName);
-    static bool parseSerial(std::string sLine, std::string &serial);
-    static bool parseCapacity(std::string sLine, uint64_t &capacity);
-    static bool parseErrorCount(std::string sLine, uint32_t &errorCount);
-    static bool parsePowerOnHours(std::string sLine, uint32_t &powerOnHours);
-    static bool parsePowerCycles(std::string sLine, uint32_t &powerCycles);
-    static bool parseTemperature(std::string sLine, uint32_t &temperature);
 };
 
-#endif // SMART_H_
+#endif // SMART_H_

include/tui.h

@@ -76,7 +76,7 @@ private:
     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, std::string selectedTask, std::string optionA, std::string optionB);
     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, std::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, std::string sPath, std::string sModelFamily, std::string sModelName, std::string sSerial, uint32_t u32Checksum);
 
     void displaySelectedDrive(Drive &drive, int stdscrX, int stdscrY);

src/drive.cpp

@@ -140,6 +140,21 @@ 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];
@@ -226,7 +241,10 @@ void Drive::setDriveSMARTData(string modelFamily,
                               uint32_t errorCount,
                               uint32_t powerOnHours,
                               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;
@@ -236,6 +254,9 @@ 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()

src/reHDD.cpp

@@ -332,7 +332,7 @@ void reHDD::filterNewDrives(list<Drive> *plistOldDrives, list<Drive> *plistNewDr
             {
                 itOld->bIsOffline = false; // drive is still attached
                 // copy new smart data to existing drive
-                itOld->setDriveSMARTData(itNew->getModelFamily(), itNew->getModelName(), itNew->getSerial(), itNew->getCapacity(), itNew->getErrorCount(), itNew->getPowerOnHours(), itNew->getPowerCycles(), itNew->getTemperature());
+                itOld->setDriveSMARTData(itNew->getModelFamily(), itNew->getModelName(), itNew->getSerial(), itNew->getCapacity(), itNew->getErrorCount(), itNew->getPowerOnHours(), itNew->getPowerCycles(), itNew->getTemperature(), itNew->getReallocatedSectors(), itNew->getPendingSectors(), itNew->getUncorrectableSectors());
 #ifdef LOG_LEVEL_HIGH
                 Logger::logThis()->info("Delete new drive, because already attached: " + itNew->getModelName());
 #endif

src/smart.cpp

@@ -6,306 +6,382 @@
  */
 
 #include "../include/reHDD.h"
+#include <sys/wait.h> // For WIFSIGNALED, WTERMSIG
 using namespace std;
 
+/**
+ * \brief   Parse context for SMART attribute values
+ */
+struct SMARTParseContext
+{
+    // Device information (top-level JSON fields)
+    string modelFamily;
+    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)
 {
-    string modelFamily;
+    SMARTParseContext ctx;
-    string modelName;
+    uint8_t exitStatus = 255U;
-    string serial;
-    uint64_t capacity = 0U;
-    uint32_t errorCount = 0U;
-    uint32_t powerOnHours = 0U;
-    uint32_t powerCycles = 0U;
-    uint32_t temperature = 0U;
 
-    modelFamily.clear();
+    // Command order optimized for USB adapters
-    modelName.clear();
+    // Standard commands first, then device-specific variants
-    serial.clear();
+    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 sSmartctlCommands[] = {" --json -a ", " --json -d sntjmicron -a ", " --json -d sntasmedia -a ", " --json -d sntrealtek -a ", " --json -d sat -a "};
+    for (const string &sSmartctlCommand : sSmartctlCommands)
-
-    for (string sSmartctlCommand : sSmartctlCommands)
     {
-        string sCMD = ("smartctl");
+        // Build command with timeout
+        string sCMD = "timeout 5 smartctl"; // 5 second timeout prevents hanging
         sCMD.append(sSmartctlCommand);
         sCMD.append(drive->getPath());
-        const char *cpComand = sCMD.c_str();
+        // Note: stderr NOT suppressed for debugging
 
-        // Logger::logThis()->info(cpComand);
+        Logger::logThis()->info("SMART: Executing: " + sCMD);
 
-        FILE *outputfileSmart = popen(cpComand, "r");
+        // Execute smartctl with timeout protection
-        size_t len = 0U;    // length of found line
+        FILE *outputfileSmart = popen(sCMD.c_str(), "r");
-        char *cLine = NULL; // found line
+        if (outputfileSmart == nullptr)
-        uint8_t status = 255U;
-
-        while ((getline(&cLine, &len, outputfileSmart)) != -1)
         {
-            string sLine = string(cLine);
+            Logger::logThis()->error("SMART: Failed to execute smartctl");
+            continue;
+        }
 
-            SMART::parseExitStatus(sLine, status);
+        // Reset context for new attempt
-            SMART::parseModelFamily(sLine, modelFamily);
+        ctx = SMARTParseContext();
-            SMART::parseModelName(sLine, modelName);
+
-            SMART::parseSerial(sLine, serial);
+        // Parse output line by line
-            SMART::parseCapacity(sLine, capacity);
+        char *cLine = nullptr;
-            SMART::parseErrorCount(sLine, errorCount);
+        size_t len = 0;
-            SMART::parsePowerOnHours(sLine, powerOnHours);
+        int lineCount = 0;
-            SMART::parsePowerCycles(sLine, powerCycles);
+
-            SMART::parseTemperature(sLine, temperature);
+        while (getline(&cLine, &len, outputfileSmart) != -1)
+        {
+            string sLine(cLine);
+            lineCount++;
+
+            // Parse exit status
+            if (sLine.find("\"exit_status\":") != string::npos)
+            {
+                exitStatus = static_cast<uint8_t>(extractIntegerValue(sLine));
+            }
+
+            // Process this line
+            processLine(sLine, ctx);
         }
 
         free(cLine);
-        pclose(outputfileSmart);
+        int pcloseStatus = pclose(outputfileSmart);
 
-        if (status == 0U)
+        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)
         {
-            // Found S.M.A.R.T. data with this command
+            Logger::logThis()->warning("SMART: Command timed out (5s) - skipping to next variant");
-            // Logger::logThis()->info("Found S.M.A.R.T. data with this command");
+            continue;
-            break;
         }
-    }
 
-    drive->setDriveSMARTData(modelFamily, modelName, serial, capacity, errorCount, powerOnHours, powerCycles, temperature); // write data in drive
+        // IGNORE exit status - instead check if we got valid data!
-}
+        // Exit status 64 means "error log contains errors" but SMART data is still valid
-
+        // Exit status 4 means "some prefail attributes concerning" but data is valid
-/**
+        // What matters: Did we parse model name and serial?
- * \brief parse ExitStatus
+        if (!ctx.modelName.empty() && !ctx.serial.empty())
- * \param string output line of smartctl
- * \param uint8_t parsed status
- * \return bool if parsing was possible
- */
-bool SMART::parseExitStatus(string sLine, uint8_t &status)
-{
-    string search("\"exit_status\": ");
-    size_t found = sLine.find(search);
-    if (found != string::npos)
-    {
-        sLine.erase(0U, sLine.find(": ") + 1U);
-        status = stol(sLine);
-        return true;
-    }
-    else
-    {
-        return false;
-    }
-}
-
-/**
- * \brief parse ModelFamily
- * \param string output line of smartctl
- * \param string parsed model family
- * \return bool if parsing was possible
- */
-bool SMART::parseModelFamily(string sLine, string &modelFamily)
-{
-    string search("\"model_family\": ");
-    size_t found = sLine.find(search);
-    if (found != string::npos)
-    {
-        sLine.erase(0U, sLine.find(": ") + 3U);
-        if (sLine.length() >= 3U)
         {
-            sLine.erase(sLine.length() - 3U, 3U);
+            Logger::logThis()->info("SMART: Successfully parsed data");
-        }
+            Logger::logThis()->info("SMART: Model: " + ctx.modelName);
-        modelFamily = sLine;
+            Logger::logThis()->info("SMART: Serial: " + ctx.serial);
-        return true;
+            Logger::logThis()->info("SMART: Capacity: " + to_string(ctx.capacity) + " bytes");
-    }
+            Logger::logThis()->info("SMART: Power-On Hours: " + to_string(ctx.powerOnHours));
-    else
+            Logger::logThis()->info("SMART: Temperature: " + to_string(ctx.temperature) + " C");
-    {
+            Logger::logThis()->info("SMART: Reallocated Sectors: " + to_string(ctx.reallocatedSectors));
-        return false;
+            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 ModelName
+            {
- * \param string output line of smartctl
+                Logger::logThis()->info("SMART: Note - exit status " + to_string(exitStatus) + " indicates warnings/errors in SMART log");
- * \param string parsed model name
+            }
- * \return bool if parsing was possible
- */
-bool SMART::parseModelName(string sLine, string &modelName)
-{
-    string search("\"model_name\": ");
-    size_t found = sLine.find(search);
-    if (found != string::npos)
-    {
-        sLine.erase(0U, sLine.find(": ") + 3U);
-        if (sLine.length() >= 3U)
-        {
-            sLine.erase(sLine.length() - 3U, 3U);
-        }
-        modelName = sLine;
-        return true;
-    }
-    else
-    {
-        return false;
-    }
-}
 
-/**
+            break; // Success - we got data!
- * \brief parse Serial
- * \param string output line of smartctl
- * \param string parsed serial
- * \return bool if parsing was possible
- */
-bool SMART::parseSerial(string sLine, string &serial)
-{
-    string search("\"serial_number\": ");
-    size_t found = sLine.find(search);
-    if (found != string::npos)
-    {
-        sLine.erase(0, sLine.find(": ") + 3);
-        if (sLine.length() >= 3U)
-        {
-            sLine.erase(sLine.length() - 3U, 3U);
-        }
-        serial = sLine;
-        return true;
-    }
-    else
-    {
-        return false;
-    }
-}
-
-/**
- * \brief parse Capacity
- * \param string output line of smartctl
- *  \param string parsed capacity
- * \return bool if parsing was possible
- */
-bool SMART::parseCapacity(string sLine, uint64_t &capacity)
-{
-    string search("\"bytes\": ");
-    size_t found = sLine.find(search);
-    if (found != string::npos)
-    {
-        sLine.erase(0, sLine.find(": ") + 2);
-        if (sLine.length() >= 1U)
-        {
-            sLine.erase(sLine.length() - 1U, 1U);
-        }
-        capacity = stol(sLine);
-        return true;
-    }
-    else
-    {
-        return false;
-    }
-}
-
-/**
- * \brief parse ErrorCount
- * \param string output line of smartctl
- * \param uint32_t parsed error count
- * \return bool if parsing was possible
- */
-bool SMART::parseErrorCount(string sLine, uint32_t &errorCount)
-{
-    string search("\"error_count_total\": ");
-    size_t found = sLine.find(search);
-    if (found != string::npos)
-    {
-        sLine.erase(0U, sLine.find(": ") + 2U);
-        if (sLine.length() >= 2U)
-        {
-            sLine.erase(sLine.length() - 2U, 2U);
-        }
-        errorCount = stol(sLine);
-        return true;
-    }
-    else
-    {
-        return false;
-    }
-}
-
-/**
- * \brief parse PowerOnHours
- * \param string output line of smartctl\
- * \param uint32_t parsed power on hours
- * \return bool if parsing was possible
- */
-bool SMART::parsePowerOnHours(string sLine, uint32_t &powerOnHours)
-{
-    string search("\"hours\": ");
-    size_t found = sLine.find(search);
-    if (found != string::npos)
-    {
-        sLine.erase(0U, sLine.find(": ") + 2U);
-        if (sLine.length() >= 1U)
-        {
-            sLine.erase(sLine.length() - 1U, 1U);
-        }
-        powerOnHours = stol(sLine);
-        return true;
-    }
-    else
-    {
-        return false;
-    }
-}
-
-/**
- * \brief parse PowerCycle
- * \param string output line of smartctl
- * \param uint32_t parsed power cycles
- * \return bool if parsing was possible
- */
-bool SMART::parsePowerCycles(string sLine, uint32_t &powerCycles)
-{
-    string search("\"power_cycle_count\": ");
-    size_t found = sLine.find(search);
-    if (found != string::npos)
-    {
-        sLine.erase(0, sLine.find(": ") + 2);
-        if (sLine.length() >= 2U)
-        {
-            sLine.erase(sLine.length() - 2U, 2U);
-        }
-        powerCycles = stol(sLine);
-        return true;
-    }
-    else
-    {
-        return false;
-    }
-}
-
-/**
- * \brief parse temperature
- * \param string output line of smartctl
- * \param uint32_t parsed temperature
- * \return bool if parsing was possible
- */
-bool SMART::parseTemperature(string sLine, uint32_t &temperature)
-{
-    string search("\"current\": ");
-    size_t found = sLine.find(search);
-    if (found != string::npos)
-    {
-        sLine.erase(0U, sLine.find(": ") + 2U);
-        if (sLine.length() >= 1U)
-        {
-            sLine.erase(sLine.length() - 1U, 2U);
-        }
-        if (sLine == "{")
-        {
-            temperature = 0U; // this drive doesn't support temperature
         }
         else
         {
-            temperature = stol(sLine);
+            Logger::logThis()->warning("SMART: No valid data parsed (exit status: " + to_string(exitStatus) + ")");
         }
-        return true;
     }
-    else
+
+    // Check if we got ANY data
+    if (ctx.modelName.empty() && ctx.serial.empty())
     {
-        return false;
+        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);
 }

src/tui.cpp

@@ -110,10 +110,10 @@ void TUI::updateTUI(list<Drive> *plistDrives, uint8_t u8SelectedEntry)
             bSelectedEntry = true; // mark this drive in entries list
             displaySelectedDrive(*it, u16StdscrX, u16StdscrY);
 
-            if ((it->getPowerOnHours() >= WORSE_HOURS) || (it->getPowerCycles() >= WORSE_POWERUP) || (it->getErrorCount() > 0) || (it->getTemperature() >= WORSE_TEMPERATURE))
+            if ((it->getPowerOnHours() >= WORSE_HOURS) || (it->getPowerCycles() >= WORSE_POWERUP) || (it->getErrorCount() > 0) || (it->getTemperature() >= WORSE_TEMPERATURE) || (it->getReallocatedSectors() > 0) || (it->getPendingSectors() > 0) || (it->getUncorrectableSectors() > 0))
             {
                 // smart values are bad --> show warning
-                smartWarning = createSmartWarning(50, 10, ((u16StdscrX) - (int)(u16StdscrX / 2) + 35), (int)(u16StdscrY / 2) - 5, it->getPath(), it->getPowerOnHours(), it->getPowerCycles(), it->getErrorCount(), it->getTemperature());
+                smartWarning = createSmartWarning(50, 14, ((u16StdscrX) - (int)(u16StdscrX / 2) + 35), (int)(u16StdscrY / 2) - 7, it->getPath(), it->getPowerOnHours(), it->getPowerCycles(), it->getErrorCount(), it->getTemperature(), it->getReallocatedSectors(), it->getPendingSectors(), it->getUncorrectableSectors());
                 wrefresh(smartWarning);
             }
         }
@@ -721,7 +721,7 @@ void TUI::displaySelectedDrive(Drive &drive, int stdscrX, int stdscrY)
     }
 }
 
-WINDOW *TUI::createSmartWarning(int iXSize, int iYSize, int iXStart, int iYStart, string sPath, uint32_t u32PowerOnHours, uint32_t u32PowerCycles, uint32_t u32ErrorCount, uint32_t u32Temperature)
+WINDOW *TUI::createSmartWarning(int iXSize, int iYSize, int iXStart, int iYStart, string sPath, uint32_t u32PowerOnHours, uint32_t u32PowerCycles, uint32_t u32ErrorCount, uint32_t u32Temperature, uint32_t u32ReallocatedSectors, uint32_t u32PendingSectors, uint32_t u32UncorrectableSectors)
 {
     WINDOW *newWindow;
     newWindow = newwin(iYSize, iXSize, iYStart, iXStart);
@@ -763,6 +763,28 @@ WINDOW *TUI::createSmartWarning(int iXSize, int iYSize, int iXStart, int iYStart
     {
         string sLineTmp = "Drive too hot: " + to_string(u32Temperature) + " C";
         mvwaddstr(newWindow, u16Line++, (iXSize / 2) - (sLine01.size() / 2), sLineTmp.c_str());
+        u16Line++;
     }
+
+    if (u32ReallocatedSectors > 0)
+    {
+        string sLineTmp = "CRITICAL: Reallocated sectors detected: " + to_string(u32ReallocatedSectors);
+        mvwaddstr(newWindow, u16Line++, (iXSize / 2) - (sLine01.size() / 2), sLineTmp.c_str());
+        u16Line++;
+    }
+
+    if (u32PendingSectors > 0)
+    {
+        string sLineTmp = "CRITICAL: Pending sectors detected: " + to_string(u32PendingSectors);
+        mvwaddstr(newWindow, u16Line++, (iXSize / 2) - (sLine01.size() / 2), sLineTmp.c_str());
+        u16Line++;
+    }
+
+    if (u32UncorrectableSectors > 0)
+    {
+        string sLineTmp = "CRITICAL: Uncorrectable sectors: " + to_string(u32UncorrectableSectors);
+        mvwaddstr(newWindow, u16Line++, (iXSize / 2) - (sLine01.size() / 2), sLineTmp.c_str());
+    }
+
     return newWindow;
 }