include/reHDD.h

@@ -8,7 +8,7 @@
 #ifndef REHDD_H_
 #define REHDD_H_
 
-#define REHDD_VERSION "V1.1.2"
+#define REHDD_VERSION "V1.1.1"
 
 // Drive handling Settings
 #define WORSE_HOURS 19200    // mark drive if at this limit or beyond
@@ -31,7 +31,7 @@
 #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 ZERO_CHECK   // check drive after shred if all bytes are zero, show alert if this fails
 

include/smart.h

@@ -19,15 +19,24 @@ public:
 private:
     SMART(void);
 
-    static bool parseExitStatus(string sLine, uint8_t &status);
+    static uint8_t parseExitStatus(string sLine);
-    static bool parseModelFamily(string sLine, string &modelFamily);
+    static void parseModelFamily(string sLine);
-    static bool parseModelName(string sLine, string &modelName);
+    static void parseModelName(string sLine);
-    static bool parseSerial(string sLine, string &serial);
+    static void parseSerial(string sLine);
-    static bool parseCapacity(string sLine, uint64_t &capacity);
+    static void parseCapacity(string sLine);
-    static bool parseErrorCount(string sLine, uint32_t &errorCount);
+    static void parseErrorCount(string sLine);
-    static bool parsePowerOnHours(string sLine, uint32_t &powerOnHours);
+    static void parsePowerOnHours(string sLine);
-    static bool parsePowerCycles(string sLine, uint32_t &powerCycles);
+    static void parsePowerCycle(string sLine);
-    static bool parseTemperature(string sLine, uint32_t &temperature);
+    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_

src/reHDD.cpp

@@ -560,7 +560,7 @@ void reHDD::handleEnter()
         {
             Logger::logThis()->info("Started shred/check for: " + getSelectedDrive()->getModelName() + "-" + getSelectedDrive()->getSerial());
             getSelectedDrive()->state = Drive::TaskState::SHRED_ACTIVE;
-            // task for drive is running --> don't show  more task options
+            // task for drive is running --> don´t show  more task options
             Drive *pTmpDrive = getSelectedDrive();
             thread(ThreadShred, pTmpDrive).detach();
         }
@@ -569,7 +569,7 @@ void reHDD::handleEnter()
         {
             Logger::logThis()->info("Started delete for: " + getSelectedDrive()->getModelName() + "-" + getSelectedDrive()->getSerial());
             getSelectedDrive()->state = Drive::TaskState::DELETE_ACTIVE;
-            // task for drive is running --> don't show  more task options
+            // task for drive is running --> don´t show  more task options
             thread(ThreadDelete).detach();
         }
     }

src/shred.cpp

@@ -90,7 +90,8 @@ int Shred::shredDrive(Drive *drive, int *ipSignalFd)
     tfng_prng_seedkey(ucKey);
 
     this->ulDriveByteSize = getDriveSizeInBytes(driveFileDiscr);
-    drive->sShredSpeed.chronoShredTimestamp = std::chrono::system_clock::now(); // set inital timestamp for speed metric
+    drive->sShredSpeed.chronoShredTimestamp = std::chrono::system_clock::now();
+    ;                                                  // set inital timestamp for speed metric
     drive->sShredSpeed.ulSpeedMetricBytesWritten = 0U; // uses to calculate speed metric
 
 #ifdef LOG_LEVEL_HIGH

src/smart.cpp

@@ -7,6 +7,15 @@
 
 #include "../include/reHDD.h"
 
