release of Beta 0.2.0

Reviewed-on: #24

.gitignore

@@ -41,3 +41,4 @@
 
 reHDD
 
+reHDD.log

README.md

@@ -3,12 +3,77 @@
 ## Useful for:
 * checking new drives for the first time
 * checking used drives for their next live
-* deleting a drive securely
+* deleting a drive securely via overwriting
 
-## planned Features:
+## Screenshot 
+![alt text](https://git.mosad.xyz/localhorst/reHDD/raw/commit/95828afcc2e417b9cb64a4add98ae9c3c7628e84/doc/screenshot.png "Screenshot")
 
-* search for new attached Hard Drives via USB
+## Debian Build Notes
-* display Hard Drive Manufacturer, Model, Rotation Rate and Capacity
+
-* Check S.M.A.R.T. values and make an 'passed' or 'not passed' decision
+* apt-get install ncurses-dev git make g++ 
-* If passed, wipe the data securely
+* clone repo
+* make release
+
+## Create Standalone with Debian
+
+Instructions how to create a standalone machine that boots directly to reHDD. This is aimed for production use, like several drives a day shredding.
+
+### Software requirements
+
+* apt-get install hwinfo
+* wget http://ftp.de.debian.org/debian/pool/main/s/smartmontools/smartmontools_7.1-1_amd64.deb
+* dpkg --install smartmontools_7.1-1_amd64.deb 
+
+### Start reHDD after boot without login (as a tty shell)
+
+nano /etc/systemd/system/reHDD.service
+```
+[Unit]
+Description=Custom user interface on tty1
+Conflicts=getty@tty1.service
+Before=getty.target
+
+[Service]
+WorkingDirectory=/root/reHDD
+ExecStart=/root/reHDD/reHDD
+StandardInput=tty
+StandardOutput=tty
+Restart=always
+RestartSec=1
+UtmpIdentifier=tty1
+TTYPath=/dev/tty1
+TTYReset=yes
+TTYVHangup=yes
+TTYVTDisallocate=yes
+SendSIGHUP=yes
+
+[Install]
+WantedBy=multi-user.target
+```
+
+nano /etc/systemd/system/reHDDSettings.service 
+```
+[Service]
+Type=oneshot
+RemainAfterExit=yes
+ExecStart=/usr/bin/bash /root/reHDDSettings.sh
+
+[Install]
+WantedBy=multi-user.target
+```
+
+nano /root/reHDDSettings.sh
+```
+#!/bin/bash
+dmesg -n 1 #disable overlay if a drive is attached/detached
+rm -f /root/reHDD/reHDD.log
+```
+Make sure the binary reHDD is in /root/reHDD/
+Add your system drive in /root/reHDD/ignoreDrives.conf like:
+``` /dev/sdX:e102f49d-5ed5-462b-94c5-ef66a4345671```
+Get your UUID via blkid /dev/sdX
+
+systemctl enable reHDD.service
+
+systemctl enable reHDDSettings.service
 

astyle.sh

@@ -0,0 +1,24 @@
+#! /bin/bash
+
+echo starting astyle for $PWD
+
+astyle --style=gnu src/*.cpp
+rm -f src/*.orig
+
+astyle --style=gnu src/shred/*.cpp
+rm -f src/shred/*.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//shred/*.h
+rm -f include//shred/*.orig
+
+astyle --style=gnu include//logger/*.h
+rm -f include//logger/*.orig
+
+echo finished astyle for $PWD

doc/update.sh

@@ -0,0 +1,26 @@
+#! /usr/bin/bash
+
+echo starting update
+
+FILE=./ignoreDrives.conf
+if test -f "$FILE"; then
+   echo backup exits
+else
+    cp reHDD/ignoreDrives.conf ./ignoreDrives.conf
+fi
+
+cd  reHDD
+
+git reset
+
+git stash force 
+
+git stash
+
+git checkout master
+
+git pull
+
+make release
+
+cp ../ignoreDrives.conf ./

include/drive.h

@@ -18,7 +18,8 @@ public:
                     SHRED_SELECTED,
                     SHRED_ACTIVE,
                     DELETE_SELECTED,
-                    DELETE_ACTIVE
+                    DELETE_ACTIVE,
+                    FROZEN
                    } state;
 
     bool bWasShredded = false;
@@ -34,9 +35,11 @@ private:
     uint32_t u32ErrorCount = 0U;
     uint32_t u32PowerOnHours = 0U; //in hours
     uint32_t u32PowerCycles = 0U;
-
+    time_t u32Timestamp = 0U; //unix timestamp for detecting a frozen drive
     double d32TaskPercentage = 0U; //in percent for Shred (1 to 100)
 
+private:
+    void setTimestamp();
 
 protected:
 
@@ -54,6 +57,7 @@ public:
     uint32_t getErrorCount(void);
     uint32_t getPowerOnHours(void); //in hours
     uint32_t getPowerCycles(void);
+    void checkFrozenDrive(void);
 
     void setDriveSMARTData( string modelFamily,
                             string modelName,

include/reHDD.h

@@ -1,6 +1,6 @@
 /**
  * @file    reHDD.h
- * @brief   represent
+ * @brief   app logic header
  * @author  hendrik schutter
  * @date    01.05.2020
  */
@@ -8,15 +8,13 @@
 #ifndef REHDD_H_
 #define REHDD_H_
 
-//#define DRYRUN
+#define REHDD_VERSION "bV0.2.0"
 
+// Drive handling Settings
 #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 SHRED_ITERATIONS 3
-#define SHRED_ITERATIONS 1
+#define FROZEN_TIMEOUT 10 //After this timeout (minutes) the drive will be marked as frozen
-
-#define READ 0
-#define WRITE 1
 
 // Logger Settings
 #define LOG_PATH "./reHDD.log"
@@ -30,11 +28,19 @@
 #define LOG_LEVEL_LOW   //log only user actions and tasks 
 #endif
 
+// Logic
+//#define DRYRUN //don´t touch the drives
+#define FROZEN_ALERT //show alert if drive is frozen
+
+//IPC pipes
+#define READ 0
+#define WRITE 1
+
 #include <iostream>
 #include <string>
 #include <fstream>
 #include <tuple>
-#include <vector>
+#include <list>
 #include <time.h>
 #include <chrono>
 #include <curses.h>
@@ -74,14 +80,16 @@ public:
 
 private:
 
-    static void searchDrives(vector <Drive>* pvecDrives);
+    static void searchDrives(list <Drive>* plistDrives);
-    static void printDrives(vector <Drive>* pvecDrives);
+    static void printDrives(list <Drive>* plistDrives);
-    static  void filterIgnoredDrives(vector <Drive>* pvecDrives);
+    static  void filterIgnoredDrives(list <Drive>* plistDrives);
-    static void filterNewDrives(vector <Drive>* pvecOldDrives, vector <Drive>* pvecNewDrives);
+    static void filterNewDrives(list <Drive>* plistOldDrives, list <Drive>* plistNewDrives);
-    static void addSMARTData(vector <Drive>* pvecDrives);
+    static void addSMARTData(list <Drive>* plistDrives);
     static void ThreadScannDevices();
     static void ThreadUserInput();
     static void ThreadShred();
+    static void ThreadDelete();
+    static void ThreadCheckFrozenDrives();
     static void handleArrowKey(TUI::UserInput userInput);
     static void handleEnter();
     static void handleESC();
@@ -89,5 +97,4 @@ private:
     static Drive* getSelectedDrive();
 };
 
