localhorst/reHDD
1
0
Fork 1
Code Issues 8 Pull Requests 1 Releases 10 Wiki Activity

Merge branch 'master' into feature/failed-state

Browse Source
This commit is contained in:
Hendrik Schutter
2025-12-10 21:59:04 +01:00
parent 298192111d 6060ae13d6
commit 7bb9013c6c
16 changed files with 459 additions and 238 deletions
Download Patch File Download Diff File Expand all files Collapse all files

66
include/drive.h
View File

@ -14,7 +14,7 @@ class Drive
{ {
public: public:
enum TaskState enum class TaskState
{ {
NONE, NONE,
SHRED_SELECTED, SHRED_SELECTED,
@ -25,23 +25,28 @@ public:
DELETE_SELECTED, DELETE_SELECTED,
DELETE_ACTIVE, DELETE_ACTIVE,
FROZEN FROZEN
} state; };
enum ConnectionType enum class ConnectionType
{ {
UNKNOWN, UNKNOWN,
USB, USB,
SATA, SATA,
NVME NVME
} connectionType; };
struct struct ShredSpeed
{ {
time_t u32ShredTimeDelta; 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 ulWrittenBytes;
unsigned long ulSpeedMetricBytesWritten; unsigned long ulSpeedMetricBytesWritten;
} sShredSpeed; };
std::atomic<TaskState> state;
std::atomic<ConnectionType> connectionType;
std::atomic<ShredSpeed> sShredSpeed;
bool bWasShredded = false; // all shred iterations done bool bWasShredded = false; // all shred iterations done
bool bWasShredStarted = false; // shred was atleast once started bool bWasShredStarted = false; // shred was atleast once started
@ -49,9 +54,10 @@ public:
bool bWasDeleted = false; bool bWasDeleted = false;
bool bIsOffline = false; bool bIsOffline = false;
uint32_t u32DriveChecksumAfterShredding = 0U; uint32_t u32DriveChecksumAfterShredding = 0U;
uint16_t u16DriveIndex = 0U; // Index of TUI list
private: 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
@ -59,9 +65,9 @@ private:
struct 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 u32ErrorCount = 0U;
uint32_t u32PowerOnHours = 0U; // in hours uint32_t u32PowerOnHours = 0U; // in hours
@ -74,15 +80,27 @@ private:
protected: protected:
public: 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; 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 getErrorCount(void);
uint32_t getPowerOnHours(void); // in hours uint32_t getPowerOnHours(void); // in hours
@ -90,20 +108,20 @@ public:
uint32_t getTemperature(void); // in Fahrenheit, just kidding: degree Celsius uint32_t getTemperature(void); // in Fahrenheit, just kidding: degree Celsius
void checkFrozenDrive(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);
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); void setTaskPercentage(double d32TaskPercentage);
double getTaskPercentage(void); double getTaskPercentage(void);

4
include/logger/logger.h
View File

@ -16,6 +16,10 @@
#include <sys/socket.h> #include <sys/socket.h>
#include <arpa/inet.h> #include <arpa/inet.h>
#include <netinet/in.h> #include <netinet/in.h>
#include <ifaddrs.h>
#include <netpacket/packet.h>
#include <cstring>
#include <string>
#include <errno.h> #include <errno.h>
#include <stdlib.h> #include <stdlib.h>
#include <sys/ioctl.h> #include <sys/ioctl.h>

4
include/reHDD.h
View File

@ -56,9 +56,7 @@
#include <sstream> #include <sstream>
#include <iomanip> #include <iomanip>
#include <signal.h> #include <signal.h>
#include <atomic>
using namespace std;
#include "drive.h" #include "drive.h"
#include "smart.h" #include "smart.h"
#include "shred.h" #include "shred.h"

2
include/shred.h
View File

@ -47,7 +47,7 @@ private:
inline double calcProgress(); inline double calcProgress();
int iRewindDrive(fileDescriptor file); int iRewindDrive(fileDescriptor file);
unsigned long getDriveSizeInBytes(fileDescriptor file); long getDriveSizeInBytes(fileDescriptor file);
unsigned int uiCalcChecksum(fileDescriptor file, Drive *drive, int *ipSignalFd); unsigned int uiCalcChecksum(fileDescriptor file, Drive *drive, int *ipSignalFd);
void cleanup(); void cleanup();
}; };

18
include/smart.h
View File

@ -19,15 +19,15 @@ public:
private: private:
SMART(void); SMART(void);
static bool parseExitStatus(string sLine, uint8_t &status); static bool parseExitStatus(std::string sLine, uint8_t &status);
static bool parseModelFamily(string sLine, string &modelFamily); static bool parseModelFamily(std::string sLine, std::string &modelFamily);
static bool parseModelName(string sLine, string &modelName); static bool parseModelName(std::string sLine, std::string &modelName);
static bool parseSerial(string sLine, string &serial); static bool parseSerial(std::string sLine, std::string &serial);
static bool parseCapacity(string sLine, uint64_t &capacity); static bool parseCapacity(std::string sLine, uint64_t &capacity);
static bool parseErrorCount(string sLine, uint32_t &errorCount); static bool parseErrorCount(std::string sLine, uint32_t &errorCount);
static bool parsePowerOnHours(string sLine, uint32_t &powerOnHours); static bool parsePowerOnHours(std::string sLine, uint32_t &powerOnHours);
static bool parsePowerCycles(string sLine, uint32_t &powerCycles); static bool parsePowerCycles(std::string sLine, uint32_t &powerCycles);
static bool parseTemperature(string sLine, uint32_t &temperature); static bool parseTemperature(std::string sLine, uint32_t &temperature);
}; };
#endif // SMART_H_ #endif // SMART_H_

28
include/tui.h
View File

@ -47,16 +47,16 @@ public:
static void initTUI(); 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 enum UserInput readUserInput();
static void terminateTUI(); static void terminateTUI();
private: 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;
@ -67,19 +67,19 @@ private:
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, string sConnection, 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 *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 *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);
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_

2
makefile
View File

@ -18,7 +18,7 @@ DCOMPILE_FLAGS = -D DEBUG
# Add additional include paths # Add additional include paths
INCLUDES = include INCLUDES = include
# General linker settings # General linker settings
LINK_FLAGS = -Llib -lpthread -lncurses -ltfng LINK_FLAGS = -Llib -lpthread -lncurses -ltfng -latomic
# Doc # Doc
DOCDIR = doc DOCDIR = doc

5
src/delete.cpp
View File