+string SMART::modelFamily;
+string SMART::modelName;
+string SMART::serial;
+uint64_t SMART::capacity = 0U;
+uint32_t SMART::errorCount = 0U;
+uint32_t SMART::powerOnHours = 0U;
+uint32_t SMART::powerCycle = 0U;
+uint32_t SMART::temperature = 0U;
+
 /**
  * \brief   get and set S.M.A.R.T. values in Drive
  * \param	pointer of Drive instance
@@ -14,20 +23,16 @@
  */
 void SMART::readSMARTData(Drive *drive)
 {
-    string modelFamily;
-    string modelName;
-    string serial;
-    uint64_t capacity = 0U;
-    uint32_t errorCount = 0U;
-    uint32_t powerOnHours = 0U;
-    uint32_t powerCycles = 0U;
-    uint32_t temperature = 0U;
-
     modelFamily.clear();
     modelName.clear();
     serial.clear();
+    capacity = 0U;
+    errorCount = 0U;
+    powerOnHours = 0U;
+    powerCycle = 0U;
+    temperature = 0U;
 
-    string sSmartctlCommands[] = {" --json -a ", " --json -d sntjmicron -a ", " --json -d sntasmedia -a ", " --json -d sntrealtek -a ", " --json -d sat -a "};
+    string sSmartctlCommands[] = {" --json -a ", " --json -d sntjmicron -a ", " --json -d sntasmedia -a ", " --json -d sntrealtek -a "};
 
     for (string sSmartctlCommand : sSmartctlCommands)
     {
@@ -36,26 +41,24 @@ void SMART::readSMARTData(Drive *drive)
         sCMD.append(drive->getPath());
         const char *cpComand = sCMD.c_str();
 
-        // Logger::logThis()->info(cpComand);
-
         FILE *outputfileSmart = popen(cpComand, "r");
-        size_t len = 0U;     // length of found line
+        size_t len = 0;     // length of found line
         char *cLine = NULL; // found line
-        uint8_t status = 255U;
+        uint8_t status = 255;
 
         while ((getline(&cLine, &len, outputfileSmart)) != -1)
         {
             string sLine = string(cLine);
 
-            SMART::parseExitStatus(sLine, status);
+            status = SMART::parseExitStatus(sLine);
-            SMART::parseModelFamily(sLine, modelFamily);
+            SMART::parseModelFamily(sLine);
-            SMART::parseModelName(sLine, modelName);
+            SMART::parseModelName(sLine);
-            SMART::parseSerial(sLine, serial);
+            SMART::parseSerial(sLine);
-            SMART::parseCapacity(sLine, capacity);
+            SMART::parseCapacity(sLine);
-            SMART::parseErrorCount(sLine, errorCount);
+            SMART::parseErrorCount(sLine);
-            SMART::parsePowerOnHours(sLine, powerOnHours);
+            SMART::parsePowerOnHours(sLine);
-            SMART::parsePowerCycles(sLine, powerCycles);
+            SMART::parsePowerCycle(sLine);
-            SMART::parseTemperature(sLine, temperature);
+            SMART::parseTemperature(sLine);
         }
 
         pclose(outputfileSmart);
@@ -63,89 +66,71 @@ void SMART::readSMARTData(Drive *drive)
         if (status == 0U)
         {
             // Found S.M.A.R.T. data with this command
-            // Logger::logThis()->info("Found S.M.A.R.T. data with this command");
             break;
         }
     }
 
-    drive->setDriveSMARTData(modelFamily, modelName, serial, capacity, errorCount, powerOnHours, powerCycles, temperature); // write data in drive
+    drive->setDriveSMARTData(modelFamily, modelName, serial, capacity, errorCount, powerOnHours, powerCycle, temperature); // wirte data in drive
 }
 
 /**
- * \brief parse ExitStatus
+ * \brief   parse ExitStatus
- * \param string output line of smartctl
+ * \param	string output line of smartctl
- * \param uint8_t parsed status
+ * \return  uint_8 exit status
- * \return bool if parsing was possible
  */
-bool SMART::parseExitStatus(string sLine, uint8_t &status)
+uint8_t SMART::parseExitStatus(string sLine)
 {
+    uint8_t exitStatus = -1;
     string search("\"exit_status\": ");
     size_t found = sLine.find(search);
     if (found != string::npos)
     {
-        sLine.erase(0U, sLine.find(": ") + 1U);
+        sLine.erase(0, sLine.find(": ") + 1);
-        status = stol(sLine);
+        exitStatus = stol(sLine);
-        return true;
-    }
-    else
-    {
-        return false;
     }
+    return exitStatus;
 }
 
 /**
- * \brief parse ModelFamily
+ * \brief   parse ModelFamiliy
- * \param string output line of smartctl
+ * \param	string output line of smartctl
- * \param string parsed model family
+ * \return  void
- * \return bool if parsing was possible
  */