-
 #endif  // REHDD_H_

include/tui.h

@@ -36,7 +36,7 @@ public:
 
     static void initTUI();
 
-    void updateTUI(vector <Drive>* pvecDrives,  uint8_t u8SelectedEntry);
+    void updateTUI(list <Drive>* plistDrives,  uint8_t u8SelectedEntry);
 
     static enum UserInput readUserInput();
 
@@ -45,21 +45,23 @@ private:
     static string sRamUsage;
     static string sLocalTime;
 
-
     WINDOW* overview;
     WINDOW* systemview;
     WINDOW* detailview;
     WINDOW* menuview;
     WINDOW* dialog;
+    WINDOW* smartWarning;
 
     static void centerTitle(WINDOW *pwin, const char * title);
     static WINDOW *createOverViewWindow( int iXSize, int iYSize);
     static WINDOW *createDetailViewWindow( int iXSize, int iYSize, int iXStart, Drive drive);
     static WINDOW *overwriteDetailViewWindow( int iXSize, int iYSize, int iXStart);
-    static WINDOW *createEntryWindow(int iXSize, int iYSize, int iXStart, int iYStart,string sModelFamily, string sModelName, string sCapacity, string sState, bool bSelected);
+    static WINDOW *createEntryWindow(int iXSize, int iYSize, int iXStart, int iYStart, string sModelFamily, string sModelName, string sCapacity, string sState, bool bSelected);
-    static WINDOW *createSystemStats(int iXSize, int iYSize, int iYStart);
+    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* createFrozenWarning(int iXSize, int iYSize, int iXStart, int iYStart, string sPath, string sModelFamily, string sModelName, string sSerial, string sProgress);
+    static WINDOW* createSmartWarning(int iXSize, int iYSize, int iXStart, int iYStart, string sPath, uint32_t u32PowerOnHours, uint32_t u32PowerCycles,  uint32_t u32ErrorCount);
 
     void displaySelectedDrive(Drive drive, int stdscrX, int stdscrY);
 

makefile

@@ -167,6 +167,7 @@ clean:
 	@echo "Deleting directories"
 	@$(RM) -r build
 	@$(RM) -r bin
+	@$(RM) -f reHDD.log
 
 # Main rule, checks the executable and symlinks to the output
 all: $(BIN_PATH)/$(BIN_NAME)
@@ -200,5 +201,6 @@ docs:
 	@$(RM) -r $(DOCDIR)/html
 	@doxygen $(DOCDIR)/doxyfile
 	
-	
+.PHONY: style	
-	
+style:
+	@bash astyle.sh

out.txt

@@ -1 +0,0 @@
-date

src/delete.cpp

@@ -21,6 +21,7 @@ void Delete::deleteDrive(Drive* drive)
 #ifndef DRYRUN
     string sCMD = ("wipefs -af ");
     sCMD.append(drive->getPath());
+    sCMD.append("*");
 #endif
 
 #ifdef DRYRUN

src/drive.cpp

@@ -69,14 +69,19 @@ string Drive::sErrorCountToText()
 
 string Drive::sPowerOnHoursToText()
 {
+    double dDays = 0U;
     double dYears = 0U;
     uint32_t u32Hours = getPowerOnHours();
-    stringstream stream;
+    stringstream streamDays;
+    stringstream streamYears;
 
+    dDays = (double) ((double)u32Hours/(double)24U);
     dYears = (double) ((double)u32Hours/(double)8760U);
 
-    stream << fixed << setprecision(2) << dYears;
+    streamDays << fixed << setprecision(0) << dDays;
-    string sRet = to_string(getPowerOnHours()) + " hours or " + stream.str() + " years";
+    streamYears << fixed << setprecision(1) << dYears;
+
+    string sRet = to_string(getPowerOnHours()) + " hours or " + streamDays.str() + " days or " + streamYears.str() + " years";
 
     return sRet;
 }
@@ -91,6 +96,7 @@ void Drive::setTaskPercentage(double d32TaskPercentage)
     if(d32TaskPercentage <= 100)
         {
             this->d32TaskPercentage = d32TaskPercentage;
+            this->setTimestamp(); //set timestamp for this progress for detecting a frozen drive
         }
 }
 double Drive::getTaskPercentage(void)
@@ -126,3 +132,23 @@ void Drive::setDriveSMARTData( string modelFamily,
     u32PowerOnHours = powerOnHours;
     u32PowerCycles = powerCycle;
 }
+
+
+void Drive::setTimestamp()
+{
+    time(&this->u32Timestamp);
+}
+
+void Drive::checkFrozenDrive(void)
+{
+    time_t u32localtime;
+    time(&u32localtime);
+
+    if((u32localtime - this->u32Timestamp) >= (FROZEN_TIMEOUT*60) && (this->u32Timestamp > 0))
+        {
+            Logger::logThis()->warning("Drive Frozen: " + this->getModelName() + " " + this->getSerial());
+            this->bWasDeleteted = false;
+            this->bWasShredded = false;
+            this->state = Drive::FROZEN;
+        }
+}

src/reHDD.cpp

@@ -13,9 +13,9 @@ static int fdShredInformPipe[2];//File descriptor for pipe that informs if a wip
 
 static std::mutex mxScannDrives;
 
-vector <Drive> vecNewDrives; //store found drives that are updated every 5sec
+list <Drive> listNewDrives; //store found drives that are updated every 5sec
 
-static vector <Drive> vecDrives; //stores all drive data from scann thread
+static list <Drive> listDrives; //stores all drive data from scann thread
 
 TUI *ui;
 
@@ -23,8 +23,6 @@ static  uint8_t u8SelectedEntry;
 
 static fd_set selectSet;
 
-//static struct TUI::MenuState menustate;
-
 /**
  * \brief   app constructor
  * \param	void
@@ -33,8 +31,6 @@ static fd_set selectSet;
 reHDD::reHDD(void)
 {
     u8SelectedEntry = 0U;
-
-    vecDrives.reserve(128);
 }
 
 /**
@@ -52,6 +48,7 @@ void reHDD::app_logic(void)
 
     thread thDevices(ThreadScannDevices); //start thread that scanns for drives
     thread thUserInput(ThreadUserInput); //start thread that reads user input
+    thread thCheckFrozenDrives(ThreadCheckFrozenDrives); //start thread that checks timeout for drives
 
     while(1)
         {
@@ -61,32 +58,37 @@ void reHDD::app_logic(void)
 
             select(FD_SETSIZE, &selectSet, NULL, NULL, NULL);
 
-            if( FD_ISSET(fdNewDrivesInformPipe[0], &selectSet))
+            if(FD_ISSET(fdNewDrivesInformPipe[0], &selectSet))
                 {
+                    mxScannDrives.lock();
                     char dummy;
                     read (fdNewDrivesInformPipe[0],&dummy,1);
-                    mxScannDrives.lock();
+                    filterNewDrives(&listDrives, &listNewDrives); //filter and copy to app logic vector
-                    filterNewDrives(&vecDrives, &vecNewDrives); //filter and copy to app logic vector
+                    printDrives(&listDrives);
-                    printDrives(&vecDrives);
                     mxScannDrives.unlock();
                 }
-
+            if(FD_ISSET(fdShredInformPipe[0], &selectSet))
-            if (FD_ISSET(fdShredInformPipe[0], &selectSet))
                 {
                     char dummy;
                     read (fdShredInformPipe[0],&dummy,1);
+#ifdef LOG_LEVEL_HIGH
+                    Logger::logThis()->info("got progress signal from a shred task");
+#endif
                 }
-            ui->updateTUI(&vecDrives, u8SelectedEntry);
+            ui->updateTUI(&listDrives, u8SelectedEntry);
         } //endless loop
     thDevices.join();
     thUserInput.join();
+    thCheckFrozenDrives.join();
 }
 
 Drive* reHDD::getSelectedDrive()
 {
-    if(u8SelectedEntry < vecDrives.size() )
+    if(u8SelectedEntry < listDrives.size() )
         {
-            return &(vecDrives.at(u8SelectedEntry));
+            list<Drive>::iterator it = listDrives.begin();
+            advance(it, u8SelectedEntry);
+            return &(*it);
         }
     else
         {
@@ -100,16 +102,33 @@ void reHDD::ThreadScannDevices()
     while(true)
         {
             mxScannDrives.lock();
-            vecNewDrives.clear();
+            listNewDrives.clear();
-            searchDrives(&vecNewDrives);           //search for new drives and store them in list
+            searchDrives(&listNewDrives);           //search for new drives and store them in list
-            filterIgnoredDrives(&vecNewDrives);    //filter out ignored drives
+            filterIgnoredDrives(&listNewDrives);    //filter out ignored drives
-            addSMARTData(&vecNewDrives);           //add S.M.A.R.T. Data to the drives
+            addSMARTData(&listNewDrives);           //add S.M.A.R.T. Data to the drives
             mxScannDrives.unlock();
             write(fdNewDrivesInformPipe[1], "A",1);
             sleep(5); //sleep 5 sec
         }
 }
 
+void reHDD::ThreadCheckFrozenDrives()
+{
+    while(true)
+        {
+            mxScannDrives.lock();
+            for(auto it = begin(listDrives); it != end(listDrives); ++it)
+                {
+                    if(it->state == Drive::SHRED_ACTIVE)
+                        {
+                            it->checkFrozenDrive();
+                        }
+                }
+            mxScannDrives.unlock();
+            sleep(13); //sleep 13 sec
+        }
+}
+
 void reHDD::ThreadUserInput()
 {
     while(true)
@@ -120,12 +139,12 @@ void reHDD::ThreadUserInput()
                 case TUI::UserInput::DownKey:
                     //cout << "Down" << endl;
                     handleArrowKey(TUI::UserInput::DownKey);
-                    ui->updateTUI(&vecDrives, u8SelectedEntry);
+                    ui->updateTUI(&listDrives, u8SelectedEntry);
                     break;
                 case TUI::UserInput::UpKey:
                     //cout << "Up" << endl;
                     handleArrowKey(TUI::UserInput::UpKey);
-                    ui->updateTUI(&vecDrives, u8SelectedEntry);
+                    ui->updateTUI(&listDrives, u8SelectedEntry);
                     break;
                 case TUI::UserInput::Undefined:
                     //cout << "Undefined" << endl;
@@ -133,7 +152,7 @@ void reHDD::ThreadUserInput()
                 case TUI::UserInput::Abort:
                     //cout << "Abort" << endl;
                     handleAbort();
-                    ui->updateTUI(&vecDrives, u8SelectedEntry);
+                    ui->updateTUI(&listDrives, u8SelectedEntry);
                     break;
                 case TUI::UserInput::Delete:
                     //cout << "Delete" << endl;
@@ -145,7 +164,7 @@ void reHDD::ThreadUserInput()
                                     getSelectedDrive()->state = Drive::DELETE_SELECTED;
                                 }
                         }
-                    ui->updateTUI(&vecDrives, u8SelectedEntry);
+                    ui->updateTUI(&listDrives, u8SelectedEntry);
                     break;
                 case TUI::UserInput::Shred:
                     //cout << "Shred" << endl;
@@ -157,17 +176,17 @@ void reHDD::ThreadUserInput()
                                     getSelectedDrive()->state = Drive::SHRED_SELECTED;
                                 }
                         }
-                    ui->updateTUI(&vecDrives, u8SelectedEntry);
+                    ui->updateTUI(&listDrives, u8SelectedEntry);
                     break;
                 case TUI::UserInput::Enter:
                     //cout << "Enter" << endl;
                     handleEnter();
-                    ui->updateTUI(&vecDrives, u8SelectedEntry);
+                    ui->updateTUI(&listDrives, u8SelectedEntry);
                     break;
                 case TUI::UserInput::ESC:
                     //cout << "ESC" << endl;
                     handleESC();
-                    ui->updateTUI(&vecDrives, u8SelectedEntry);
+                    ui->updateTUI(&listDrives, u8SelectedEntry);
                     break;
                 default:
                     break;
@@ -182,24 +201,36 @@ void reHDD::ThreadShred()
             Shred* pShredTask = new Shred(); //create new shred task
             pShredTask->shredDrive(getSelectedDrive(), &fdShredInformPipe[1]); //start new shred task
             delete pShredTask; //delete shred task
-            ui->updateTUI(&vecDrives, u8SelectedEntry);
+            ui->updateTUI(&listDrives, u8SelectedEntry);
         }
 }
 
-void reHDD::filterNewDrives(vector <Drive>* pvecOldDrives, vector <Drive>* pvecNewDrives)
+void reHDD::ThreadDelete()
 {
-    vector <Drive>::iterator itOld; //Iterator for current (old) drive list
+    if (getSelectedDrive() != nullptr)
-    vector <Drive>::iterator itNew; //Iterator for new drive list that was created from to scann thread
+        {
+            Delete::deleteDrive(getSelectedDrive()); //blocking, no thread
+            getSelectedDrive()->state = Drive::TaskState::NONE; //delete finished
+            getSelectedDrive()->bWasDeleteted = true;
+            Logger::logThis()->info("Finished delete for: " + getSelectedDrive()->getModelName() + "-" +  getSelectedDrive()->getSerial());
+            ui->updateTUI(&listDrives, u8SelectedEntry);
+        }
+}
+
+void reHDD::filterNewDrives(list <Drive>* plistOldDrives, list <Drive>* plistNewDrives)
+{
+    list <Drive>::iterator itOld; //Iterator for current (old) drive list
+    list <Drive>::iterator itNew; //Iterator for new drive list that was created from to scann thread
 
     //remove offline old drives from previously run
-    for (itOld = pvecOldDrives->begin(); itOld != pvecOldDrives->end();)
+    for (itOld = plistOldDrives->begin(); itOld != plistOldDrives->end();)
         {
             if(itOld->bIsOffline == true)
                 {
                     Logger::logThis()->warning("Offline drive found: " + itOld->getPath());
-                    itOld = pvecOldDrives->erase(itOld);
+                    itOld = plistOldDrives->erase(itOld);
                     /*
-                    if(pvecOldDrives->size() > 0){ //This can be a risk if the user starts a task for the selected drive and the selected drive changes
+                    if(plistOldDrives->size() > 0){ //This can be a risk if the user starts a task for the selected drive and the selected drive changes
                         u8SelectedEntry = 0U;
                     }
                     */
@@ -211,18 +242,18 @@ void reHDD::filterNewDrives(vector <Drive>* pvecOldDrives, vector <Drive>* pvecN
         }
 
     //search offline drives and mark them
-    for (itOld = pvecOldDrives->begin(); itOld != pvecOldDrives->end(); ++itOld)
+    for (itOld = plistOldDrives->begin(); itOld != plistOldDrives->end(); ++itOld)
         {
             itOld->bIsOffline = true; //set offline befor seachring in the new list
-            for (itNew = pvecNewDrives->begin(); itNew != pvecNewDrives->end();)
+            for (itNew = plistNewDrives->begin(); itNew != plistNewDrives->end();)
                 {
-                    if(itOld->getSerial() == itNew->getSerial())
+                    if((itOld->getSerial() == itNew->getSerial()) || (itOld->getPath() == itNew->getPath()))
                         {
                             itOld->bIsOffline = false; //drive is still attached
 #ifdef LOG_LEVEL_HIGH
                             Logger::logThis()->info("Delete new drive, because allready attached: " + itNew->getModelName());
 #endif
-                            itNew = pvecNewDrives->erase(itNew); //This drive is allready attached, remove from new list
+                            itNew = plistNewDrives->erase(itNew); //This drive is allready attached, remove from new list
                         }
                     else
                         {
@@ -232,7 +263,7 @@ void reHDD::filterNewDrives(vector <Drive>* pvecOldDrives, vector <Drive>* pvecN
         }
 
     //mark offline old drives
-    for (itOld = pvecOldDrives->begin(); itOld != pvecOldDrives->end(); ++itOld)
+    for (itOld = plistOldDrives->begin(); itOld != plistOldDrives->end(); ++itOld)
         {
             if(itOld->bIsOffline == true)
                 {
@@ -243,41 +274,42 @@ void reHDD::filterNewDrives(vector <Drive>* pvecOldDrives, vector <Drive>* pvecN
         }
 
     //add new drives to drive list
-    for (itNew = pvecNewDrives->begin(); itNew != pvecNewDrives->end(); ++itNew)
+    for (itNew = plistNewDrives->begin(); itNew != plistNewDrives->end(); ++itNew)
         {
-            pvecOldDrives->push_back(pvecNewDrives->at(itNew - pvecNewDrives->begin()));
+            plistOldDrives->push_back(*itNew);
             Logger::logThis()->info("Add new drive: " + itNew->getModelName());
         }
-    pvecNewDrives->clear();
+    plistNewDrives->clear();
 }
 
 /**
  * \brief   search attached drives on /dev/sd*
- * \param	pointer of vector <Drive>* pvecDrives
+ * \param	pointer of list <Drive>* plistDrives
  * \return  void
  */
-void reHDD::searchDrives(vector <Drive>* pvecDrives)
+void reHDD::searchDrives(list <Drive>* plistDrives)
 {
     // cout << "search drives ..." << endl;
     Logger::logThis()->info("-->    search drives   <--");
     char * cLine = NULL;
     size_t len = 0;
 
-    FILE* outputfileHwinfo = popen("hwinfo --short --disk", "r");
+    FILE* outputfileHwinfo = popen("ls -1 /dev/sd*", "r");
 
     if (outputfileHwinfo == NULL)
         {
+            Logger::logThis()->error("Unable to scann attached drives");
             exit(EXIT_FAILURE);
         }
 
     while ((getline(&cLine, &len, outputfileHwinfo)) != -1)
         {
-            if (string(cLine).find("/dev/sd") != string::npos)
+            if (string(cLine).length() == 9)
                 {
-                    Drive* tmpDrive = new Drive(string(cLine).substr (2,8));
+                    Drive* tmpDrive = new Drive(string(cLine).substr(0, 8));
                     tmpDrive->state = Drive::NONE;
                     tmpDrive->bIsOffline = false;
-                    pvecDrives->push_back(*tmpDrive);
+                    plistDrives->push_back(*tmpDrive);
                 }
         }
     fclose(outputfileHwinfo);
@@ -285,16 +317,16 @@ void reHDD::searchDrives(vector <Drive>* pvecDrives)
 
 /**
  * \brief   filter out drives that are listed in "ignoreDrives.conf"
- * \param	pointer of vector <Drive>* pvecDrives
+ * \param	pointer of list <Drive>* plistDrives
  * \return  void
  */
-void reHDD::filterIgnoredDrives(vector <Drive>* pvecDrives)
+void reHDD::filterIgnoredDrives(list <Drive>* plistDrives)
 {
     string sDelimiter = ":";
     string sIgnoredDrivePath;
     string sIgnoredDriveUUID;
 
-    vector<tuple<string, string>> vtlIgnoredDevices; //store drives from ingnore file
+    list<tuple<string, string>> vtlIgnoredDevices; //store drives from ingnore file
 
     ifstream input( "ignoreDrives.conf" ); //read ingnore file
 
@@ -317,8 +349,8 @@ void reHDD::filterIgnoredDrives(vector <Drive>* pvecDrives)
     //loop through found entries in ingnore file
     for(auto row : vtlIgnoredDevices)
         {
-            vector <Drive>::iterator it;
+            list <Drive>::iterator it;
-            for (it = pvecDrives->begin(); it != pvecDrives->end(); ++it)
+            for (it = plistDrives->begin(); it != plistDrives->end(); ++it)
                 {
                     string sUUID;
                     if (!get<0>(row).compare(it->getPath())) //find same drive based on path
@@ -360,7 +392,7 @@ void reHDD::filterIgnoredDrives(vector <Drive>* pvecDrives)
 #ifdef LOG_LEVEL_HIGH
                                     Logger::logThis()->info("same uuid found than in ignore file --> ignore this drive: " + it->getPath());
 #endif
-                                    it = pvecDrives->erase(it);
+                                    it = plistDrives->erase(it);
                                     it--;
                                 }
                         }
@@ -370,16 +402,17 @@ void reHDD::filterIgnoredDrives(vector <Drive>* pvecDrives)
 
 /**
  * \brief   print drives with all information
- * \param	pointer of vector <Drive>* pvecDrives
+ * \param	pointer of list <Drive>* plistDrives
  * \return  void
  */
-void reHDD::printDrives(vector <Drive>* pvecDrives)
+void reHDD::printDrives(list <Drive>* plistDrives)
 {
 #ifdef LOG_LEVEL_HIGH
-    Logger::logThis()->info("------------DRIVES---------------");
+    Logger::logThis()->info("------------DRIVES START------------");
     //cout << "------------DRIVES---------------" << endl;
-    vector <Drive>::iterator it;
+    list <Drive>::iterator it;
-    for (it = pvecDrives->begin(); it != pvecDrives->end(); ++it)
+    uint8_t u8Index = 0;
+    for (it = plistDrives->begin(); it != plistDrives->end(); ++it)
         {
             /*
                cout << "        Drive: " << distance(pvecDrives->begin(), it) << endl;
@@ -394,34 +427,32 @@ void reHDD::printDrives(vector <Drive>* pvecDrives)
                cout << endl;*/
 
             ostringstream address;
-            address << (void const *)&pvecDrives->at(it - pvecDrives->begin());
+            address << (void const *)&(*it);
-
+            Logger::logThis()->info(to_string(u8Index++) + ": " + it->getPath() + " - " + it->getModelFamily() + " - " + it->getSerial() + " @" + address.str());
-
-            Logger::logThis()->info(to_string(it - pvecDrives->begin()) + ": " + it->getPath() + " - " + it->getModelFamily() + " - " + it->getSerial() + " @" + address.str());
         }
-    Logger::logThis()->info("---------------------------------");
+    Logger::logThis()->info("------------DRIVES END--------------");
     //cout << "---------------------------------" << endl;
 #endif
 }
 
 /**
  * \brief   add S.M.A.R.T data from SMART
- * \param	pointer of vector <Drive>* pvecDrives
+ * \param	pointer of list <Drive>* plistDrives
  * \return  void
  */
-void reHDD::addSMARTData(vector <Drive>* pvecDrives)
+void reHDD::addSMARTData(list <Drive>* plistDrives)
 {
-    vector <Drive>::iterator it;
+    list <Drive>::iterator it;
-    for (it = pvecDrives->begin(); it != pvecDrives->end(); ++it)
+    for (it = plistDrives->begin(); it != plistDrives->end(); ++it)
         {
-            Drive* pTmpDrive = iterator_to_pointer<Drive, std::vector<Drive>::iterator > (it);
+            Drive* pTmpDrive = iterator_to_pointer<Drive, std::list<Drive>::iterator > (it);
             SMART::readSMARTData(pTmpDrive);
         }
 }
 
 void reHDD::handleArrowKey(TUI::UserInput userInput)
 {
-    int8_t u8EntrySize = (int8_t) vecDrives.size();
+    int8_t u8EntrySize = (int8_t) listDrives.size();
     switch (userInput)
         {
         case TUI::UserInput::DownKey:
@@ -466,10 +497,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
-                    Delete::deleteDrive(getSelectedDrive()); //blocking, no thread
+                    thread(ThreadDelete).detach();
-                    getSelectedDrive()->state = Drive::TaskState::NONE; //delete finished
-                    getSelectedDrive()->bWasDeleteted = true;
-                    Logger::logThis()->info("Finished delete for: " + getSelectedDrive()->getModelName() + "-" +  getSelectedDrive()->getSerial());
                 }
         }
 }

src/shred/shred.cpp

@@ -21,6 +21,7 @@ struct tfnge_stream
 };
 
 static struct tfnge_stream tfnge;
+#endif
 
 Shred::Shred()
 {
@@ -34,7 +35,7 @@ Shred::~Shred()
 }
 
 
-#endif
+
 /**
  * \brief   shred drive with shred
  * \param	pointer of Drive instance
@@ -51,7 +52,6 @@ void Shred::shredDrive(Drive* drive, int* ipSignalFd)
                 }
             drive->setTaskPercentage(i+0.05);
             write(*ipSignalFd, "A",1);
-
             usleep(20000);
         }
 #endif

src/tui.cpp

@@ -50,27 +50,28 @@ void TUI::initTUI()
     Logger::logThis()->info("UI successfully initialized");
 }
 
-void TUI::updateTUI(vector <Drive>* pvecDrives, uint8_t u8SelectedEntry)
+void TUI::updateTUI(list <Drive>* plistDrives, uint8_t u8SelectedEntry)
 {
     mxUIrefresh.lock();
-    int stdscrX, stdscrY;
+    uint16_t u16StdscrX, u16StdscrY;
-    getmaxyx(stdscr, stdscrY, stdscrX);
+    getmaxyx(stdscr, u16StdscrY, u16StdscrX);
 
     init_pair(COLOR_AREA_STDSCR,COLOR_WHITE, COLOR_BLUE);
     wbkgd(stdscr, COLOR_PAIR(COLOR_AREA_STDSCR));
 
     refresh();
 
-    overview=createOverViewWindow((int)(stdscrX/3), (stdscrY-15));
+    overview=createOverViewWindow((int)(u16StdscrX/3), (u16StdscrY-3));
     wrefresh(overview);
 
-    systemview=createSystemStats((int)(stdscrX/3), 10, (stdscrY-11));
+    systemview=createSystemStats((int)(u16StdscrX/3), 10, u16StdscrX-(int)(u16StdscrX/3)-2, (u16StdscrY-11 ));
     wrefresh(systemview);
 
     delwin(detailview);
 
-    vector <Drive>::iterator it;
+    list <Drive>::iterator it;
-    for (it = pvecDrives->begin(); it != pvecDrives->end(); ++it)
+    uint8_t u8Index = 0U;
+    for (it = plistDrives->begin(); it != plistDrives->end(); ++it)
         {
             string sModelFamily = it->getModelFamily();
             string sModelName = it->getModelName();
@@ -79,10 +80,17 @@ void TUI::updateTUI(vector <Drive>* pvecDrives, uint8_t u8SelectedEntry)
 
             bool bSelectedEntry = false;
 
-            if(u8SelectedEntry == (it - pvecDrives->begin()))
+            if(u8SelectedEntry == u8Index)
                 {
                     bSelectedEntry = true; //mark this drive in entries list
-                    displaySelectedDrive(pvecDrives->at(u8SelectedEntry), stdscrX, stdscrY);
+                    displaySelectedDrive(*it, u16StdscrX, u16StdscrY);
+
+                    if((it->getPowerOnHours() >= WORSE_HOURS) || (it->getPowerCycles() >= WORSE_POWERUP) || (it->getErrorCount() > 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());
+                            wrefresh(smartWarning);
+                        }
                 }
 
             stringstream stream;
@@ -111,15 +119,27 @@ void TUI::updateTUI(vector <Drive>* pvecDrives, uint8_t u8SelectedEntry)
                             sState = "SHREDDED"; //mark drive as shreded previously, overwrite if deleted
                         }
                     break;
+                case Drive::FROZEN:
+                    stream << fixed << setprecision(2) << (it->getTaskPercentage());
+#ifdef FROZEN_ALERT
+                    if(bSelectedEntry)
+                        {
+                            dialog=createFrozenWarning(70, 16, ((u16StdscrX)-(int)(u16StdscrX/2)-20),(int)(u16StdscrY/2)-8, it->getPath(), it->getModelFamily(), it->getModelName(), it->getSerial(), stream.str() + "%");
+                            wrefresh(dialog);
+                        }
+#endif
+                    sState = "FROZEN " + stream.str() + "%"; //mark drive as frozen and reached progress
+                    break;
                 default:
                     break;
                 }
 
-            WINDOW * tmp = createEntryWindow( ((int)(stdscrX/3) - 2), 5, 3, (5* (it - pvecDrives->begin()) )+3, sModelFamily, sModelName, sCapacity, sState, bSelectedEntry);
+            WINDOW * tmp = createEntryWindow( ((int)(u16StdscrX/3) - 2), 5, 3, (5* (u8Index) )+3, sModelFamily, sModelName, sCapacity, sState, bSelectedEntry);
             wrefresh(tmp);
+            u8Index++;
         }//end loop though drives
 
-    if(pvecDrives->size() == 0)
+    if(plistDrives->size() == 0)
         {
             //no selected drive present
             Logger::logThis()->warning("no selected drive present");
@@ -130,10 +150,10 @@ void TUI::updateTUI(vector <Drive>* pvecDrives, uint8_t u8SelectedEntry)
             menustate.bDelete = false;
             menustate.bShred = false;
 
-            menuview=createMenuView(((stdscrX)-(int)(stdscrX/3)-7), 10, (int)(stdscrX/3)+5,(stdscrY-11), menustate);
+            menuview=createMenuView(((int)(u16StdscrX/3)-10 ), 10, (int)(u16StdscrX/3)+5,(u16StdscrY-11), menustate);
             wrefresh(menuview);
 
-            detailview=overwriteDetailViewWindow(((stdscrX)-(int)(stdscrX/3)-7), (stdscrY-15), (int)(stdscrX/3)+5);
+            detailview=overwriteDetailViewWindow(((u16StdscrX)-(int)(u16StdscrX/3)-7), (u16StdscrY-15), (int)(u16StdscrX/3)+5);
             wrefresh(detailview);
         }
 
@@ -228,38 +248,9 @@ WINDOW* TUI::createDetailViewWindow( int iXSize, int iYSize, int iXStart, Drive
 
     attroff(COLOR_PAIR(COLOR_AREA_DETAIL));
 
-    if(drive.getPowerOnHours() >= WORSE_HOURS)
-        {
-            mvwaddstr(newWindow,u16Line++, 3, "------------> WARNING: OPERATING HOURS <-----------");
     mvwaddstr(newWindow,u16Line++, 3, sPowerOnHours.c_str());
-            mvwaddstr(newWindow,u16Line++, 3, "---------------------------------------------------");
-        }
-    else
-        {
-            mvwaddstr(newWindow,u16Line++, 3, sPowerOnHours.c_str());
-        }
-
-    if(drive.getPowerCycles() >= WORSE_POWERUP)
-        {
-            mvwaddstr(newWindow,u16Line++, 3, "------------> WARNING: POWER-ON <------------------");
     mvwaddstr(newWindow,u16Line++, 3, sPowerCycle.c_str());
-            mvwaddstr(newWindow,u16Line++, 3, "---------------------------------------------------");
-        }
-    else
-        {
-            mvwaddstr(newWindow,u16Line++, 3, sPowerCycle.c_str());
-        }
-
-    if(drive.getErrorCount() > 0)
-        {
-            mvwaddstr(newWindow,u16Line++, 3, "------------> WARNING: S.M.A.R.T ERROR <-----------");
     mvwaddstr(newWindow,u16Line++, 3, sErrorCount.c_str());
-            mvwaddstr(newWindow,u16Line++, 3, "---------------------------------------------------");
-        }
-    else
-        {
-            mvwaddstr(newWindow,u16Line++, 3, sErrorCount.c_str());
-        }
 
     return newWindow;
 }
@@ -274,23 +265,23 @@ WINDOW* TUI::overwriteDetailViewWindow( int iXSize, int iYSize, int iXStart)
     string title = "About this tool";
     centerTitle(newWindow, title.c_str());
 
-    string sLine01 =  "Path: NextLine        ";
+    string sLine01 =  "reHDD - hard drive refurbishing tool";
-    string sLine02 =  "Path: NextLine        ";
+    string sLine02 =  "Version: " + string(REHDD_VERSION);
-    string sLine03 =  "Path: NextLine        ";
+    string sLine03 =  "Available under GPL 3.0";
-    string sLine04 =  "Path: NextLine        ";
+    string sLine04 =  "https://git.mosad.xyz/localhorst/reHDD";
-    string sLine05 =  "Path: NextLine        ";
+    string sLine05 =  "Delete: Wipe format table - this is NOT secure";
-    string sLine06 =  "Path: NextLine        ";
+    string sLine06 =  "Shred: Overwite drive " + to_string(SHRED_ITERATIONS) + " iterations - this is secure";
-    string sLine07 =  "Path: NextLine        ";
 
     uint16_t u16Line = 5;
 
     mvwaddstr(newWindow,u16Line++, (iXSize/2)-(sLine01.size()/2), sLine01.c_str());
     mvwaddstr(newWindow,u16Line++, (iXSize/2)-(sLine02.size()/2), sLine02.c_str());
+    u16Line++;
     mvwaddstr(newWindow,u16Line++, (iXSize/2)-(sLine03.size()/2), sLine03.c_str());
     mvwaddstr(newWindow,u16Line++, (iXSize/2)-(sLine04.size()/2), sLine04.c_str());
+    u16Line++;
     mvwaddstr(newWindow,u16Line++, (iXSize/2)-(sLine05.size()/2), sLine05.c_str());
     mvwaddstr(newWindow,u16Line++, (iXSize/2)-(sLine06.size()/2), sLine06.c_str());
-    mvwaddstr(newWindow,u16Line++, (iXSize/2)-(sLine07.size()/2), sLine07.c_str());
 
     attroff(COLOR_PAIR(COLOR_AREA_DETAIL));
 
@@ -326,10 +317,10 @@ WINDOW* TUI::createEntryWindow(int iXSize, int iYSize, int iXStart, int iYStart,
     return newWindow;
 }
 
-WINDOW* TUI::createSystemStats(int iXSize, int iYSize, int iYStart)
+WINDOW* TUI::createSystemStats(int iXSize, int iYSize, int iXStart, int iYStart)
 {
     WINDOW *newWindow;
-    newWindow = newwin(iYSize, iXSize, iYStart, 2);
+    newWindow = newwin(iYSize, iXSize, iYStart, iXStart);
 
     wbkgd(newWindow, COLOR_PAIR(COLOR_AREA_OVERVIEW));
     box(newWindow, ACS_VLINE, ACS_HLINE);
@@ -344,7 +335,19 @@ WINDOW* TUI::createSystemStats(int iXSize, int iYSize, int iYStart)
     strftime(buffer,sizeof(buffer),"Date: %d-%m-%Y   Time: %H:%M",timeinfo);
     string time(buffer);
 
-    mvwaddstr(newWindow,2, 2, time.c_str());
+    string sLine01 =  "reHDD - hard drive refurbishing tool";
+    string sLine02 =  "Version: " + string(REHDD_VERSION);
+    string sLine03 =  "Available under GPL 3.0";
+    string sLine04 =  "https://git.mosad.xyz/localhorst/reHDD";
+
+    uint16_t u16Line = 2;
+
+    mvwaddstr(newWindow,u16Line++, (iXSize/2)-(sLine01.size()/2), sLine01.c_str());
+    mvwaddstr(newWindow,u16Line++, (iXSize/2)-(sLine01.size()/2), sLine02.c_str());
+    mvwaddstr(newWindow,u16Line++, (iXSize/2)-(sLine01.size()/2), sLine03.c_str());
+    mvwaddstr(newWindow,u16Line++, (iXSize/2)-(sLine01.size()/2), sLine04.c_str());
+    u16Line++;
+    mvwaddstr(newWindow,u16Line++, (iXSize/2)-(sLine01.size()/2), time.c_str());
 
     return newWindow;
 }
@@ -359,20 +362,24 @@ WINDOW* TUI::createMenuView(int iXSize, int iYSize, int iXStart, int iYStart, st
 
     centerTitle(newWindow, "Controls");
 
-
     uint16_t u16Line = 2;
 
     if(menustate.bAbort)
         {
-            mvwaddstr(newWindow,u16Line++, 3, "Press A for Abort");
+            string sLineTmp = "Press A for Abort";
+            mvwaddstr(newWindow,u16Line++, (iXSize/2)-(sLineTmp.size()/2), sLineTmp.c_str());
+            u16Line++;
         }
     if(menustate.bShred)
         {
-            mvwaddstr(newWindow,u16Line++, 3, "Press S for Shred");
+            string sLineTmp = "Press S for Shred ";
+            mvwaddstr(newWindow,u16Line++, (iXSize/2)-(sLineTmp.size()/2), sLineTmp.c_str());
+            u16Line++;
         }
     if(menustate.bDelete)
         {
-            mvwaddstr(newWindow,u16Line++, 3, "Press D for Delete");
+            string sLineTmp = "Press D for Delete";
+            mvwaddstr(newWindow,u16Line++, (iXSize/2)-(sLineTmp.size()/2), sLineTmp.c_str());
         }
 
     return newWindow;
@@ -388,9 +395,46 @@ WINDOW* TUI::createDialog(int iXSize, int iYSize, int iXStart, int iYStart, stri
 
     centerTitle(newWindow, task.c_str());
 
+    uint16_t u16Line = 3;
+    mvwaddstr(newWindow,u16Line++, (iXSize/2)-(optionA.size()/2), optionA.c_str());
+    u16Line++;
+    mvwaddstr(newWindow,u16Line++, (iXSize/2)-(optionB.size()/2), optionB.c_str());
+
+    return newWindow;
+}
+
+WINDOW* TUI::createFrozenWarning(int iXSize, int iYSize, int iXStart, int iYStart, string sPath, string sModelFamily, string sModelName, string sSerial, string sProgress)
+{
+    WINDOW *newWindow;
+    newWindow = newwin(iYSize, iXSize, iYStart, iXStart);
+
+    wbkgd(newWindow, COLOR_PAIR(COLOR_AREA_ENTRY_SELECTED));
+    box(newWindow, ACS_VLINE, ACS_HLINE);
+
+    string sHeader = "Drive " + sPath + " is frozen";
+    string sLine01 = "Please detach this drive and check it manually:";
+    string sShredState = "Shredding stopped after " + sProgress;
+    string sLinePath =  "Path:          " +sPath;
+    string sLineModelFamlily = "ModelFamily:   " + sModelFamily;
+    string sLineModelName =  "ModelName:     " + sModelName;
+    string sLineSerial =  "Serial:        " + sSerial;
+
+    string sLine02 = "reHDD was not able to write data to the drive.";
+    string sLine03 = "This can be caused by an malfunctioning drive.";
+
+    centerTitle(newWindow, sHeader.c_str());
+
     uint16_t u16Line = 2;
-    mvwaddstr(newWindow,u16Line++, 3, optionA.c_str());
+    mvwaddstr(newWindow,u16Line++, 3, sLine01.c_str());
-    mvwaddstr(newWindow,u16Line++, 3, optionB.c_str());
+    u16Line++;
+    mvwaddstr(newWindow,u16Line++, 3, sLinePath.c_str());
+    mvwaddstr(newWindow,u16Line++, 3, sLineModelFamlily.c_str());
+    mvwaddstr(newWindow,u16Line++, 3, sLineModelName.c_str());
+    mvwaddstr(newWindow,u16Line++, 3, sLineSerial.c_str());
+    u16Line++;
+    mvwaddstr(newWindow,u16Line++, 3, sLine02.c_str());
+    mvwaddstr(newWindow,u16Line++, 3, sLine03.c_str());
+    mvwaddstr(newWindow,u16Line++, 3, sShredState.c_str());
 
     return newWindow;
 }
@@ -433,17 +477,17 @@ void TUI::displaySelectedDrive(Drive drive, int stdscrX, int stdscrY)
     detailview=createDetailViewWindow(((stdscrX)-(int)(stdscrX/3)-7), (stdscrY-15), (int)(stdscrX/3)+5, drive);
     wrefresh(detailview);
 
-    menuview=createMenuView(((stdscrX)-(int)(stdscrX/3)-7), 10, (int)(stdscrX/3)+5,(stdscrY-11), menustate);
+    menuview=createMenuView(((int)(stdscrX/3)-10 ), 10, (int)(stdscrX/3)+5,(stdscrY-11), menustate);
     wrefresh(menuview);
 
     if(menustate.bConfirmShred == true)
         {
-            dialog=createDialog(70, 10, ((stdscrX)-(int)(stdscrX/3)-7)-(int)((stdscrX/3)+5)/2,(int)(stdscrY/2)-5, "Confirm SHRED", "Press ENTER for SHRED", "Press ESC for cancel");
+            dialog=createDialog(40, 10, ((stdscrX)-(int)(stdscrX/3)-7)-(int)((stdscrX/3)+5)/2,(int)(stdscrY/2)-5, "Confirm SHRED", "Press ENTER for SHRED", "Press ESC for cancel");
             wrefresh(dialog);
         }
     else if(menustate.bConfirmDelete == true)
         {
-            dialog=createDialog(70, 10, ((stdscrX)-(int)(stdscrX/3)-7)-(int)((stdscrX/3)+5)/2,(int)(stdscrY/2)-5, "Confirm DELETE", "Press ENTER for DELETE", "Press ESC for cancel");
+            dialog=createDialog(40, 10, ((stdscrX)-(int)(stdscrX/3)-7)-(int)((stdscrX/3)+5)/2,(int)(stdscrY/2)-5, "Confirm DELETE", "Press ENTER for DELETE", "Press ESC for cancel");
             wrefresh(dialog);
         }
     else
@@ -451,3 +495,42 @@ void TUI::displaySelectedDrive(Drive drive, int stdscrX, int stdscrY)
             delwin(dialog);
         }
 }
+
+WINDOW* TUI::createSmartWarning(int iXSize, int iYSize, int iXStart, int iYStart, string sPath, uint32_t u32PowerOnHours, uint32_t u32PowerCycles,  uint32_t u32ErrorCount)
+{
+    WINDOW *newWindow;
+    newWindow = newwin(iYSize, iXSize, iYStart, iXStart);
+
+    wbkgd(newWindow, COLOR_PAIR(COLOR_AREA_ENTRY_SELECTED));
+    box(newWindow, ACS_VLINE, ACS_HLINE);
+
+    string sHeader = "Drive " + sPath + " is suspicious";
+    string sLine01 = "Please evaluate this drive carefully.";
+
+    centerTitle(newWindow, sHeader.c_str());
+
+    uint16_t u16Line = 2;
+    mvwaddstr(newWindow,u16Line++, (iXSize/2)-(sLine01.size()/2), sLine01.c_str());
+    u16Line++;
+
+    if(u32PowerOnHours > WORSE_HOURS)
+        {
+            string sLineTmp = "Operating hours exceeded " + to_string(WORSE_HOURS) + " hours: " + to_string(u32PowerOnHours);
+            mvwaddstr(newWindow,u16Line++, (iXSize/2)-(sLine01.size()/2), sLineTmp.c_str());
+            u16Line++;
+        }
+
+    if(u32PowerCycles > WORSE_POWERUP)
+        {
+            string sLineTmp = "Power-on exceeded " + to_string(WORSE_POWERUP) + " cycles: " + to_string(u32PowerCycles);
+            mvwaddstr(newWindow,u16Line++, (iXSize/2)-(sLine01.size()/2), sLineTmp.c_str());
+            u16Line++;
+        }
+
+    if(u32ErrorCount > 0)
+        {
+            string sLineTmp = "S.M.A.R.T. erros detected: " + to_string(u32ErrorCount);
+            mvwaddstr(newWindow,u16Line++, (iXSize/2)-(sLine01.size()/2), sLineTmp.c_str());
+        }
+    return newWindow;
+}