@ -6,6 +6,7 @@
*/ */
#include "../include/reHDD.h" #include "../include/reHDD.h"
using namespace std;
/** /**
* \brief delete drive with wipefs * \brief delete drive with wipefs
@ -34,13 +35,15 @@ void Delete::deleteDrive(Drive *drive)
if (drive->bWasShredStarted == false) if (drive->bWasShredStarted == false)
{ {
//only start delete if the drive was not shredded before // only start delete if the drive was not shredded before
FILE *deleteCmdOutput = popen(cpComand, "r"); FILE *deleteCmdOutput = popen(cpComand, "r");
while ((getline(&cLine, &len, deleteCmdOutput)) != -1) while ((getline(&cLine, &len, deleteCmdOutput)) != -1)
{ {
// wipefs running // wipefs running
} }
free(cLine);
pclose(deleteCmdOutput); pclose(deleteCmdOutput);
} }
} }

123
src/drive.cpp
View File

@ -6,6 +6,95 @@
*/ */
#include "../include/reHDD.h" #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) string Drive::getPath(void)
{ {
@ -62,8 +151,12 @@ string Drive::sCapacityToText()
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; return acBuffer;
} }
@ -99,7 +192,6 @@ string Drive::sPowerCyclesToText()
string Drive::sTemperatureToText() string Drive::sTemperatureToText()
{ {
return to_string(getTemperature()) + " C"; return to_string(getTemperature()) + " C";
;
} }
void Drive::setTaskPercentage(double d32TaskPercentage) void Drive::setTaskPercentage(double d32TaskPercentage)
@ -148,12 +240,20 @@ void Drive::setDriveSMARTData(string modelFamily,
void Drive::setTimestamp() void Drive::setTimestamp()
{ {
time(&this->u32Timestamp); if (time(&this->u32Timestamp) == -1)
{
// handle error
this->u32Timestamp = 0U;
}
} }
void Drive::setActionStartTimestamp() void Drive::setActionStartTimestamp()
{ {
time(&this->u32TimestampTaskStart); if (time(&this->u32TimestampTaskStart) == -1)
{
// handle error
this->u32TimestampTaskStart = 0U;
}
} }
time_t Drive::getActionStartTimestamp() time_t Drive::getActionStartTimestamp()
@ -164,7 +264,11 @@ time_t Drive::getActionStartTimestamp()
void Drive::calculateTaskDuration() void Drive::calculateTaskDuration()
{ {
time_t u32localtime; time_t u32localtime;
time(&u32localtime); if (time(&u32localtime) == -1)
{
// handle error
u32localtime = 0U;
}
this->u32TaskDuration = u32localtime - this->u32TimestampTaskStart; this->u32TaskDuration = u32localtime - this->u32TimestampTaskStart;
} }
@ -178,12 +282,17 @@ void Drive::checkFrozenDrive(void)
{ {
time_t u32localtime; time_t u32localtime;
time(&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;
} }
} }

48
src/logger/logger.cpp
View File