-bool SMART::parseModelFamily(string sLine, string &modelFamily)
+void SMART::parseModelFamily(string sLine)
 {
     string search("\"model_family\": ");
     size_t found = sLine.find(search);
     if (found != string::npos)
     {
-        sLine.erase(0U, sLine.find(": ") + 3U);
+        sLine.erase(0, sLine.find(": ") + 3);
-        sLine.erase(sLine.length() - 3U, 3U);
+        sLine.erase(sLine.length() - 3, 3);
         modelFamily = sLine;
-        return true;
-    }
-    else
-    {
-        return false;
     }
 }
 
 /**
- * \brief parse ModelName
+ * \brief   parse ModelName
- * \param string output line of smartctl
+ * \param	string output line of smartctl
- * \param string parsed model name
+ * \return  void
- * \return bool if parsing was possible
  */
-bool SMART::parseModelName(string sLine, string &modelName)
+void SMART::parseModelName(string sLine)
 {
     string search("\"model_name\": ");
     size_t found = sLine.find(search);
     if (found != string::npos)
     {
-        sLine.erase(0U, sLine.find(": ") + 3U);
+        sLine.erase(0, sLine.find(": ") + 3);
-        sLine.erase(sLine.length() - 3U, 3U);
+        sLine.erase(sLine.length() - 3, 3);
         modelName = sLine;
-        return true;
-    }
-    else
-    {
-        return false;
     }
 }
 
 /**
- * \brief parse Serial
+ * \brief   parse Serial
- * \param string output line of smartctl
+ * \param	string output line of smartctl
- * \param string parsed serial
+ * \return  void
- * \return bool if parsing was possible
  */
-bool SMART::parseSerial(string sLine, string &serial)
+void SMART::parseSerial(string sLine)
 {
     string search("\"serial_number\": ");
     size_t found = sLine.find(search);
@@ -154,21 +139,15 @@ bool SMART::parseSerial(string sLine, string &serial)
         sLine.erase(0, sLine.find(": ") + 3);
         sLine.erase(sLine.length() - 3, 3);
         serial = sLine;
-        return true;
-    }
-    else
-    {
-        return false;
     }
 }
 
 /**
- * \brief parse Capacity
+ * \brief   parse Capacity
- * \param string output line of smartctl
+ * \param	string output line of smartctl
- *  \param string parsed capacity
+ * \return  void
- * \return bool if parsing was possible
  */
-bool SMART::parseCapacity(string sLine, uint64_t &capacity)
+void SMART::parseCapacity(string sLine)
 {
     string search("\"bytes\": ");
     size_t found = sLine.find(search);
@@ -177,67 +156,49 @@ bool SMART::parseCapacity(string sLine, uint64_t &capacity)
         sLine.erase(0, sLine.find(": ") + 2);
         sLine.erase(sLine.length() - 1, 1);
         capacity = stol(sLine);
-        return true;
-    }
-    else
-    {
-        return false;
     }
 }
 
 /**
- * \brief parse ErrorCount
+ * \brief   parse ErrorCount
- * \param string output line of smartctl
+ * \param	string output line of smartctl
- * \param uint32_t parsed error count
+ * \return  void
- * \return bool if parsing was possible
  */
-bool SMART::parseErrorCount(string sLine, uint32_t &errorCount)
+void SMART::parseErrorCount(string sLine)
 {
     string search("\"error_count_total\": ");
     size_t found = sLine.find(search);
     if (found != string::npos)
     {
-        sLine.erase(0U, sLine.find(": ") + 2U);
+        sLine.erase(0, sLine.find(": ") + 2);
-        sLine.erase(sLine.length() - 2U, 2U);
+        sLine.erase(sLine.length() - 2, 2);
         errorCount = stol(sLine);
-        return true;
-    }
-    else
-    {
-        return false;
     }
 }
 
 /**
- * \brief parse PowerOnHours
+ * \brief   parse PowerOnHours
- * \param string output line of smartctl\
+ * \param	string output line of smartctl
- * \param uint32_t parsed power on hours
+ * \return  void
- * \return bool if parsing was possible
  */
-bool SMART::parsePowerOnHours(string sLine, uint32_t &powerOnHours)
+void SMART::parsePowerOnHours(string sLine)
 {
     string search("\"hours\": ");
     size_t found = sLine.find(search);
     if (found != string::npos)
     {
-        sLine.erase(0U, sLine.find(": ") + 2U);
+        sLine.erase(0, sLine.find(": ") + 2);
-        sLine.erase(sLine.length() - 1U, 1U);
+        sLine.erase(sLine.length() - 1, 1);
         powerOnHours = stol(sLine);
-        return true;
-    }
-    else
-    {
-        return false;
     }
 }
 
 /**
- * \brief parse PowerCycle
+ * \brief   parse PowerCycle
- * \param string output line of smartctl
+ * \param	string output line of smartctl
- * \param uint32_t parsed power cycles
+ * \return  void
- * \return bool if parsing was possible
  */
-bool SMART::parsePowerCycles(string sLine, uint32_t &powerCycles)
+void SMART::parsePowerCycle(string sLine)
 {
     string search("\"power_cycle_count\": ");
     size_t found = sLine.find(search);
@@ -245,29 +206,23 @@ bool SMART::parsePowerCycles(string sLine, uint32_t &powerCycles)
     {
         sLine.erase(0, sLine.find(": ") + 2);
         sLine.erase(sLine.length() - 2, 2);
-        powerCycles = stol(sLine);
+        powerCycle = stol(sLine);
-        return true;
-    }
-    else
-    {
-        return false;
     }
 }
 
 /**
- * \brief parse temperature
+ * \brief   parse temperature
- * \param string output line of smartctl
+ * \param	string output line of smartctl
- * \param uint32_t parsed temperature
+ * \return  void
- * \return bool if parsing was possible
  */
-bool SMART::parseTemperature(string sLine, uint32_t &temperature)
+void SMART::parseTemperature(string sLine)
 {
     string search("\"current\": ");
     size_t found = sLine.find(search);
     if (found != string::npos)
     {
-        sLine.erase(0U, sLine.find(": ") + 2U);
+        sLine.erase(0, sLine.find(": ") + 2);
-        sLine.erase(sLine.length() - 1U, 2U);
+        sLine.erase(sLine.length() - 1, 2);
         if (sLine == "{")
         {
             temperature = 0U; // this drive doesn't support temperature
@@ -276,10 +231,5 @@ bool SMART::parseTemperature(string sLine, uint32_t &temperature)
         {
             temperature = stol(sLine);
         }
-        return true;
-    }
-    else
-    {
-        return false;
     }
 }

src/tui.cpp

@@ -43,21 +43,11 @@ void TUI::initTUI()
 
     init_pair(COLOR_AREA_ENTRY_EVEN, COLOR_BLACK, COLOR_WHITE);
     init_pair(COLOR_AREA_ENTRY_ODD, COLOR_BLUE, COLOR_WHITE);
-
-#ifdef DRYRUN
-    init_pair(COLOR_AREA_ENTRY_SELECTED, COLOR_WHITE, COLOR_GREEN);
-#else
     init_pair(COLOR_AREA_ENTRY_SELECTED, COLOR_WHITE, COLOR_RED);
-#endif
-
     init_pair(COLOR_AREA_OVERVIEW, COLOR_BLACK, COLOR_WHITE);
     init_pair(COLOR_AREA_DETAIL, COLOR_BLACK, COLOR_WHITE);
 
-#ifdef DRYRUN
-    mvprintw(0, 2, "reHDD - HDD refurbishing tool - GPL 3.0    DRYRUN is active! Don't use in production!");
-#else
     mvprintw(0, 2, "reHDD - HDD refurbishing tool - GPL 3.0 ");
-#endif
     Logger::logThis()->info("UI successfully initialized");
 }