@ -134,7 +134,7 @@ string Logger::getTimestamp()
} }
timeinfo = localtime(&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; return buffer;
} }
@ -143,24 +143,44 @@ string Logger::getTimestamp()
* \param void * \param void
* \return string MAC address (formatted) * \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)
{ {
strcpy(ifr.ifr_name, "eno1"); 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
{
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;
} }
/** /**

5
src/main.cpp
View File

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

40
src/printer.cpp
View File

@ -42,35 +42,35 @@ void Printer::print(Drive *drive)
t_msgQueueData msgQueueData; t_msgQueueData msgQueueData;
msgQueueData.msg_queue_type = 1; 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());
switch (drive->connectionType) switch (drive->connectionType)
{ {
case Drive::USB: case Drive::ConnectionType::USB:
strcpy(msgQueueData.driveData.caDriveConnectionType, "usb"); strncpy(msgQueueData.driveData.caDriveConnectionType, "usb", STR_BUFFER_SIZE);
break; break;
case Drive::SATA: case Drive::ConnectionType::SATA:
strcpy(msgQueueData.driveData.caDriveConnectionType, "sata"); strncpy(msgQueueData.driveData.caDriveConnectionType, "sata", STR_BUFFER_SIZE);
break; break;
case Drive::NVME: case Drive::ConnectionType::NVME:
strcpy(msgQueueData.driveData.caDriveConnectionType, "nvme"); strncpy(msgQueueData.driveData.caDriveConnectionType, "nvme", STR_BUFFER_SIZE);
break; break;
case Drive::UNKNOWN: case Drive::ConnectionType::UNKNOWN:
default: default:
strcpy(msgQueueData.driveData.caDriveConnectionType, "na"); strncpy(msgQueueData.driveData.caDriveConnectionType, "na", STR_BUFFER_SIZE);
} }
sprintf(msgQueueData.driveData.caDriveReHddVersion, REHDD_VERSION); snprintf(msgQueueData.driveData.caDriveReHddVersion, STR_BUFFER_SIZE, "%s", REHDD_VERSION);
if (-1 == msgsnd(this->msqid, &msgQueueData, sizeof(t_msgQueueData) - sizeof(long), 0)) if (-1 == msgsnd(this->msqid, &msgQueueData, sizeof(t_msgQueueData) - sizeof(long), 0))
{ {

186
src/reHDD.cpp
View File

@ -6,6 +6,7 @@
*/ */
#include "../include/reHDD.h" #include "../include/reHDD.h"
using namespace std;
static int fdNewDrivesInformPipe[2]; // File descriptor for pipe that informs if new drives are found static int fdNewDrivesInformPipe[2]; // File descriptor for pipe that informs if new drives are found
@ -19,7 +20,7 @@ static list<Drive> listDrives; // stores all drive data from scan thread
TUI *ui; TUI *ui;
static uint8_t u8SelectedEntry; static uint16_t u16SelectedEntry;
static fd_set selectSet; static fd_set selectSet;
@ -30,7 +31,7 @@ static fd_set selectSet;
*/ */
reHDD::reHDD(void) reHDD::reHDD(void)
{ {
u8SelectedEntry = 0U; u16SelectedEntry = 0U;
} }
/** /**
@ -43,8 +44,15 @@ void reHDD::app_logic(void)
ui = new TUI(); ui = new TUI();
ui->initTUI(); ui->initTUI();
pipe(fdNewDrivesInformPipe); if (pipe(fdNewDrivesInformPipe) == -1)
pipe(fdShredInformPipe); {
Logger::logThis()->error("Unable to open pipe 'fdNewDrivesInformPipe'");
}
if (pipe(fdShredInformPipe) == -1)
{
Logger::logThis()->error("Unable to open pipe 'fdShredInformPipe'");
}
thread thDevices(ThreadScanDevices); // start thread that scans for drives thread thDevices(ThreadScanDevices); // start thread that scans for drives
thread thUserInput(ThreadUserInput); // start thread that reads user input thread thUserInput(ThreadUserInput); // start thread that reads user input
@ -76,7 +84,7 @@ void reHDD::app_logic(void)
Logger::logThis()->info("got progress signal from a shred task"); Logger::logThis()->info("got progress signal from a shred task");
#endif #endif
} }
ui->updateTUI(&listDrives, u8SelectedEntry); ui->updateTUI(&listDrives, u16SelectedEntry);
} // endless loop } // endless loop
thDevices.join(); thDevices.join();
thUserInput.join(); thUserInput.join();
@ -85,16 +93,20 @@ void reHDD::app_logic(void)
Drive *reHDD::getSelectedDrive() Drive *reHDD::getSelectedDrive()
{ {
if (u8SelectedEntry < listDrives.size()) mxDrives.lock();
if (u16SelectedEntry < listDrives.size())
{ {
list<Drive>::iterator it = listDrives.begin(); list<Drive>::iterator it = listDrives.begin();
advance(it, u8SelectedEntry); advance(it, u16SelectedEntry);
it->u16DriveIndex = u16SelectedEntry;
mxDrives.unlock();
return &(*it); return &(*it);
} }
else else
{ {
Logger::logThis()->warning("selected drive not present"); Logger::logThis()->warning("selected drive not present");
return {}; mxDrives.unlock();
return nullptr;
} }
} }
@ -121,7 +133,7 @@ void reHDD::ThreadCheckFrozenDrives()
mxDrives.lock(); mxDrives.lock();
for (auto it = begin(listDrives); it != end(listDrives); ++it) for (auto it = begin(listDrives); it != end(listDrives); ++it)
{ {
if (it->state == Drive::SHRED_ACTIVE) if (it->state == Drive::TaskState::SHRED_ACTIVE)
{ {
it->checkFrozenDrive(); it->checkFrozenDrive();
} }
@ -135,18 +147,20 @@ void reHDD::ThreadUserInput()
{ {
while (true) while (true)
{ {
Drive *tmpSelectedDrive = getSelectedDrive();
// cout << TUI::readUserInput() << endl; // cout << TUI::readUserInput() << endl;
switch (TUI::readUserInput()) switch (TUI::readUserInput())
{ {
case TUI::UserInput::DownKey: case TUI::UserInput::DownKey:
// cout << "Down" << endl; // cout << "Down" << endl;
handleArrowKey(TUI::UserInput::DownKey); handleArrowKey(TUI::UserInput::DownKey);
ui->updateTUI(&listDrives, u8SelectedEntry); ui->updateTUI(&listDrives, u16SelectedEntry);
break; break;
case TUI::UserInput::UpKey: case TUI::UserInput::UpKey:
// cout << "Up" << endl; // cout << "Up" << endl;
handleArrowKey(TUI::UserInput::UpKey); handleArrowKey(TUI::UserInput::UpKey);
ui->updateTUI(&listDrives, u8SelectedEntry); ui->updateTUI(&listDrives, u16SelectedEntry);
break; break;
case TUI::UserInput::Undefined: case TUI::UserInput::Undefined:
// cout << "Undefined" << endl; // cout << "Undefined" << endl;
@ -154,48 +168,46 @@ void reHDD::ThreadUserInput()
case TUI::UserInput::Abort: case TUI::UserInput::Abort:
// cout << "Abort" << endl; // cout << "Abort" << endl;
handleAbort(); handleAbort();
ui->updateTUI(&listDrives, u8SelectedEntry); ui->updateTUI(&listDrives, u16SelectedEntry);
break; break;
case TUI::UserInput::Delete: case TUI::UserInput::Delete:
// cout << "Delete" << endl; // cout << "Delete" << endl;
if (getSelectedDrive() != nullptr) if (tmpSelectedDrive != nullptr)
{ {
if (getSelectedDrive()->state == Drive::NONE) if (tmpSelectedDrive->state == Drive::TaskState::NONE)
{ {
getSelectedDrive()->state = Drive::DELETE_SELECTED; tmpSelectedDrive->state = Drive::TaskState::DELETE_SELECTED;
} }
} }
ui->updateTUI(&listDrives, u8SelectedEntry); ui->updateTUI(&listDrives, u16SelectedEntry);
break; break;
case TUI::UserInput::Shred: case TUI::UserInput::Shred:
// cout << "Shred" << endl; // cout << "Shred" << endl;
if (tmpSelectedDrive != nullptr)
if (getSelectedDrive() != nullptr)
{ {
if (getSelectedDrive()->state == Drive::NONE) if (tmpSelectedDrive->state == Drive::TaskState::NONE)
{ {
getSelectedDrive()->state = Drive::SHRED_SELECTED; tmpSelectedDrive->state = Drive::TaskState::SHRED_SELECTED;
} }
} }
ui->updateTUI(&listDrives, u16SelectedEntry);
ui->updateTUI(&listDrives, u8SelectedEntry);
break; break;
case TUI::UserInput::ShredAll: case TUI::UserInput::ShredAll:
// cout << "ShredAll" << endl; // cout << "ShredAll" << endl;
startShredAllDrives(&listDrives); startShredAllDrives(&listDrives);
ui->updateTUI(&listDrives, u8SelectedEntry); ui->updateTUI(&listDrives, u16SelectedEntry);
break; break;
case TUI::UserInput::Enter: case TUI::UserInput::Enter:
// cout << "Enter" << endl; // cout << "Enter" << endl;
handleEnter(); handleEnter();
ui->updateTUI(&listDrives, u8SelectedEntry); ui->updateTUI(&listDrives, u16SelectedEntry);
break; break;
case TUI::UserInput::ESC: case TUI::UserInput::ESC:
// cout << "ESC" << endl; // cout << "ESC" << endl;
handleESC(); handleESC();
ui->updateTUI(&listDrives, u8SelectedEntry); ui->updateTUI(&listDrives, u16SelectedEntry);
break; break;
case TUI::UserInput::Terminate: case TUI::UserInput::Terminate:
// cout << "Terminate" << endl; // cout << "Terminate" << endl;
@ -218,20 +230,21 @@ void reHDD::ThreadShred(Drive *const pDrive)
Shred *pShredTask = new Shred(); // create new shred task Shred *pShredTask = new Shred(); // create new shred task
pShredTask->shredDrive(pDrive, &fdShredInformPipe[1]); // start new shred task pShredTask->shredDrive(pDrive, &fdShredInformPipe[1]); // start new shred task
delete pShredTask; // delete shred task delete pShredTask; // delete shred task
ui->updateTUI(&listDrives, u8SelectedEntry); ui->updateTUI(&listDrives, u16SelectedEntry);
} }
} }
void reHDD::ThreadDelete() void reHDD::ThreadDelete()
{ {
if (getSelectedDrive() != nullptr) Drive *tmpSelectedDrive = getSelectedDrive();
if (tmpSelectedDrive != nullptr)
{ {
getSelectedDrive()->setActionStartTimestamp(); // save timestamp at start of deleting tmpSelectedDrive->setActionStartTimestamp(); // save timestamp at start of deleting
Delete::deleteDrive(getSelectedDrive()); // blocking, no thread Delete::deleteDrive(tmpSelectedDrive); // blocking, no thread
getSelectedDrive()->state = Drive::TaskState::NONE; // delete finished tmpSelectedDrive->state = Drive::TaskState::NONE; // delete finished
getSelectedDrive()->bWasDeleted = true; tmpSelectedDrive->bWasDeleted = true;
Logger::logThis()->info("Finished delete for: " + getSelectedDrive()->getModelName() + "-" + getSelectedDrive()->getSerial()); Logger::logThis()->info("Finished delete for: " + tmpSelectedDrive->getModelName() + "-" + tmpSelectedDrive->getSerial());
ui->updateTUI(&listDrives, u8SelectedEntry); ui->updateTUI(&listDrives, u16SelectedEntry);
} }
} }
@ -289,7 +302,7 @@ void reHDD::filterNewDrives(list<Drive> *plistOldDrives, list<Drive> *plistNewDr
{ {
// cout << "offline drive found: " << itOld->getPath() << endl; // cout << "offline drive found: " << itOld->getPath() << endl;
Logger::logThis()->warning("Mark offline drive found: " + itOld->getPath()); Logger::logThis()->warning("Mark offline drive found: " + itOld->getPath());
itOld->state = Drive::NONE; // clear state --> shred task will terminate itOld->state = Drive::TaskState::NONE; // clear state --> shred task will terminate
} }
} }
@ -326,28 +339,28 @@ void reHDD::searchDrives(std::list<Drive> *plistDrives)
if (devName.empty()) if (devName.empty())
continue; continue;
Drive *tmpDrive = new Drive("/dev/" + devName); Drive tmpDrive("/dev/" + devName);
tmpDrive->state = Drive::NONE; tmpDrive.state = Drive::TaskState::NONE;
tmpDrive->bIsOffline = false; tmpDrive.bIsOffline = false;
// Set connection type // Set connection type
if (transport == "sata") if (transport == "sata")
tmpDrive->connectionType = Drive::SATA; tmpDrive.connectionType = Drive::ConnectionType::SATA;
else if (transport == "usb") else if (transport == "usb")
tmpDrive->connectionType = Drive::USB; tmpDrive.connectionType = Drive::ConnectionType::USB;
else if (transport == "nvme") else if (transport == "nvme")
tmpDrive->connectionType = Drive::NVME; tmpDrive.connectionType = Drive::ConnectionType::NVME;
else else
tmpDrive->connectionType = Drive::UNKNOWN; tmpDrive.connectionType = Drive::ConnectionType::UNKNOWN;
plistDrives->push_back(*tmpDrive); plistDrives->push_back(tmpDrive);
Logger::logThis()->info( Logger::logThis()->info(
"Drive found: " + tmpDrive->getPath() + "Drive found: " + tmpDrive.getPath() +
" (type: " + " (type: " +
(tmpDrive->connectionType == Drive::USB ? "USB" : tmpDrive->connectionType == Drive::SATA ? "SATA" (tmpDrive.connectionType == Drive::ConnectionType::USB ? "USB" : tmpDrive.connectionType == Drive::ConnectionType::SATA ? "SATA"
: tmpDrive->connectionType == Drive::NVME ? "NVME" : tmpDrive.connectionType == Drive::ConnectionType::NVME ? "NVME"
: "UNKNOWN") + : "UNKNOWN") +
")"); ")");
} }
@ -376,7 +389,6 @@ void reHDD::filterIgnoredDrives(list<Drive> *plistDrives)
Logger::logThis()->info("system drive found --> ignore this drive: " + it->getPath()); Logger::logThis()->info("system drive found --> ignore this drive: " + it->getPath());
#endif #endif
it = plistDrives->erase(it); it = plistDrives->erase(it);
it--;
} }
} }
} }
@ -419,6 +431,7 @@ void reHDD::filterIgnoredDrives(list<Drive> *plistDrives)
// cout << "blkid uuid:" << sUUID << endl; // cout << "blkid uuid:" << sUUID << endl;
} }
} }
free(cLine);
pclose(outputfileBlkid); pclose(outputfileBlkid);
// cout << "blkid uuid:" << sUUID << endl; // cout << "blkid uuid:" << sUUID << endl;
@ -429,7 +442,6 @@ void reHDD::filterIgnoredDrives(list<Drive> *plistDrives)
Logger::logThis()->info("same uuid found than in ignore file --> ignore this drive: " + it->getPath()); Logger::logThis()->info("same uuid found than in ignore file --> ignore this drive: " + it->getPath());
#endif #endif
it = plistDrives->erase(it); it = plistDrives->erase(it);
it--;
} }
} }
} }
@ -451,7 +463,6 @@ void reHDD::filterInvalidDrives(list<Drive> *plistDrives)
Logger::logThis()->info("Drive reports zero capacity --> ignore this drive: " + it->getPath()); Logger::logThis()->info("Drive reports zero capacity --> ignore this drive: " + it->getPath());
#endif #endif
it = plistDrives->erase(it); it = plistDrives->erase(it);
it--;
} }
} }
} }
@ -467,7 +478,7 @@ void reHDD::startShredAllDrives(list<Drive> *plistDrives)
mxDrives.lock(); mxDrives.lock();
for (it = plistDrives->begin(); it != plistDrives->end(); ++it) for (it = plistDrives->begin(); it != plistDrives->end(); ++it)
{ {
if (it->state == Drive::NONE) if (it->state == Drive::TaskState::NONE)
{ {
Drive *pTmpDrive = iterator_to_pointer<Drive, std::list<Drive>::iterator>(it); Drive *pTmpDrive = iterator_to_pointer<Drive, std::list<Drive>::iterator>(it);
#ifdef LOG_LEVEL_HIGH #ifdef LOG_LEVEL_HIGH
@ -494,9 +505,9 @@ void reHDD::stopShredAllDrives(list<Drive> *plistDrives)
for (it = plistDrives->begin(); it != plistDrives->end(); ++it) for (it = plistDrives->begin(); it != plistDrives->end(); ++it)
{ {
if (it->state == Drive::SHRED_ACTIVE || it->state == Drive::DELETE_ACTIVE) if (it->state == Drive::TaskState::SHRED_ACTIVE || it->state == Drive::TaskState::DELETE_ACTIVE)
{ {
it->state = Drive::NONE; it->state = Drive::TaskState::NONE;
Logger::logThis()->info("Abort-Shred-Signal for: " + it->getModelName() + "-" + it->getSerial()); Logger::logThis()->info("Abort-Shred-Signal for: " + it->getModelName() + "-" + it->getSerial());
// task for drive is running --> remove selection // task for drive is running --> remove selection
} }
@ -555,18 +566,20 @@ void reHDD::updateShredMetrics(list<Drive> *plistDrives)
list<Drive>::iterator it; list<Drive>::iterator it;
for (it = plistDrives->begin(); it != plistDrives->end(); ++it) for (it = plistDrives->begin(); it != plistDrives->end(); ++it)
{ {
if (it->state == Drive::SHRED_ACTIVE) if (it->state == Drive::TaskState::SHRED_ACTIVE)
{ {
Drive *pTmpDrive = iterator_to_pointer<Drive, std::list<Drive>::iterator>(it); Drive *pTmpDrive = iterator_to_pointer<Drive, std::list<Drive>::iterator>(it);
// set metrics for calculating shred speed // set metrics for calculating shred speed
std::chrono::time_point<std::chrono::system_clock> chronoCurrentTimestamp = std::chrono::system_clock::now(); std::chrono::time_point<std::chrono::system_clock> chronoCurrentTimestamp = std::chrono::system_clock::now();
time_t u32ShredTimeDelta = (chronoCurrentTimestamp - pTmpDrive->sShredSpeed.chronoShredTimestamp).count(); auto shredSpeed = pTmpDrive->sShredSpeed.load();
time_t u32ShredTimeDelta = (chronoCurrentTimestamp - shredSpeed.chronoShredTimestamp).count();
if (u32ShredTimeDelta > METRIC_THRESHOLD) if (u32ShredTimeDelta > METRIC_THRESHOLD)
{ {
pTmpDrive->sShredSpeed.u32ShredTimeDelta = u32ShredTimeDelta; shredSpeed.u32ShredTimeDelta = u32ShredTimeDelta;
pTmpDrive->sShredSpeed.chronoShredTimestamp = std::chrono::system_clock::now(); shredSpeed.chronoShredTimestamp = std::chrono::system_clock::now();
pTmpDrive->sShredSpeed.ulWrittenBytes = pTmpDrive->sShredSpeed.ulSpeedMetricBytesWritten; shredSpeed.ulWrittenBytes = shredSpeed.ulSpeedMetricBytesWritten;
pTmpDrive->sShredSpeed.ulSpeedMetricBytesWritten = 0U; shredSpeed.ulSpeedMetricBytesWritten = 0U;
pTmpDrive->sShredSpeed.store(shredSpeed);
} }
} }
} }
@ -589,28 +602,28 @@ void reHDD::addSMARTData(list<Drive> *plistDrives)
void reHDD::handleArrowKey(TUI::UserInput userInput) void reHDD::handleArrowKey(TUI::UserInput userInput)
{ {
int8_t u8EntrySize = (int8_t)listDrives.size(); uint8_t u8EntrySize = (uint8_t)listDrives.size();
switch (userInput) switch (userInput)
{ {
case TUI::UserInput::DownKey: case TUI::UserInput::DownKey:
u8SelectedEntry++; u16SelectedEntry++;
if (u8SelectedEntry >= u8EntrySize) if (u16SelectedEntry >= u8EntrySize)
{ {
u8SelectedEntry = 0; u16SelectedEntry = 0;
} }
break; break;
case TUI::UserInput::UpKey: case TUI::UserInput::UpKey:
if (u8SelectedEntry == 0) if (u16SelectedEntry == 0)
{ {
u8SelectedEntry = (u8EntrySize - 1); u16SelectedEntry = (u8EntrySize - 1);
} }
else else
{ {
u8SelectedEntry--; u16SelectedEntry--;
} }
break; break;
default: default:
u8SelectedEntry = 0; u16SelectedEntry = 0;
break; break;
} }
@ -619,22 +632,21 @@ void reHDD::handleArrowKey(TUI::UserInput userInput)
void reHDD::handleEnter() void reHDD::handleEnter()
{ {
Drive *tmpSelectedDrive = getSelectedDrive();
if (getSelectedDrive() != nullptr) if (tmpSelectedDrive != nullptr)
{ {
if (getSelectedDrive()->state == Drive::TaskState::SHRED_SELECTED) if (tmpSelectedDrive->state == Drive::TaskState::SHRED_SELECTED)
{ {
Logger::logThis()->info("Started shred/check for: " + getSelectedDrive()->getModelName() + "-" + getSelectedDrive()->getSerial()); Logger::logThis()->info("Started shred/check for: " + tmpSelectedDrive->getModelName() + "-" + tmpSelectedDrive->getSerial());
getSelectedDrive()->state = Drive::TaskState::SHRED_ACTIVE; tmpSelectedDrive->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 option
Drive *pTmpDrive = getSelectedDrive(); thread(ThreadShred, tmpSelectedDrive).detach();
thread(ThreadShred, pTmpDrive).detach();
} }
if (getSelectedDrive()->state == Drive::TaskState::DELETE_SELECTED) if (tmpSelectedDrive->state == Drive::TaskState::DELETE_SELECTED)
{ {
Logger::logThis()->info("Started delete for: " + getSelectedDrive()->getModelName() + "-" + getSelectedDrive()->getSerial()); Logger::logThis()->info("Started delete for: " + tmpSelectedDrive->getModelName() + "-" + tmpSelectedDrive->getSerial());
getSelectedDrive()->state = Drive::TaskState::DELETE_ACTIVE; tmpSelectedDrive->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(); thread(ThreadDelete).detach();
} }
@ -643,17 +655,18 @@ void reHDD::handleEnter()
void reHDD::handleESC() void reHDD::handleESC()
{ {
if (getSelectedDrive() != nullptr) Drive *tmpSelectedDrive = getSelectedDrive();
if (tmpSelectedDrive != nullptr)
{ {
if (getSelectedDrive()->state == Drive::TaskState::SHRED_SELECTED) if (tmpSelectedDrive->state == Drive::TaskState::SHRED_SELECTED)
{ {
getSelectedDrive()->state = Drive::TaskState::NONE; tmpSelectedDrive->state = Drive::TaskState::NONE;
// task for drive is selected --> remove selection // task for drive is selected --> remove selection
} }
if (getSelectedDrive()->state == Drive::TaskState::DELETE_SELECTED) if (tmpSelectedDrive->state == Drive::TaskState::DELETE_SELECTED)
{ {
getSelectedDrive()->state = Drive::TaskState::NONE; tmpSelectedDrive->state = Drive::TaskState::NONE;
// task for drive is selected --> remove selection // task for drive is selected --> remove selection
} }
} }
@ -661,12 +674,13 @@ void reHDD::handleESC()
void reHDD::handleAbort() void reHDD::handleAbort()
{ {
if (getSelectedDrive() != nullptr) Drive *tmpSelectedDrive = getSelectedDrive();
if (tmpSelectedDrive != nullptr)
{ {
if (getSelectedDrive()->state == Drive::SHRED_ACTIVE || getSelectedDrive()->state == Drive::DELETE_ACTIVE) if (tmpSelectedDrive->state == Drive::TaskState::SHRED_ACTIVE || tmpSelectedDrive->state == Drive::TaskState::DELETE_ACTIVE)
{ {
getSelectedDrive()->state = Drive::NONE; tmpSelectedDrive->state = Drive::TaskState::NONE;
Logger::logThis()->info("Abort-Shred-Signal for: " + getSelectedDrive()->getModelName() + "-" + getSelectedDrive()->getSerial()); Logger::logThis()->info("Abort-Shred-Signal for: " + tmpSelectedDrive->getModelName() + "-" + tmpSelectedDrive->getSerial());
// task for drive is running --> remove selection // task for drive is running --> remove selection
} }
} }

60
src/shred.cpp
View File

@ -6,6 +6,7 @@
*/ */
#include "../include/reHDD.h" #include "../include/reHDD.h"
using namespace std;
#ifdef __cplusplus #ifdef __cplusplus
extern "C" extern "C"
@ -41,7 +42,7 @@ int Shred::shredDrive(Drive *drive, int *ipSignalFd)
#ifdef DRYRUN #ifdef DRYRUN
for (int i = 0; i <= 500; i++) for (int i = 0; i <= 500; i++)
{ {
if (drive->state != Drive::SHRED_ACTIVE) if (drive->state.load() != Drive::TaskState::SHRED_ACTIVE)
{ {
return 0; return 0;
} }
@ -60,7 +61,7 @@ int Shred::shredDrive(Drive *drive, int *ipSignalFd)
randomSrcFileDiscr = open(randomsrc, O_RDONLY | O_LARGEFILE); randomSrcFileDiscr = open(randomsrc, O_RDONLY | O_LARGEFILE);
if (randomSrcFileDiscr == -1) if (randomSrcFileDiscr == -1)
{ {
std::string errorMsg(strerror(randomSrcFileDiscr)); std::string errorMsg(strerror(errno));
Logger::logThis()->error("Shred-Task: Open random source failed! " + errorMsg + " - Drive: " + drive->getSerial()); Logger::logThis()->error("Shred-Task: Open random source failed! " + errorMsg + " - Drive: " + drive->getSerial());
perror(randomsrc); perror(randomsrc);
cleanup(); cleanup();
@ -71,7 +72,7 @@ int Shred::shredDrive(Drive *drive, int *ipSignalFd)
driveFileDiscr = open(cpDrivePath, O_RDWR | O_LARGEFILE); driveFileDiscr = open(cpDrivePath, O_RDWR | O_LARGEFILE);
if (driveFileDiscr == -1) if (driveFileDiscr == -1)
{ {
std::string errorMsg(strerror(driveFileDiscr)); std::string errorMsg(strerror(errno));
Logger::logThis()->error("Shred-Task: Open drive failed! " + errorMsg + " - Drive: " + drive->getSerial()); Logger::logThis()->error("Shred-Task: Open drive failed! " + errorMsg + " - Drive: " + drive->getSerial());
perror(cpDrivePath); perror(cpDrivePath);
cleanup(); cleanup();
@ -82,7 +83,7 @@ int Shred::shredDrive(Drive *drive, int *ipSignalFd)
ssize_t readRet = read(randomSrcFileDiscr, ucKey, sizeof(ucKey)); ssize_t readRet = read(randomSrcFileDiscr, ucKey, sizeof(ucKey));
if (readRet <= 0) if (readRet <= 0)
{ {
std::string errorMsg(strerror(readRet)); std::string errorMsg(strerror(errno));
Logger::logThis()->error("Shred-Task: Read random key failed! " + errorMsg + " - Drive: " + drive->getSerial()); Logger::logThis()->error("Shred-Task: Read random key failed! " + errorMsg + " - Drive: " + drive->getSerial());
perror(randomsrc); perror(randomsrc);
cleanup(); cleanup();
@ -92,8 +93,10 @@ int Shred::shredDrive(Drive *drive, int *ipSignalFd)
tfng_prng_seedkey(ucKey); tfng_prng_seedkey(ucKey);
this->ulDriveByteSize = getDriveSizeInBytes(driveFileDiscr); this->ulDriveByteSize = getDriveSizeInBytes(driveFileDiscr);
drive->sShredSpeed.chronoShredTimestamp = std::chrono::system_clock::now(); // set inital timestamp for speed metric Drive::ShredSpeed shredSpeed = drive->sShredSpeed.load();
drive->sShredSpeed.ulSpeedMetricBytesWritten = 0U; // uses to calculate speed metric shredSpeed.chronoShredTimestamp = std::chrono::system_clock::now(); // set inital timestamp for speed metric
shredSpeed.ulSpeedMetricBytesWritten = 0U; // uses to calculate speed metric
drive->sShredSpeed.store(shredSpeed);
#ifdef LOG_LEVEL_HIGH #ifdef LOG_LEVEL_HIGH
Logger::logThis()->info("Shred-Task: Bytes-Size of Drive: " + to_string(this->ulDriveByteSize) + " - Drive: " + drive->getSerial()); Logger::logThis()->info("Shred-Task: Bytes-Size of Drive: " + to_string(this->ulDriveByteSize) + " - Drive: " + drive->getSerial());
@ -132,21 +135,24 @@ int Shred::shredDrive(Drive *drive, int *ipSignalFd)
if (iByteShredded <= 0) if (iByteShredded <= 0)
{ {
std::string errorMsg(strerror(iByteShredded)); std::string errorMsg(strerror(errno));
Logger::logThis()->error("Shred-Task: Write to drive failed! " + errorMsg + " - Drive: " + drive->getSerial()); Logger::logThis()->error("Shred-Task: Write to drive failed! " + errorMsg + " - Drive: " + drive->getSerial());
perror("unable to write random data"); perror("unable to write random data");
cleanup(); cleanup();
return -1; return -1;
} }
auto shredSpeed = drive->sShredSpeed.load();
shredSpeed.ulSpeedMetricBytesWritten += iByteShredded;
drive->sShredSpeed.store(shredSpeed);
ulDriveByteCounter += iByteShredded; ulDriveByteCounter += iByteShredded;
ulDriveByteOverallCount += iByteShredded; ulDriveByteOverallCount += iByteShredded;
d32Percent = this->calcProgress(); d32Percent = this->calcProgress();
drive->sShredSpeed.ulSpeedMetricBytesWritten += iByteShredded;
#ifdef LOG_LEVEL_HIGH #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 #endif
if ((d32Percent - d32TmpPercent) >= 0.01) if ((d32Percent - d32TmpPercent) >= 0.01)
{ {
// set shred percantage // set shred percantage
@ -156,7 +162,7 @@ int Shred::shredDrive(Drive *drive, int *ipSignalFd)
write(*ipSignalFd, "A", 1); write(*ipSignalFd, "A", 1);
} }
if (drive->state != Drive::SHRED_ACTIVE) if (drive->state != Drive::TaskState::SHRED_ACTIVE)
{ {
drive->setTaskPercentage(0); drive->setTaskPercentage(0);
d32Percent = 0.00; d32Percent = 0.00;
@ -183,18 +189,18 @@ int Shred::shredDrive(Drive *drive, int *ipSignalFd)
drive->bWasShredded = true; drive->bWasShredded = true;
Logger::logThis()->info("Shred-Task finished - Drive: " + drive->getModelName() + "-" + drive->getSerial() + " @" + address.str()); Logger::logThis()->info("Shred-Task finished - Drive: " + drive->getModelName() + "-" + drive->getSerial() + " @" + address.str());
#ifdef ZERO_CHECK #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()); Logger::logThis()->info("Check-Task started - Drive: " + drive->getModelName() + "-" + drive->getSerial() + " @" + address.str());
drive->u32DriveChecksumAfterShredding = uiCalcChecksum(driveFileDiscr, drive, ipSignalFd); drive->u32DriveChecksumAfterShredding = uiCalcChecksum(driveFileDiscr, drive, ipSignalFd);
if (drive->u32DriveChecksumAfterShredding != 0) if (drive->u32DriveChecksumAfterShredding != 0)
{ {
drive->state = Drive::CHECK_FAILED; drive->state = Drive::TaskState::CHECK_FAILED;
Logger::logThis()->info("Shred-Task: Checksum not zero: " + to_string(drive->u32DriveChecksumAfterShredding) + " - Drive: " + drive->getSerial()); Logger::logThis()->info("Shred-Task: Checksum not zero: " + to_string(drive->u32DriveChecksumAfterShredding) + " - Drive: " + drive->getSerial());
} }
else else
{ {
drive->state = Drive::CHECK_SUCCESSFUL; drive->state = Drive::TaskState::CHECK_SUCCESSFUL;
Logger::logThis()->info("Shred-Task: Checksum zero: " + to_string(drive->u32DriveChecksumAfterShredding) + " - Drive: " + drive->getSerial()); Logger::logThis()->info("Shred-Task: Checksum zero: " + to_string(drive->u32DriveChecksumAfterShredding) + " - Drive: " + drive->getSerial());
} }
#endif #endif
@ -202,9 +208,9 @@ int Shred::shredDrive(Drive *drive, int *ipSignalFd)
cleanup(); cleanup();
if ((drive->state == Drive::SHRED_ACTIVE) || (drive->state == Drive::CHECK_SUCCESSFUL) || (drive->state == Drive::CHECK_FAILED)) if ((drive->state.load() == Drive::TaskState::SHRED_ACTIVE) || (drive->state.load() == Drive::TaskState::CHECK_ACTIVE) || (drive->state == Drive::TaskState::CHECK_FAILED))
{ {
drive->state = Drive::NONE; drive->state = Drive::TaskState::NONE;
drive->setTaskPercentage(0.0); drive->setTaskPercentage(0.0);
Printer::getPrinter()->print(drive); Printer::getPrinter()->print(drive);
Logger::logThis()->info("Finished shred/check for: " + drive->getModelName() + "-" + drive->getSerial()); Logger::logThis()->info("Finished shred/check for: " + drive->getModelName() + "-" + drive->getSerial());
@ -224,6 +230,8 @@ double Shred::calcProgress()
#ifdef ZERO_CHECK #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 #endif
if (this->ulDriveByteSize == 0)
return 0.0;
return (double)(((double)ulDriveByteOverallCount) / ((double)this->ulDriveByteSize * uiMaxShredIteration)) * 100.0f; return (double)(((double)ulDriveByteOverallCount) / ((double)this->ulDriveByteSize * uiMaxShredIteration)) * 100.0f;
} }
@ -232,6 +240,7 @@ int Shred::iRewindDrive(fileDescriptor file)
if (0 != lseek(file, 0L, SEEK_SET)) if (0 != lseek(file, 0L, SEEK_SET))
{ {
perror("unable to rewind drive"); perror("unable to rewind drive");
Logger::logThis()->info("Unable to rewind drive! - fileDescriptor: " + to_string(file));
return -1; return -1;
} }
else else
@ -240,19 +249,26 @@ int Shred::iRewindDrive(fileDescriptor file)
} }
} }
unsigned long Shred::getDriveSizeInBytes(fileDescriptor file) long Shred::getDriveSizeInBytes(fileDescriptor file)
{ {
unsigned long ulDriveSizeTmp = lseek(file, 0L, SEEK_END); long liDriveSizeTmp = lseek(file, 0L, SEEK_END);
if (liDriveSizeTmp == -1)
{
perror("unable to get drive size");
Logger::logThis()->info("Unable to get drive size! - fileDescriptor: " + to_string(file));
return 0L;
}
if (0 != iRewindDrive(file)) if (0 != iRewindDrive(file))
{ {
ulDriveSizeTmp = 0U; liDriveSizeTmp = 0L;
} }
#ifdef DEMO_DRIVE_SIZE #ifdef DEMO_DRIVE_SIZE
ulDriveSizeTmp = DEMO_DRIVE_SIZE; liDriveSizeTmp = DEMO_DRIVE_SIZE;
#endif #endif
return ulDriveSizeTmp; return liDriveSizeTmp;
} }
unsigned int Shred::uiCalcChecksum(fileDescriptor file, Drive *drive, int *ipSignalFd) unsigned int Shred::uiCalcChecksum(fileDescriptor file, Drive *drive, int *ipSignalFd)
@ -278,7 +294,9 @@ unsigned int Shred::uiCalcChecksum(fileDescriptor file, Drive *drive, int *ipSig
ulDriveByteCounter += iReadBytes; ulDriveByteCounter += iReadBytes;
ulDriveByteOverallCount += iReadBytes; ulDriveByteOverallCount += iReadBytes;
d32Percent = this->calcProgress(); d32Percent = this->calcProgress();
drive->sShredSpeed.ulSpeedMetricBytesWritten += iReadBytes; auto shredSpeed = drive->sShredSpeed.load();
shredSpeed.ulSpeedMetricBytesWritten += iReadBytes;
drive->sShredSpeed.store(shredSpeed);
#ifdef LOG_LEVEL_HIGH #ifdef LOG_LEVEL_HIGH
Logger::logThis()->info("Shred-Task (Checksum): ByteCount: " + to_string(ulDriveByteCounter) + " - progress: " + to_string(d32Percent) + " - Drive: " + drive->getSerial()); Logger::logThis()->info("Shred-Task (Checksum): ByteCount: " + to_string(ulDriveByteCounter) + " - progress: " + to_string(d32Percent) + " - Drive: " + drive->getSerial());

48
src/smart.cpp
View File

@ -6,6 +6,7 @@
*/ */
#include "../include/reHDD.h" #include "../include/reHDD.h"
using namespace std;
/** /**
* \brief get and set S.M.A.R.T. values in Drive * \brief get and set S.M.A.R.T. values in Drive
@ -36,10 +37,10 @@ void SMART::readSMARTData(Drive *drive)
sCMD.append(drive->getPath()); sCMD.append(drive->getPath());
const char *cpComand = sCMD.c_str(); const char *cpComand = sCMD.c_str();
//Logger::logThis()->info(cpComand); // Logger::logThis()->info(cpComand);
FILE *outputfileSmart = popen(cpComand, "r"); FILE *outputfileSmart = popen(cpComand, "r");
size_t len = 0U; // length of found line size_t len = 0U; // length of found line
char *cLine = NULL; // found line char *cLine = NULL; // found line
uint8_t status = 255U; uint8_t status = 255U;
@ -58,12 +59,13 @@ void SMART::readSMARTData(Drive *drive)
SMART::parseTemperature(sLine, temperature); SMART::parseTemperature(sLine, temperature);
} }
free(cLine);
pclose(outputfileSmart); pclose(outputfileSmart);
if (status == 0U) if (status == 0U)
{ {
// Found S.M.A.R.T. data with this command // Found S.M.A.R.T. data with this command
//Logger::logThis()->info("Found S.M.A.R.T. data with this command"); // Logger::logThis()->info("Found S.M.A.R.T. data with this command");
break; break;
} }
} }
@ -106,7 +108,10 @@ bool SMART::parseModelFamily(string sLine, string &modelFamily)
if (found != string::npos) if (found != string::npos)
{ {
sLine.erase(0U, sLine.find(": ") + 3U); sLine.erase(0U, sLine.find(": ") + 3U);
sLine.erase(sLine.length() - 3U, 3U); if (sLine.length() >= 3U)
{
sLine.erase(sLine.length() - 3U, 3U);
}
modelFamily = sLine; modelFamily = sLine;
return true; return true;
} }
@ -129,7 +134,10 @@ bool SMART::parseModelName(string sLine, string &modelName)
if (found != string::npos) if (found != string::npos)
{ {
sLine.erase(0U, sLine.find(": ") + 3U); sLine.erase(0U, sLine.find(": ") + 3U);
sLine.erase(sLine.length() - 3U, 3U); if (sLine.length() >= 3U)
{
sLine.erase(sLine.length() - 3U, 3U);
}
modelName = sLine; modelName = sLine;
return true; return true;
} }
@ -152,7 +160,10 @@ bool SMART::parseSerial(string sLine, string &serial)
if (found != string::npos) if (found != string::npos)
{ {
sLine.erase(0, sLine.find(": ") + 3); sLine.erase(0, sLine.find(": ") + 3);
sLine.erase(sLine.length() - 3, 3); if (sLine.length() >= 3U)
{
sLine.erase(sLine.length() - 3U, 3U);
}
serial = sLine; serial = sLine;
return true; return true;
} }
@ -175,7 +186,10 @@ bool SMART::parseCapacity(string sLine, uint64_t &capacity)
if (found != string::npos) if (found != string::npos)
{ {
sLine.erase(0, sLine.find(": ") + 2); sLine.erase(0, sLine.find(": ") + 2);
sLine.erase(sLine.length() - 1, 1); if (sLine.length() >= 1U)
{
sLine.erase(sLine.length() - 1U, 1U);
}
capacity = stol(sLine); capacity = stol(sLine);
return true; return true;
} }
@ -198,7 +212,10 @@ bool SMART::parseErrorCount(string sLine, uint32_t &errorCount)
if (found != string::npos) if (found != string::npos)
{ {
sLine.erase(0U, sLine.find(": ") + 2U); sLine.erase(0U, sLine.find(": ") + 2U);
sLine.erase(sLine.length() - 2U, 2U); if (sLine.length() >= 2U)
{
sLine.erase(sLine.length() - 2U, 2U);
}
errorCount = stol(sLine); errorCount = stol(sLine);
return true; return true;
} }
@ -221,7 +238,10 @@ bool SMART::parsePowerOnHours(string sLine, uint32_t &powerOnHours)
if (found != string::npos) if (found != string::npos)
{ {
sLine.erase(0U, sLine.find(": ") + 2U); sLine.erase(0U, sLine.find(": ") + 2U);
sLine.erase(sLine.length() - 1U, 1U); if (sLine.length() >= 1U)
{
sLine.erase(sLine.length() - 1U, 1U);
}
powerOnHours = stol(sLine); powerOnHours = stol(sLine);
return true; return true;
} }
@ -244,7 +264,10 @@ bool SMART::parsePowerCycles(string sLine, uint32_t &powerCycles)
if (found != string::npos) if (found != string::npos)
{ {
sLine.erase(0, sLine.find(": ") + 2); sLine.erase(0, sLine.find(": ") + 2);
sLine.erase(sLine.length() - 2, 2); if (sLine.length() >= 2U)
{
sLine.erase(sLine.length() - 2U, 2U);
}
powerCycles = stol(sLine); powerCycles = stol(sLine);
return true; return true;
} }
@ -267,7 +290,10 @@ bool SMART::parseTemperature(string sLine, uint32_t &temperature)
if (found != string::npos) if (found != string::npos)
{ {
sLine.erase(0U, sLine.find(": ") + 2U); sLine.erase(0U, sLine.find(": ") + 2U);
sLine.erase(sLine.length() - 1U, 2U); if (sLine.length() >= 1U)
{
sLine.erase(sLine.length() - 1U, 2U);
}
if (sLine == "{") if (sLine == "{")
{ {
temperature = 0U; // this drive doesn't support temperature temperature = 0U; // this drive doesn't support temperature

58
src/tui.cpp
View File

@ -6,6 +6,7 @@
*/ */
#include "../include/reHDD.h" #include "../include/reHDD.h"
using namespace std;
static std::mutex mxUIrefresh; static std::mutex mxUIrefresh;
@ -98,9 +99,9 @@ void TUI::updateTUI(list<Drive> *plistDrives, uint8_t u8SelectedEntry)
string sSpeed = " "; string sSpeed = " ";
string sTime = " "; string sTime = " ";
string sTemp = it->sTemperatureToText(); string sTemp = it->sTemperatureToText();
string sConnection = (it->connectionType == Drive::USB ? "USB" : it->connectionType == Drive::SATA ? "SATA" string sConnection = (it->connectionType == Drive::ConnectionType::USB ? "USB" : it->connectionType == Drive::ConnectionType::SATA ? "SATA"
: it->connectionType == Drive::NVME ? "NVME" : it->connectionType == Drive::ConnectionType::NVME ? "NVME"
: ""); : "");
bool bSelectedEntry = false; bool bSelectedEntry = false;
@ -121,31 +122,40 @@ void TUI::updateTUI(list<Drive> *plistDrives, uint8_t u8SelectedEntry)
switch (it->state) switch (it->state)
{ {
case Drive::SHRED_ACTIVE: case Drive::TaskState::SHRED_ACTIVE:
{
stream << fixed << setprecision(3) << (it->getTaskPercentage()); stream << fixed << setprecision(3) << (it->getTaskPercentage());
sState = "Shredding: " + stream.str() + "%"; sState = "Shredding: " + stream.str() + "%";
it->calculateTaskDuration(); it->calculateTaskDuration();
sTime = this->formatTimeDuration(it->getTaskDuration()); sTime = this->formatTimeDuration(it->getTaskDuration());
sSpeed = this->formatSpeed(it->sShredSpeed.u32ShredTimeDelta, it->sShredSpeed.ulWrittenBytes); auto shredSpeed = it->sShredSpeed.load();
sSpeed = this->formatSpeed(shredSpeed.u32ShredTimeDelta, shredSpeed.ulWrittenBytes);
break; break;
case Drive::CHECK_ACTIVE: }
case Drive::TaskState::CHECK_ACTIVE:
{
stream << fixed << setprecision(3) << (it->getTaskPercentage()); stream << fixed << setprecision(3) << (it->getTaskPercentage());
sState = "Checking: " + stream.str() + "%"; sState = "Checking: " + stream.str() + "%";
it->calculateTaskDuration(); it->calculateTaskDuration();
sTime = this->formatTimeDuration(it->getTaskDuration()); sTime = this->formatTimeDuration(it->getTaskDuration());
sSpeed = this->formatSpeed(it->sShredSpeed.u32ShredTimeDelta, it->sShredSpeed.ulWrittenBytes); auto shredSpeed = it->sShredSpeed.load();
sSpeed = this->formatSpeed(shredSpeed.u32ShredTimeDelta, shredSpeed.ulWrittenBytes);
break; break;
case Drive::DELETE_ACTIVE: }
case Drive::TaskState::DELETE_ACTIVE:
{
sState = "Deleting ..."; sState = "Deleting ...";
it->calculateTaskDuration(); it->calculateTaskDuration();
sTime = this->formatTimeDuration(it->getTaskDuration()); sTime = this->formatTimeDuration(it->getTaskDuration());
break; break;
case Drive::NONE: }
case Drive::SHRED_SELECTED: case Drive::TaskState::NONE:
case Drive::DELETE_SELECTED: case Drive::TaskState::SHRED_SELECTED:
case Drive::CHECK_SUCCESSFUL: case Drive::TaskState::DELETE_SELECTED:
case Drive::TaskState::CHECK_SUCCESSFUL:
{
if (it->bWasDeleted) if (it->bWasDeleted)
{ {
sState = "DELETED"; // mark drive as deleted previously sState = "DELETED"; // mark drive as deleted previously
@ -166,15 +176,15 @@ void TUI::updateTUI(list<Drive> *plistDrives, uint8_t u8SelectedEntry)
} }
#ifdef ZERO_CHECK #ifdef ZERO_CHECK
if (bSelectedEntry && it->bWasChecked && (it->state == Drive::CHECK_FAILED)) if (bSelectedEntry && it->bWasChecked && (it->state == Drive::TaskState::CHECK_FAILED))
{ {
dialog = createZeroChecksumWarning(70, 16, ((u16StdscrX) - (int)(u16StdscrX / 2) - 20), (int)(u16StdscrY / 2) - 8, it->getPath(), it->getModelFamily(), it->getModelName(), it->getSerial(), it->u32DriveChecksumAfterShredding); dialog = createZeroChecksumWarning(70, 16, ((u16StdscrX) - (int)(u16StdscrX / 2) - 20), (int)(u16StdscrY / 2) - 8, it->getPath(), it->getModelFamily(), it->getModelName(), it->getSerial(), it->u32DriveChecksumAfterShredding);
wrefresh(dialog); wrefresh(dialog);
} }
#endif #endif
break; break;
case Drive::FROZEN: }
case Drive::TaskState::FROZEN:
stream << fixed << setprecision(3) << (it->getTaskPercentage()); stream << fixed << setprecision(3) << (it->getTaskPercentage());
#ifdef FROZEN_ALERT #ifdef FROZEN_ALERT
if (bSelectedEntry) if (bSelectedEntry)
@ -290,7 +300,7 @@ WINDOW *TUI::createOverViewWindow(int iXSize, int iYSize)
return newWindow; return newWindow;
} }
WINDOW *TUI::createDetailViewWindow(int iXSize, int iYSize, int iXStart, Drive drive) WINDOW *TUI::createDetailViewWindow(int iXSize, int iYSize, int iXStart, Drive &drive)
{ {
WINDOW *newWindow; WINDOW *newWindow;
newWindow = newwin(iYSize, iXSize, 1, iXStart); newWindow = newwin(iYSize, iXSize, 1, iXStart);
@ -633,7 +643,7 @@ void TUI::vTruncateText(string *psText, uint16_t u16MaxLenght)
} }
} }
void TUI::displaySelectedDrive(Drive drive, int stdscrX, int stdscrY) void TUI::displaySelectedDrive(Drive &drive, int stdscrX, int stdscrY)
{ {
struct MenuState menustate; struct MenuState menustate;
static bool dialogIsActive; static bool dialogIsActive;
@ -646,27 +656,27 @@ void TUI::displaySelectedDrive(Drive drive, int stdscrX, int stdscrY)
// set menustate based on drive state // set menustate based on drive state
switch (drive.state) switch (drive.state)
{ {
case Drive::NONE: // no task running or selected for this drive case Drive::TaskState::NONE: // no task running or selected for this drive
menustate.bShred = true; menustate.bShred = true;
menustate.bDelete = true; menustate.bDelete = true;
break; break;
case Drive::DELETE_ACTIVE: // delete task running for this drive case Drive::TaskState::DELETE_ACTIVE: // delete task running for this drive
menustate.bAbort = true; menustate.bAbort = true;
break; break;
case Drive::SHRED_ACTIVE: // shred task running for this drive case Drive::TaskState::SHRED_ACTIVE: // shred task running for this drive
menustate.bAbort = true; menustate.bAbort = true;
break; break;
case Drive::CHECK_ACTIVE: // check task running for this drive case Drive::TaskState::CHECK_ACTIVE: // check task running for this drive
menustate.bAbort = true; menustate.bAbort = true;
break; break;
case Drive::DELETE_SELECTED: // delete task selected for this drive case Drive::TaskState::DELETE_SELECTED: // delete task selected for this drive
menustate.bConfirmDelete = true; menustate.bConfirmDelete = true;
break; break;
case Drive::SHRED_SELECTED: // shred task selected for this drive case Drive::TaskState::SHRED_SELECTED: // shred task selected for this drive
menustate.bConfirmShred = true; menustate.bConfirmShred = true;
break; break;
default: default: