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

Compare commits

base: localhorst:master
Branches Tags
localhorst:master
localhorst:test/ipc-dummy
localhorst:1.2.0
localhorst:1.1.3
localhorst:1.1.2
localhorst:1.1.1
localhorst:b1.1.0
localhorst:b0.3.0
localhorst:b0.2.2
localhorst:b0.2.0
localhorst:b0.1.0
localhorst:1.0.0
..
compare: localhorst:b0.2.2
Branches Tags
localhorst:master
localhorst:test/ipc-dummy
localhorst:1.2.0
localhorst:1.1.3
localhorst:1.1.2
localhorst:1.1.1
localhorst:b1.1.0
localhorst:b0.3.0
localhorst:b0.2.2
localhorst:b0.2.0
localhorst:b0.1.0
localhorst:1.0.0

No commits in common. "master" and "b0.2.2" have entirely different histories.
master ... b0.2.2

27 changed files with 1180 additions and 1874 deletions
Show Stats Expand all files Collapse all files

5
.gitignore vendored
View File

@ -41,10 +41,7 @@
reHDD reHDD
*.log reHDD.log
*.ods
*.txt
.vscode/
ignoreDrives.conf ignoreDrives.conf

3
.gitmodules vendored
View File

@ -1,3 +0,0 @@
[submodule "tfnoisegen"]
path = tfnoisegen
url = https://git.mosad.xyz/localhorst/tfnoisegen.git

31
README.md
View File

@ -1,33 +1,18 @@
# reHDD # reHDD
## Features: ## Useful for:
* show S.M.A.R.T values of attached drives * checking new drives for the first time
* checking used drives for their next live based on threshold limits * checking used drives for their next live
* delete a drive instant with wipefs
* deleting a drive securely via overwriting * deleting a drive securely via overwriting
* only needs a display and keyboard
* process multiple drives at once
## Download USB Image ##
See reHDD-Bootable how the live image created: https://git.mosad.xyz/localhorst/reHDD-Bootable
Use [Etcher](https://www.balena.io/etcher/#download) or `dd` to create an bootable USB drive .
## Screenshot ## Screenshot
![Screenshot of reHDD with multiple drives in different states](https://git.mosad.xyz/localhorst/reHDD/raw/commit/c40dfe2cbb8f86490b49caf82db70a10015f06f9/doc/screenshot.png "Screenshot") ![alt text](https://git.mosad.xyz/localhorst/reHDD/raw/commit/42bc26eac95429e20c0f0d59f684dfec0d600e75/doc/screenshot.png "Screenshot")
## Debian Build Notes ## Debian Build Notes
* `apt-get install ncurses-dev git make g++` * `apt-get install ncurses-dev git make g++`
* `git submodule init`
* `git submodule update`
* `make release` * `make release`
## Enable Label Printer ##
Just install [reHDDPrinter](https://git.mosad.xyz/localhorst/reHDDPrinter).
No further settings needed.
## Create Standalone with Debian 11 ## Create Standalone with Debian 11
Instructions how to create a standalone machine that boots directly to reHDD. This is aimed for production use, like several drives a day shredding. Instructions how to create a standalone machine that boots directly to reHDD. This is aimed for production use, like several drives a day shredding.
@ -37,17 +22,13 @@ Instructions how to create a standalone machine that boots directly to reHDD. Th
* Upload reHDD log every 12h if wanted * Upload reHDD log every 12h if wanted
### Software requirements ### Software requirements
* `apt-get install hwinfo smartmontools curl htop sudo` * `apt-get install hwinfo smartmontools curl`
### Installation ### Installation
clone this repo into /root/ clone this repo into /root/
```
git submodule init
git submodule update
```
`cd /root/reHDD/` `cd /root/reHDD/`
`make release` `make release`

17
astyle.sh Normal file
View File

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

BIN
doc/screenshot.png
View File

Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 92 KiB

After

Width:  |  Height:  |  Size: 90 KiB

1
ignoreDrives.conf
View File

@ -1,3 +1,2 @@
4673974d 4673974d
2cb3dea4 2cb3dea4
8ffbc421

2
include/delete.h
View File

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

51
include/drive.h
View File

@ -14,49 +14,21 @@ class Drive
{ {
public: public:
enum TaskState enum TaskState {NONE,
{
NONE,
SHRED_SELECTED, SHRED_SELECTED,
SHRED_ACTIVE, // shred iterations active SHRED_ACTIVE,
CHECK_ACTIVE, // optional checking active
DELETE_SELECTED, DELETE_SELECTED,
DELETE_ACTIVE, DELETE_ACTIVE,
FROZEN FROZEN
} state; } state;
enum ConnectionType bool bWasShredded = false;
{ bool bWasDeleteted = false;
UNKNOWN,
USB,
SATA,
NVME
} connectionType;
struct
{
time_t u32ShredTimeDelta;
std::chrono::time_point<std::chrono::system_clock> chronoShredTimestamp;
unsigned long ulWrittenBytes;
unsigned long ulSpeedMetricBytesWritten;
} sShredSpeed;
bool bWasShredded = false; // all shred iterations done
bool bWasShredStarted = false; // shred was atleast once started
bool bWasChecked = false; // all shred iterations and optional checking done
bool bWasDeleted = false;
bool bIsOffline = false; bool bIsOffline = false;
uint32_t u32DriveChecksumAfterShredding = 0U; uint32_t u32DriveChecksumAferShredding = 0U;
private: private:
string sPath; string sPath;
time_t u32Timestamp = 0U; // unix timestamp for detecting a frozen drive
double d32TaskPercentage = 0U; // in percent for Shred (1 to 100)
time_t u32TimestampTaskStart = 0U; // unix timestamp for duration of an action
time_t u32TaskDuration = 0U; // time needed to complete the task
struct
{
string sModelFamily; string sModelFamily;
string sModelName; string sModelName;
string sSerial; string sSerial;
@ -64,13 +36,16 @@ private:
uint32_t u32ErrorCount = 0U; uint32_t u32ErrorCount = 0U;
uint32_t u32PowerOnHours = 0U; //in hours uint32_t u32PowerOnHours = 0U; //in hours
uint32_t u32PowerCycles = 0U; uint32_t u32PowerCycles = 0U;
uint32_t u32Temperature = 0U; // in Fahrenheit, just kidding: degree Celsius time_t u32Timestamp = 0U; //unix timestamp for detecting a frozen drive
} sSmartData; double d32TaskPercentage = 0U; //in percent for Shred (1 to 100)
time_t u32TimestampTaskStart = 0U; //unix timestamp for duration of an action
time_t u32TaskDuration = 0U; //time needed to complete the task
private: private:
void setTimestamp(); void setTimestamp();
protected: protected:
public: public:
Drive(string path) Drive(string path)
{ {
@ -85,7 +60,6 @@ public:
uint32_t getErrorCount(void); uint32_t getErrorCount(void);
uint32_t getPowerOnHours(void); //in hours uint32_t getPowerOnHours(void); //in hours
uint32_t getPowerCycles(void); uint32_t getPowerCycles(void);
uint32_t getTemperature(void); // in Fahrenheit, just kidding: degree Celsius
void checkFrozenDrive(void); void checkFrozenDrive(void);
void setDriveSMARTData( string modelFamily, void setDriveSMARTData( string modelFamily,
@ -94,14 +68,12 @@ public:
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);
string sCapacityToText(); string sCapacityToText();
string sErrorCountToText(); string sErrorCountToText();
string sPowerOnHoursToText(); string sPowerOnHoursToText();
string sPowerCyclesToText(); string sPowerCyclesToText();
string sTemperatureToText();
void setTaskPercentage(double d32TaskPercentage); void setTaskPercentage(double d32TaskPercentage);
double getTaskPercentage(void); double getTaskPercentage(void);
@ -111,6 +83,7 @@ public:
void calculateTaskDuration(); void calculateTaskDuration();
time_t getTaskDuration(); time_t getTaskDuration();
}; };
#endif // DRIVE_H_ #endif // DRIVE_H_

1
include/logger/logger.h
View File

@ -68,6 +68,7 @@ private:
~Logger(); ~Logger();
public: public:
void info(string s); void info(string s);
void warning(string s); void warning(string s);
void error(string s); void error(string s);

56
include/printer.h
View File

@ -1,56 +0,0 @@
/**
* @file printer.h
* @brief Send drive data to printer service using ipc msg queue
* @author Hendrik Schutter
* @date 24.11.2022
*/
#ifndef PRINTER_H_
#define PRINTER_H_
#include "reHDD.h"
#include <sys/ipc.h>
#include <sys/msg.h>
#define STR_BUFFER_SIZE 64U
#define IPC_MSG_QUEUE_KEY 0x1B11193C0
typedef struct
{
char caDriveIndex[STR_BUFFER_SIZE];
char caDriveHours[STR_BUFFER_SIZE];
char caDriveCycles[STR_BUFFER_SIZE];
char caDriveErrors[STR_BUFFER_SIZE];
char caDriveShredTimestamp[STR_BUFFER_SIZE];
char caDriveShredDuration[STR_BUFFER_SIZE];
char caDriveCapacity[STR_BUFFER_SIZE];
char caDriveState[STR_BUFFER_SIZE];
char caDriveModelFamily[STR_BUFFER_SIZE];
char caDriveModelName[STR_BUFFER_SIZE];
char caDriveSerialnumber[STR_BUFFER_SIZE];
char caDriveReHddVersion[STR_BUFFER_SIZE];
} t_driveData;
typedef struct
{
long msg_queue_type;
t_driveData driveData;
} t_msgQueueData;
class Printer
{
protected:
public:
static Printer *getPrinter();
void print(Drive *drive);
private:
static bool instanceFlag;
static Printer *single;
int msqid;
Printer();
~Printer();
};
#endif // PRINTER_H_

29
include/reHDD.h
View File

@ -8,21 +8,19 @@
#ifndef REHDD_H_ #ifndef REHDD_H_
#define REHDD_H_ #define REHDD_H_
#define REHDD_VERSION "V1.2.0" #define REHDD_VERSION "bV0.2.2"
// Drive handling Settings // Drive handling Settings
#define WORSE_HOURS 19200 //mark drive if at this limit or beyond #define WORSE_HOURS 19200 //mark drive if at this limit or beyond
#define WORSE_POWERUP 10000 //mark drive if at this limit or beyond #define WORSE_POWERUP 10000 //mark drive if at this limit or beyond
#define WORSE_TEMPERATURE 55 // mark drive if at this limit or beyond
#define SHRED_ITERATIONS 3U #define SHRED_ITERATIONS 3U
#define FROZEN_TIMEOUT 20 // After this timeout (minutes) the drive will be marked as frozen, if no progress #define FROZEN_TIMEOUT 10 //After this timeout (minutes) the drive will be marked as frozen
#define METRIC_THRESHOLD 3L * 1000L * 1000L * 1000L // calc shred speed with this minimum of time delta
// Logger Settings // Logger Settings
#define LOG_PATH "./reHDD.log" #define LOG_PATH "./reHDD.log"
#define DESCRIPTION "reHDD - Copyright Hendrik Schutter 2025" #define DESCRIPTION "reHDD - Copyright Hendrik Schutter 2022"
#define DEVICE_ID "generic" #define DEVICE_ID "generic"
#define SOFTWARE_VERSION REHDD_VERSION #define SOFTWARE_VERSION "alpha"
#define HARDWARE_VERSION "generic" #define HARDWARE_VERSION "generic"
//#define LOG_LEVEL_HIGH //log everything, like drive scan thread //#define LOG_LEVEL_HIGH //log everything, like drive scan thread
@ -31,9 +29,9 @@
#endif #endif
// Logic // Logic
// #define DRYRUN // don't touch the drives //#define DRYRUN //don´t touch the drives
#define FROZEN_ALERT //show alert if drive is frozen #define FROZEN_ALERT //show alert if drive is frozen
#define ZERO_CHECK // check drive after shred if all bytes are zero, show alert if this fails #define ZERO_CHECK_ALERT //check drive after shred if all bytes are zero, show alert if this fails
//IPC pipes //IPC pipes
#define READ 0 #define READ 0
@ -64,13 +62,11 @@ using namespace std;
#include "shred.h" #include "shred.h"
#include "delete.h" #include "delete.h"
#include "tui.h" #include "tui.h"
#include "printer.h"
#include "logger/logger.h" #include "logger/logger.h"
extern Logger* logging; extern Logger* logging;
template <typename T, typename I> template <typename T, typename I> T* iterator_to_pointer(I i)
T *iterator_to_pointer(I i)
{ {
return (&(*i)); return (&(*i));
} }
@ -78,23 +74,21 @@ T *iterator_to_pointer(I i)
class reHDD class reHDD
{ {
protected: protected:
public: public:
reHDD(void); reHDD(void);
static void app_logic(); static void app_logic();
private: private:
static void searchDrives(list <Drive>* plistDrives); static void searchDrives(list <Drive>* plistDrives);
static void printDrives(list <Drive>* plistDrives); static void printDrives(list <Drive>* plistDrives);
static void startShredAllDrives(list<Drive> *plistDrives);
static void stopShredAllDrives(list<Drive> *plistDrives);
static void updateShredMetrics(list<Drive> *plistDrives);
static void filterIgnoredDrives(list <Drive>* plistDrives); static void filterIgnoredDrives(list <Drive>* plistDrives);
static void filterInvalidDrives(list<Drive> *plistDrives);
static void filterNewDrives(list <Drive>* plistOldDrives, list <Drive>* plistNewDrives); static void filterNewDrives(list <Drive>* plistOldDrives, list <Drive>* plistNewDrives);
static void addSMARTData(list <Drive>* plistDrives); static void addSMARTData(list <Drive>* plistDrives);
static void ThreadScanDevices(); static void ThreadScannDevices();
static void ThreadUserInput(); static void ThreadUserInput();
static void ThreadShred(Drive *const pDrive); static void ThreadShred();
static void ThreadDelete(); static void ThreadDelete();
static void ThreadCheckFrozenDrives(); static void ThreadCheckFrozenDrives();
static void handleArrowKey(TUI::UserInput userInput); static void handleArrowKey(TUI::UserInput userInput);
@ -102,7 +96,6 @@ private:
static void handleESC(); static void handleESC();
static void handleAbort(); static void handleAbort();
static Drive* getSelectedDrive(); static Drive* getSelectedDrive();
static bool getSystemDrive(string &systemDrive);
}; };
#endif // REHDD_H_ #endif // REHDD_H_

11
include/shred.h
View File

@ -17,12 +17,11 @@
#include <unistd.h> #include <unistd.h>
#include <string.h> #include <string.h>
#define CHUNK_SIZE 1024 * 1024 * 32 // amount of bytes that are overwritten at once --> 32MB #define CHUNK_SIZE 1024*1024*2 //amount of bytes that are overwritten at once --> 2MB
#define TFNG_DATA_SIZE CHUNK_SIZE // amount of bytes used by tfng #define CHUNK_DIMENSION 100U //amount of chunks are read at once from random source
//#define DEMO_DRIVE_SIZE 1024*1024*256L // 256MB //#define DEMO_DRIVE_SIZE 1024*1024*256L // 256MB
//#define DEMO_DRIVE_SIZE 1024*1024*1024L // 1GB //#define DEMO_DRIVE_SIZE 1024*1024*1024L // 1GB
// #define DEMO_DRIVE_SIZE 5*1024*1024*1024L // 5GB
//#define DEMO_DRIVE_SIZE 1024*1024*1024*10L // 10GB //#define DEMO_DRIVE_SIZE 1024*1024*1024*10L // 10GB
typedef int fileDescriptor; typedef int fileDescriptor;
@ -30,7 +29,9 @@ typedef int fileDescriptor;
class Shred class Shred
{ {
protected: protected:
public: public:
Shred(); Shred();
~Shred(); ~Shred();
int shredDrive(Drive* drive, int* ipSignalFd); int shredDrive(Drive* drive, int* ipSignalFd);
@ -38,8 +39,7 @@ public:
private: private:
fileDescriptor randomSrcFileDiscr; fileDescriptor randomSrcFileDiscr;
fileDescriptor driveFileDiscr; fileDescriptor driveFileDiscr;
unsigned char caTfngData[TFNG_DATA_SIZE]; unsigned char caChunk[CHUNK_DIMENSION][CHUNK_SIZE];
unsigned char caReadBuffer[CHUNK_SIZE];
unsigned long ulDriveByteSize; unsigned long ulDriveByteSize;
unsigned long ulDriveByteOverallCount = 0; //all bytes shredded in all iterations + checking -> used for progress calculation unsigned long ulDriveByteOverallCount = 0; //all bytes shredded in all iterations + checking -> used for progress calculation
double d32Percent = 0.0; double d32Percent = 0.0;
@ -50,6 +50,7 @@ private:
unsigned long getDriveSizeInBytes(fileDescriptor file); unsigned 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();
}; };
#endif // SHRED_H_ #endif // SHRED_H_

25
include/smart.h
View File

@ -13,21 +13,28 @@
class SMART class SMART
{ {
protected: protected:
public: public:
static void readSMARTData(Drive* drive); static void readSMARTData(Drive* drive);
private: private:
SMART(void); SMART(void);
static bool parseExitStatus(string sLine, uint8_t &status); static void parseModelFamily(string sLine);
static bool parseModelFamily(string sLine, string &modelFamily); static void parseModelName(string sLine);
static bool parseModelName(string sLine, string &modelName); static void parseSerial(string sLine);
static bool parseSerial(string sLine, string &serial); static void parseCapacity(string sLine);
static bool parseCapacity(string sLine, uint64_t &capacity); static void parseErrorCount(string sLine);
static bool parseErrorCount(string sLine, uint32_t &errorCount); static void parsePowerOnHours(string sLine);
static bool parsePowerOnHours(string sLine, uint32_t &powerOnHours); static void parsePowerCycle(string sLine);
static bool parsePowerCycles(string sLine, uint32_t &powerCycles);
static bool parseTemperature(string sLine, uint32_t &temperature); static string modelFamily;
static string modelName;
static string serial;
static uint64_t capacity;
static uint32_t errorCount;
static uint32_t powerOnHours;
static uint32_t powerCycle;
}; };
#endif // SMART_H_ #endif // SMART_H_

30
include/tui.h
View File

@ -12,28 +12,17 @@
#define COLOR_AREA_STDSCR 1 #define COLOR_AREA_STDSCR 1
#define COLOR_AREA_OVERVIEW 2 #define COLOR_AREA_OVERVIEW 2
#define COLOR_AREA_ENTRY_EVEN 3 #define COLOR_AREA_ENTRY 3
#define COLOR_AREA_ENTRY_ODD 4 #define COLOR_AREA_ENTRY_SELECTED 4
#define COLOR_AREA_ENTRY_SELECTED 5 #define COLOR_AREA_DETAIL 5
#define COLOR_AREA_DETAIL 6
class TUI class TUI
{ {
protected: protected:
public: public:
enum UserInput
{ enum UserInput { UpKey, DownKey, Abort, Shred, Delete, Enter, ESC, Undefined};
UpKey,
DownKey,
Abort,
Shred,
ShredAll,
Delete,
Enter,
ESC,
Terminate,
Undefined
};
struct MenuState struct MenuState
{ {
bool bAbort; bool bAbort;
@ -67,17 +56,16 @@ private:
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, string sModelFamily, string sModelName, string sCapacity, string sState, string sTime, 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, 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* 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, uint32_t u32Temperature); static WINDOW* createSmartWarning(int iXSize, int iYSize, int iXStart, int iYStart, string sPath, uint32_t u32PowerOnHours, uint32_t u32PowerCycles, uint32_t u32ErrorCount);
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, string sPath, string sModelFamily, string sModelName, 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); string formatTimeDuration(time_t u32Duration);
string formatSpeed(time_t u32ShredTimeDelta, unsigned long ulWrittenBytes);
static void vTruncateText(string *psText, uint16_t u16MaxLenght);
}; };
#endif // TUI_H_ #endif // TUI_H_

18
makefile
View File

@ -8,22 +8,19 @@ SRC_EXT = cpp
# Path to the source directory, relative to the makefile # Path to the source directory, relative to the makefile
SRC_PATH = src SRC_PATH = src
# Space-separated pkg-config libraries used by this project # Space-separated pkg-config libraries used by this project
LIBS = lib LIBS =
# General compiler flags # General compiler flags
COMPILE_FLAGS = -std=c++23 -Wall -Wextra -g COMPILE_FLAGS = -std=c++17 -Wall -Wextra -g
# Additional release-specific flags # Additional release-specific flags
RCOMPILE_FLAGS = -D NDEBUG -Ofast RCOMPILE_FLAGS = -D NDEBUG
# Additional debug-specific flags # Additional debug-specific flags
DCOMPILE_FLAGS = -D DEBUG 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 = -lpthread -lncurses
# Doc # Doc
DOCDIR = doc DOCDIR = doc
TFRANDDIR = tfnoisegen
TFRANDLIB = libtfng.a
#### END PROJECT SETTINGS #### #### END PROJECT SETTINGS ####
# Optionally you may move the section above to a separate config.mk file, and # Optionally you may move the section above to a separate config.mk file, and
@ -161,7 +158,6 @@ dirs:
@echo "Creating directories" @echo "Creating directories"
@mkdir -p $(dir $(OBJECTS)) @mkdir -p $(dir $(OBJECTS))
@mkdir -p $(BIN_PATH) @mkdir -p $(BIN_PATH)
@mkdir -p $(LIBS)
# Removes all build files # Removes all build files
.PHONY: clean .PHONY: clean
@ -171,22 +167,16 @@ clean:
@echo "Deleting directories" @echo "Deleting directories"
@$(RM) -r build @$(RM) -r build
@$(RM) -r bin @$(RM) -r bin
@$(RM) -r $(LIBS)
@$(RM) -f reHDD.log @$(RM) -f reHDD.log
$(MAKE) clean -C tfnoisegen
# Main rule, checks the executable and symlinks to the output # Main rule, checks the executable and symlinks to the output
all: $(BIN_PATH)/$(BIN_NAME) all: $(BIN_PATH)/$(BIN_NAME)
$(MAKE) libtfng.a -C tfnoisegen
@cp $(TFRANDDIR)/$(TFRANDLIB) $(LIBS)
@echo "Making symlink: $(BIN_NAME) -> $<" @echo "Making symlink: $(BIN_NAME) -> $<"
@$(RM) $(BIN_NAME) @$(RM) $(BIN_NAME)
@ln -s $(BIN_PATH)/$(BIN_NAME) $(BIN_NAME) @ln -s $(BIN_PATH)/$(BIN_NAME) $(BIN_NAME)
# Link the executable # Link the executable
$(BIN_PATH)/$(BIN_NAME): $(OBJECTS) $(BIN_PATH)/$(BIN_NAME): $(OBJECTS)
$(MAKE) libtfng.a -C tfnoisegen
@cp $(TFRANDDIR)/$(TFRANDLIB) $(LIBS)
@echo "Linking: $@" @echo "Linking: $@"
@$(START_TIME) @$(START_TIME)
$(CMD_PREFIX)$(CXX) $(OBJECTS) $(LDFLAGS) -o $@ $(CMD_PREFIX)$(CXX) $(OBJECTS) $(LDFLAGS) -o $@

2
scripts/getty@tty2.service.d_override.conf
View File

@ -4,7 +4,7 @@ Description=dmesg on tty2
[Service] [Service]
WorkingDirectory=/usr/bin/ WorkingDirectory=/usr/bin/
ExecStart= ExecStart=
ExecStart=-/usr/bin/dmesg -wHT ExecStart=-/usr/bin/dmesg -wH
StandardInput=tty StandardInput=tty
StandardOutput=tty StandardOutput=tty
Restart=always Restart=always

22
scripts/update.sh
View File

@ -2,17 +2,15 @@
echo starting update echo starting update
systemctl stop /lib/systemd/system/getty@tty1.service.d FILE=./ignoreDrives.conf
cd /root/reHDD/
FILE=../ignoreDrives.conf
if test -f "$FILE"; then if test -f "$FILE"; then
echo "backup exits already" echo backup exits
else else
cp /root/reHDD/ignoreDrives.conf /root/ignoreDrives.conf cp reHDD/ignoreDrives.conf ./ignoreDrives.conf
fi fi
cd reHDD
git reset git reset
git stash force git stash force
@ -23,14 +21,6 @@ git checkout master
git pull git pull
git submodule init
git submodule update
make clean
make release make release
cp /root/ignoreDrives.conf /root/reHDD/ignoreDrives.conf cp ../ignoreDrives.conf ./
systemctl start /lib/systemd/system/getty@tty1.service.d

4
src/delete.cpp
View File

@ -32,9 +32,6 @@ void Delete::deleteDrive(Drive *drive)
const char* cpComand = sCMD.c_str(); const char* cpComand = sCMD.c_str();
//cout << "delete: " << cpComand << endl; //cout << "delete: " << cpComand << endl;
if (drive->bWasShredStarted == false)
{
//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)
@ -43,4 +40,3 @@ void Delete::deleteDrive(Drive *drive)
} }
pclose(deleteCmdOutput); pclose(deleteCmdOutput);
} }
}

51
src/drive.cpp
View File

@ -14,41 +14,36 @@ string Drive::getPath(void)
string Drive::getModelFamily(void) string Drive::getModelFamily(void)
{ {
return sSmartData.sModelFamily; return sModelFamily;
} }
string Drive::getModelName(void) string Drive::getModelName(void)
{ {
return sSmartData.sModelName; return sModelName;
} }
string Drive::getSerial(void) string Drive::getSerial(void)
{ {
return sSmartData.sSerial; return sSerial;
} }
uint64_t Drive::getCapacity(void) uint64_t Drive::getCapacity(void)
{ {
return sSmartData.u64Capacity; return u64Capacity;
} }
uint32_t Drive::getErrorCount(void) uint32_t Drive::getErrorCount(void)
{ {
return sSmartData.u32ErrorCount; return u32ErrorCount;
} }
uint32_t Drive::getPowerOnHours(void) uint32_t Drive::getPowerOnHours(void)
{ {
return sSmartData.u32PowerOnHours; return u32PowerOnHours;
} }
uint32_t Drive::getPowerCycles(void) uint32_t Drive::getPowerCycles(void)
{ {
return sSmartData.u32PowerCycles; return u32PowerCycles;
}
uint32_t Drive::getTemperature(void)
{
return sSmartData.u32Temperature;
} }
string Drive::sCapacityToText() string Drive::sCapacityToText()
@ -72,6 +67,7 @@ string Drive::sErrorCountToText()
return to_string(getErrorCount()); return to_string(getErrorCount());
} }
string Drive::sPowerOnHoursToText() string Drive::sPowerOnHoursToText()
{ {
double dDays = 0U; double dDays = 0U;
@ -96,12 +92,6 @@ string Drive::sPowerCyclesToText()
return to_string(getPowerCycles()); return to_string(getPowerCycles());
} }
string Drive::sTemperatureToText()
{
return to_string(getTemperature()) + " C";
;
}
void Drive::setTaskPercentage(double d32TaskPercentage) void Drive::setTaskPercentage(double d32TaskPercentage)
{ {
if(d32TaskPercentage <= 100) if(d32TaskPercentage <= 100)
@ -115,6 +105,7 @@ double Drive::getTaskPercentage(void)
return this->d32TaskPercentage; return this->d32TaskPercentage;
} }
/** /**
* \brief set S.M.A.R.T. values in model * \brief set S.M.A.R.T. values in model
* \param string modelFamily * \param string modelFamily
@ -124,7 +115,6 @@ double Drive::getTaskPercentage(void)
* \param uint32_t errorCount * \param uint32_t errorCount
* \param uint32_t powerOnHours * \param uint32_t powerOnHours
* \param uint32_t powerCycle * \param uint32_t powerCycle
* \param uint32_t temperature
* \return void * \return void
*/ */
void Drive::setDriveSMARTData( string modelFamily, void Drive::setDriveSMARTData( string modelFamily,
@ -133,17 +123,16 @@ void Drive::setDriveSMARTData(string modelFamily,
uint64_t capacity, uint64_t capacity,
uint32_t errorCount, uint32_t errorCount,
uint32_t powerOnHours, uint32_t powerOnHours,
uint32_t powerCycle, uint32_t powerCycle)
uint32_t temperature)
{ {
this->sSmartData.sModelFamily = modelFamily; this->sModelFamily = modelFamily;
this->sSmartData.sModelName = modelName; sModelName = modelName;
this->sSmartData.sSerial = serial; sSerial = serial;
this->sSmartData.u64Capacity = capacity; u64Capacity = capacity;
this->sSmartData.u32ErrorCount = errorCount; u32ErrorCount = errorCount;
this->sSmartData.u32PowerOnHours = powerOnHours; u32PowerOnHours = powerOnHours;
this->sSmartData.u32PowerCycles = powerCycle; u32PowerCycles = powerCycle;
this->sSmartData.u32Temperature = temperature;
} }
void Drive::setTimestamp() void Drive::setTimestamp()
@ -179,10 +168,10 @@ void Drive::checkFrozenDrive(void)
time_t u32localtime; time_t u32localtime;
time(&u32localtime); time(&u32localtime);
if ((u32localtime - this->u32Timestamp) >= (FROZEN_TIMEOUT * 60) && (this->u32Timestamp > 0) && (this->getTaskPercentage() < 100.0)) if((u32localtime - this->u32Timestamp) >= (FROZEN_TIMEOUT*60) && (this->u32Timestamp > 0))
{ {
Logger::logThis()->warning("Drive Frozen: " + this->getModelName() + " " + this->getSerial()); Logger::logThis()->warning("Drive Frozen: " + this->getModelName() + " " + this->getSerial());
this->bWasDeleted = false; this->bWasDeleteted = false;
this->bWasShredded = false; this->bWasShredded = false;
this->state = Drive::FROZEN; this->state = Drive::FROZEN;
} }

6
src/logger/logger.cpp
View File

@ -5,6 +5,7 @@
* @date 04.09.2020 * @date 04.09.2020
*/ */
#include "../../include/reHDD.h" //for logger settings #include "../../include/reHDD.h" //for logger settings
#include "../../include/logger/logger.h" #include "../../include/logger/logger.h"
@ -17,6 +18,8 @@ Logger *Logger::single = NULL;
/** /**
* \brief create new logger instance * \brief create new logger instance
* \param path to log file
* \param struct with data
* \return instance of Logger * \return instance of Logger
*/ */
Logger::Logger() Logger::Logger()
@ -152,6 +155,7 @@ string Logger::getMacAddress()
if (ioctl(s, SIOCGIFHWADDR, &ifr) < 0) if (ioctl(s, SIOCGIFHWADDR, &ifr) < 0)
{ {
strcpy(ifr.ifr_name, "eno1"); strcpy(ifr.ifr_name, "eno1");
} }
unsigned char *hwaddr = (unsigned char *)ifr.ifr_hwaddr.sa_data; unsigned char *hwaddr = (unsigned char *)ifr.ifr_hwaddr.sa_data;
@ -227,3 +231,5 @@ Logger *Logger::logThis()
return single; //return existing obj return single; //return existing obj
} }
} }

84
src/printer.cpp
View File

@ -1,84 +0,0 @@
/**
* @file printer.cpp
* @brief Send drive data to printer service using ipc msg queue
* @author Hendrik Schutter
* @date 24.11.2022
*/
#include "../include/reHDD.h"
bool Printer::instanceFlag = false;
Printer *Printer::single = NULL;
/**
* \brief create new Printer instance
* \param path to log file
* \param struct with data
* \return instance of Printer
*/
Printer::Printer()
{
if (-1 == (this->msqid = msgget((key_t)IPC_MSG_QUEUE_KEY, IPC_CREAT | 0666)))
{
Logger::logThis()->error("Printer: Create mgs queue failed!");
}
}
/**
* \brief deconstructor
* \return void
*/
Printer::~Printer()
{
instanceFlag = false;
}
/**
* \brief send data to msg queue
* \return void
*/
void Printer::print(Drive *drive)
{
t_msgQueueData msgQueueData;
msgQueueData.msg_queue_type = 1;
sprintf(msgQueueData.driveData.caDriveIndex, "%i", 42); // TODO: get from tui
sprintf(msgQueueData.driveData.caDriveState, "shredded");
strcpy(msgQueueData.driveData.caDriveModelFamily, drive->getModelFamily().c_str());
strcpy(msgQueueData.driveData.caDriveModelName, drive->getModelName().c_str());
sprintf(msgQueueData.driveData.caDriveCapacity, "%li", drive->getCapacity());
strcpy(msgQueueData.driveData.caDriveSerialnumber, drive->getSerial().c_str());
sprintf(msgQueueData.driveData.caDriveHours, "%i", drive->getPowerOnHours());
sprintf(msgQueueData.driveData.caDriveCycles, "%i", drive->getPowerCycles());
sprintf(msgQueueData.driveData.caDriveErrors, "%i", drive->getErrorCount());
sprintf(msgQueueData.driveData.caDriveShredTimestamp, "%li", drive->getActionStartTimestamp());
sprintf(msgQueueData.driveData.caDriveShredDuration, "%li", drive->getTaskDuration());
sprintf(msgQueueData.driveData.caDriveReHddVersion, REHDD_VERSION);
if (-1 == msgsnd(this->msqid, &msgQueueData, sizeof(t_msgQueueData) - sizeof(long), 0))
{
Logger::logThis()->error("Printer: Send mgs queue failed!");
}
else
{
Logger::logThis()->info("Printer: print triggered - Drive: " + drive->getSerial());
}
}
/**
* \brief return a instance of the printer
* \return printer obj
*/
Printer *Printer::getPrinter()
{
if (!instanceFlag)
{
single = new Printer(); // create new obj
instanceFlag = true;
return single;
}
else
{
return single; // return existing obj
}
}

303
src/reHDD.cpp
View File

@ -11,11 +11,11 @@ static int fdNewDrivesInformPipe[2]; // File descriptor for pipe that informs if
static int fdShredInformPipe[2];//File descriptor for pipe that informs if a wipe thread signals static int fdShredInformPipe[2];//File descriptor for pipe that informs if a wipe thread signals
static std::mutex mxDrives; static std::mutex mxScannDrives;
list <Drive> listNewDrives; //store found drives that are updated every 5sec list <Drive> listNewDrives; //store found drives that are updated every 5sec
static list<Drive> listDrives; // stores all drive data from scan thread static list <Drive> listDrives; //stores all drive data from scann thread
TUI *ui; TUI *ui;
@ -46,7 +46,7 @@ void reHDD::app_logic(void)
pipe(fdNewDrivesInformPipe); pipe(fdNewDrivesInformPipe);
pipe(fdShredInformPipe); pipe(fdShredInformPipe);
thread thDevices(ThreadScanDevices); // start thread that scans for drives thread thDevices(ThreadScannDevices); //start thread that scanns for drives
thread thUserInput(ThreadUserInput); //start thread that reads user input thread thUserInput(ThreadUserInput); //start thread that reads user input
thread thCheckFrozenDrives(ThreadCheckFrozenDrives); //start thread that checks timeout for drives thread thCheckFrozenDrives(ThreadCheckFrozenDrives); //start thread that checks timeout for drives
@ -60,18 +60,17 @@ void reHDD::app_logic(void)
if(FD_ISSET(fdNewDrivesInformPipe[0], &selectSet)) if(FD_ISSET(fdNewDrivesInformPipe[0], &selectSet))
{ {
mxDrives.lock(); mxScannDrives.lock();
char dummy; char dummy;
read (fdNewDrivesInformPipe[0],&dummy,1); read (fdNewDrivesInformPipe[0],&dummy,1);
filterNewDrives(&listDrives, &listNewDrives); //filter and copy to app logic vector filterNewDrives(&listDrives, &listNewDrives); //filter and copy to app logic vector
printDrives(&listDrives); printDrives(&listDrives);
mxDrives.unlock(); mxScannDrives.unlock();
} }
if(FD_ISSET(fdShredInformPipe[0], &selectSet)) if(FD_ISSET(fdShredInformPipe[0], &selectSet))
{ {
char dummy; char dummy;
read (fdShredInformPipe[0],&dummy,1); read (fdShredInformPipe[0],&dummy,1);
updateShredMetrics(&listDrives);
#ifdef LOG_LEVEL_HIGH #ifdef LOG_LEVEL_HIGH
Logger::logThis()->info("got progress signal from a shred task"); Logger::logThis()->info("got progress signal from a shred task");
#endif #endif
@ -98,17 +97,16 @@ Drive *reHDD::getSelectedDrive()
} }
} }
void reHDD::ThreadScanDevices() void reHDD::ThreadScannDevices()
{ {
while(true) while(true)
{ {
mxDrives.lock(); mxScannDrives.lock();
listNewDrives.clear(); listNewDrives.clear();
searchDrives(&listNewDrives); //search for new drives and store them in list searchDrives(&listNewDrives); //search for new drives and store them in list
filterIgnoredDrives(&listNewDrives); //filter out ignored drives filterIgnoredDrives(&listNewDrives); //filter out ignored drives
addSMARTData(&listNewDrives); //add S.M.A.R.T. Data to the drives addSMARTData(&listNewDrives); //add S.M.A.R.T. Data to the drives
filterInvalidDrives(&listNewDrives); // filter out drives that report zero capacity mxScannDrives.unlock();
mxDrives.unlock();
write(fdNewDrivesInformPipe[1], "A",1); write(fdNewDrivesInformPipe[1], "A",1);
sleep(5); //sleep 5 sec sleep(5); //sleep 5 sec
} }
@ -118,7 +116,7 @@ void reHDD::ThreadCheckFrozenDrives()
{ {
while(true) while(true)
{ {
mxDrives.lock(); mxScannDrives.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::SHRED_ACTIVE)
@ -126,7 +124,7 @@ void reHDD::ThreadCheckFrozenDrives()
it->checkFrozenDrive(); it->checkFrozenDrive();
} }
} }
mxDrives.unlock(); mxScannDrives.unlock();
sleep(13); //sleep 13 sec sleep(13); //sleep 13 sec
} }
} }
@ -166,7 +164,6 @@ void reHDD::ThreadUserInput()
getSelectedDrive()->state = Drive::DELETE_SELECTED; getSelectedDrive()->state = Drive::DELETE_SELECTED;
} }
} }
ui->updateTUI(&listDrives, u8SelectedEntry); ui->updateTUI(&listDrives, u8SelectedEntry);
break; break;
case TUI::UserInput::Shred: case TUI::UserInput::Shred:
@ -179,12 +176,6 @@ void reHDD::ThreadUserInput()
getSelectedDrive()->state = Drive::SHRED_SELECTED; getSelectedDrive()->state = Drive::SHRED_SELECTED;
} }
} }
ui->updateTUI(&listDrives, u8SelectedEntry);
break;
case TUI::UserInput::ShredAll:
// cout << "ShredAll" << endl;
startShredAllDrives(&listDrives);
ui->updateTUI(&listDrives, u8SelectedEntry); ui->updateTUI(&listDrives, u8SelectedEntry);
break; break;
case TUI::UserInput::Enter: case TUI::UserInput::Enter:
@ -197,25 +188,19 @@ void reHDD::ThreadUserInput()
handleESC(); handleESC();
ui->updateTUI(&listDrives, u8SelectedEntry); ui->updateTUI(&listDrives, u8SelectedEntry);
break; break;
case TUI::UserInput::Terminate:
cout << "Terminate" << endl;
stopShredAllDrives(&listDrives);
sleep(5); // sleep 5 sec
std::exit(1); // Terminates main, doesn't wait for threads
break;
default: default:
break; break;
} }
} }
} }
void reHDD::ThreadShred(Drive *const pDrive) void reHDD::ThreadShred()
{ {
if (pDrive != nullptr) if (getSelectedDrive() != nullptr)
{ {
pDrive->setActionStartTimestamp(); // save timestamp at start of shredding getSelectedDrive()->setActionStartTimestamp(); //save timestamp at start of shredding
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(getSelectedDrive(), &fdShredInformPipe[1]); //start new shred task
delete pShredTask; //delete shred task delete pShredTask; //delete shred task
ui->updateTUI(&listDrives, u8SelectedEntry); ui->updateTUI(&listDrives, u8SelectedEntry);
} }
@ -228,7 +213,7 @@ void reHDD::ThreadDelete()
getSelectedDrive()->setActionStartTimestamp(); //save timestamp at start of deleting getSelectedDrive()->setActionStartTimestamp(); //save timestamp at start of deleting
Delete::deleteDrive(getSelectedDrive()); //blocking, no thread Delete::deleteDrive(getSelectedDrive()); //blocking, no thread
getSelectedDrive()->state = Drive::TaskState::NONE; //delete finished getSelectedDrive()->state = Drive::TaskState::NONE; //delete finished
getSelectedDrive()->bWasDeleted = true; getSelectedDrive()->bWasDeleteted = true;
Logger::logThis()->info("Finished delete for: " + getSelectedDrive()->getModelName() + "-" + getSelectedDrive()->getSerial()); Logger::logThis()->info("Finished delete for: " + getSelectedDrive()->getModelName() + "-" + getSelectedDrive()->getSerial());
ui->updateTUI(&listDrives, u8SelectedEntry); ui->updateTUI(&listDrives, u8SelectedEntry);
} }
@ -237,7 +222,7 @@ void reHDD::ThreadDelete()
void reHDD::filterNewDrives(list <Drive>* plistOldDrives, list <Drive>* plistNewDrives) void reHDD::filterNewDrives(list <Drive>* plistOldDrives, list <Drive>* plistNewDrives)
{ {
list <Drive>::iterator itOld; //Iterator for current (old) drive list list <Drive>::iterator itOld; //Iterator for current (old) drive list
list<Drive>::iterator itNew; // Iterator for new drive list that was created from to scan thread list <Drive>::iterator itNew; //Iterator for new drive list that was created from to scann thread
//remove offline old drives from previously run //remove offline old drives from previously run
for (itOld = plistOldDrives->begin(); itOld != plistOldDrives->end();) for (itOld = plistOldDrives->begin(); itOld != plistOldDrives->end();)
@ -261,18 +246,16 @@ void reHDD::filterNewDrives(list<Drive> *plistOldDrives, list<Drive> *plistNewDr
//search offline drives and mark them //search offline drives and mark them
for (itOld = plistOldDrives->begin(); itOld != plistOldDrives->end(); ++itOld) for (itOld = plistOldDrives->begin(); itOld != plistOldDrives->end(); ++itOld)
{ {
itOld->bIsOffline = true; // set offline before searching in the new list itOld->bIsOffline = true; //set offline befor seachring in the new list
for (itNew = plistNewDrives->begin(); itNew != plistNewDrives->end();) for (itNew = plistNewDrives->begin(); itNew != plistNewDrives->end();)
{ {
if((itOld->getSerial() == itNew->getSerial()) || (itOld->getPath() == itNew->getPath())) if((itOld->getSerial() == itNew->getSerial()) || (itOld->getPath() == itNew->getPath()))
{ {
itOld->bIsOffline = false; //drive is still attached itOld->bIsOffline = false; //drive is still attached
// copy new smart data to existing drive
itOld->setDriveSMARTData(itNew->getModelFamily(), itNew->getModelName(), itNew->getSerial(), itNew->getCapacity(), itNew->getErrorCount(), itNew->getPowerOnHours(), itNew->getPowerCycles(), itNew->getTemperature());
#ifdef LOG_LEVEL_HIGH #ifdef LOG_LEVEL_HIGH
Logger::logThis()->info("Delete new drive, because already attached: " + itNew->getModelName()); Logger::logThis()->info("Delete new drive, because allready attached: " + itNew->getModelName());
#endif #endif
itNew = plistNewDrives->erase(itNew); // This drive is already attached, remove from new list itNew = plistNewDrives->erase(itNew); //This drive is allready attached, remove from new list
} }
else else
{ {
@ -296,7 +279,7 @@ void reHDD::filterNewDrives(list<Drive> *plistOldDrives, list<Drive> *plistNewDr
for (itNew = plistNewDrives->begin(); itNew != plistNewDrives->end(); ++itNew) for (itNew = plistNewDrives->begin(); itNew != plistNewDrives->end(); ++itNew)
{ {
plistOldDrives->push_back(*itNew); plistOldDrives->push_back(*itNew);
// Logger::logThis()->info("Add new drive: " + itNew->getModelName()); Logger::logThis()->info("Add new drive: " + itNew->getModelName());
} }
plistNewDrives->clear(); plistNewDrives->clear();
} }
@ -306,51 +289,32 @@ void reHDD::filterNewDrives(list<Drive> *plistOldDrives, list<Drive> *plistNewDr
* \param pointer of list <Drive>* plistDrives * \param pointer of list <Drive>* plistDrives
* \return void * \return void
*/ */
void reHDD::searchDrives(std::list<Drive> *plistDrives) void reHDD::searchDrives(list <Drive>* plistDrives)
{ {
FILE *fp = popen("lsblk -d -n -o NAME,TRAN", "r"); Logger::logThis()->info("--> search drives <--");
if (!fp) char * cLine = NULL;
size_t len = 0;
FILE* outputfileHwinfo = popen("lsblk -I 8 -d -o NAME", "r");
if (outputfileHwinfo == NULL)
{ {
Logger::logThis()->error("Unable to execute lsblk to scan drives"); Logger::logThis()->error("Unable to scan attached drives");
exit(EXIT_FAILURE); exit(EXIT_FAILURE);
} }
char line[256]; while ((getline(&cLine, &len, outputfileHwinfo)) != -1)
while (fgets(line, sizeof(line), fp))
{ {
std::string devName, transport; if (string(cLine).length() == 4)
std::istringstream iss(line); {
iss >> devName >> transport; Drive* tmpDrive = new Drive("/dev/" + string(cLine).substr(0, 3));
if (devName.empty())
continue;
Drive *tmpDrive = new Drive("/dev/" + devName);
tmpDrive->state = Drive::NONE; tmpDrive->state = Drive::NONE;
tmpDrive->bIsOffline = false; tmpDrive->bIsOffline = false;
// Set connection type
if (transport == "sata")
tmpDrive->connectionType = Drive::SATA;
else if (transport == "usb")
tmpDrive->connectionType = Drive::USB;
else if (transport == "nvme")
tmpDrive->connectionType = Drive::NVME;
else
tmpDrive->connectionType = Drive::UNKNOWN;
plistDrives->push_back(*tmpDrive); plistDrives->push_back(*tmpDrive);
//Logger::logThis()->info("drive found: " + tmpDrive->getPath());
Logger::logThis()->info(
"Drive found: " + tmpDrive->getPath() +
" (type: " +
(tmpDrive->connectionType == Drive::USB ? "USB" : tmpDrive->connectionType == Drive::SATA ? "SATA"
: tmpDrive->connectionType == Drive::NVME ? "NVME"
: "UNKNOWN") +
")");
} }
}
pclose(fp); pclose(outputfileHwinfo);
} }
/** /**
@ -360,35 +324,15 @@ void reHDD::searchDrives(std::list<Drive> *plistDrives)
*/ */
void reHDD::filterIgnoredDrives(list <Drive>* plistDrives) void reHDD::filterIgnoredDrives(list <Drive>* plistDrives)
{ {
string systemDrivePath; list<tuple<string>> vtlIgnoredDevices; //store drives from ingnore file
if (getSystemDrive(systemDrivePath)) ifstream input( "ignoreDrives.conf" ); //read ingnore file
{
// Logger::logThis()->info("Found system drive: " + systemDrivePath);
list<Drive>::iterator it;
for (it = plistDrives->begin(); it != plistDrives->end(); ++it)
{
if (it->getPath().find(systemDrivePath) != std::string::npos) // compare found system drive and current drive
{
// system drive found --> ignore this drive
#ifdef LOG_LEVEL_HIGH
Logger::logThis()->info("system drive found --> ignore this drive: " + it->getPath());
#endif
it = plistDrives->erase(it);
it--;
}
}
}
list<tuple<string>> vtlIgnoredDevices; // store drives from ignore file
ifstream input("ignoreDrives.conf"); // read ignore file
for(string sLine; getline( input, sLine );) for(string sLine; getline( input, sLine );)
{ {
// Logger::logThis()->info("read uuid: " + sLine); Logger::logThis()->info("read uuid: " + sLine);
vtlIgnoredDevices.emplace_back(sLine); //add found path and uuid from ignore file to vector vtlIgnoredDevices.emplace_back(sLine); //add found path and uuid from ignore file to vector
} }
// loop through found entries in ignore file //loop through found entries in ingnore file
for(auto row : vtlIgnoredDevices) for(auto row : vtlIgnoredDevices)
{ {
list <Drive>::iterator it; list <Drive>::iterator it;
@ -433,81 +377,6 @@ void reHDD::filterIgnoredDrives(list<Drive> *plistDrives)
} }
} }
/**
* \brief filter out drives that are not indented for processing
* \param pointer of list <Drive>* plistDrives
* \return void
*/
void reHDD::filterInvalidDrives(list<Drive> *plistDrives)
{
list<Drive>::iterator it;
for (it = plistDrives->begin(); it != plistDrives->end(); ++it)
{
if (it->getCapacity() == 0U)
{
#ifdef LOG_LEVEL_HIGH
Logger::logThis()->info("Drive reports zero capacity --> ignore this drive: " + it->getPath());
#endif
it = plistDrives->erase(it);
it--;
}
}
}
/**
* \brief start shred for all drives
* \param pointer of list <Drive>* plistDrives
* \return void
*/
void reHDD::startShredAllDrives(list<Drive> *plistDrives)
{
list<Drive>::iterator it;
mxDrives.lock();
for (it = plistDrives->begin(); it != plistDrives->end(); ++it)
{
if (it->state == Drive::NONE)
{
Drive *pTmpDrive = iterator_to_pointer<Drive, std::list<Drive>::iterator>(it);
#ifdef LOG_LEVEL_HIGH
ostringstream address;
address << (void const *)&(*pTmpDrive);
Logger::logThis()->info("Started shred (all) for: " + pTmpDrive->getModelName() + "-" + pTmpDrive->getSerial() + " @" + address.str());
#endif
pTmpDrive->state = Drive::TaskState::SHRED_ACTIVE;
thread(ThreadShred, pTmpDrive).detach();
}
}
mxDrives.unlock();
}
/**
* \brief stop shred for all drives
* \param pointer of list <Drive>* plistDrives
* \return void
*/
void reHDD::stopShredAllDrives(list<Drive> *plistDrives)
{
list<Drive>::iterator it;
mxDrives.lock();
for (it = plistDrives->begin(); it != plistDrives->end(); ++it)
{
if (it->state == Drive::SHRED_ACTIVE || it->state == Drive::DELETE_ACTIVE)
{
it->state = Drive::NONE;
Logger::logThis()->info("Abort-Shred-Signal for: " + it->getModelName() + "-" + it->getSerial());
// task for drive is running --> remove selection
}
#ifdef LOG_LEVEL_HIGH
ostringstream address;
address << (void const *)&(*it);
Logger::logThis()->info("Started shred (all) for: " + it->getModelName() + "-" + it->getSerial() + " @" + address.str());
#endif
}
mxDrives.unlock();
}
/** /**
* \brief print drives with all information * \brief print drives with all information
* \param pointer of list <Drive>* plistDrives * \param pointer of list <Drive>* plistDrives
@ -543,33 +412,6 @@ void reHDD::printDrives(list<Drive> *plistDrives)
#endif #endif
} }
/**
* \brief update shred metrics for all drives
* \param pointer of list <Drive>* plistDrives
* \return void
*/
void reHDD::updateShredMetrics(list<Drive> *plistDrives)
{
list<Drive>::iterator it;
for (it = plistDrives->begin(); it != plistDrives->end(); ++it)
{
if (it->state == Drive::SHRED_ACTIVE)
{
Drive *pTmpDrive = iterator_to_pointer<Drive, std::list<Drive>::iterator>(it);
// set metrics for calculating shred speed
std::chrono::time_point<std::chrono::system_clock> chronoCurrentTimestamp = std::chrono::system_clock::now();
time_t u32ShredTimeDelta = (chronoCurrentTimestamp - pTmpDrive->sShredSpeed.chronoShredTimestamp).count();
if (u32ShredTimeDelta > METRIC_THRESHOLD)
{
pTmpDrive->sShredSpeed.u32ShredTimeDelta = u32ShredTimeDelta;
pTmpDrive->sShredSpeed.chronoShredTimestamp = std::chrono::system_clock::now();
pTmpDrive->sShredSpeed.ulWrittenBytes = pTmpDrive->sShredSpeed.ulSpeedMetricBytesWritten;
pTmpDrive->sShredSpeed.ulSpeedMetricBytesWritten = 0U;
}
}
}
}
/** /**
* \brief add S.M.A.R.T data from SMART * \brief add S.M.A.R.T data from SMART
* \param pointer of list <Drive>* plistDrives * \param pointer of list <Drive>* plistDrives
@ -612,28 +454,26 @@ void reHDD::handleArrowKey(TUI::UserInput userInput)
break; break;
} }
// Logger::logThis()->info("ArrowKey - selected drive: " + to_string(u8SelectedEntry)); Logger::logThis()->info("ArrowKey - selected drive: " + to_string(u8SelectedEntry));
} }
void reHDD::handleEnter() void reHDD::handleEnter()
{ {
if (getSelectedDrive() != nullptr) if (getSelectedDrive() != nullptr)
{ {
if(getSelectedDrive()->state == Drive::TaskState::SHRED_SELECTED) if(getSelectedDrive()->state == Drive::TaskState::SHRED_SELECTED)
{ {
Logger::logThis()->info("Started shred/check for: " + getSelectedDrive()->getModelName() + "-" + getSelectedDrive()->getSerial()); Logger::logThis()->info("Started shred for: " + getSelectedDrive()->getModelName() + "-" + getSelectedDrive()->getSerial());
getSelectedDrive()->state = Drive::TaskState::SHRED_ACTIVE; getSelectedDrive()->state = Drive::TaskState::SHRED_ACTIVE;
// task for drive is running --> don't show more task options //task for drive is running --> don´t show more task options
Drive *pTmpDrive = getSelectedDrive(); thread(ThreadShred).detach();
thread(ThreadShred, pTmpDrive).detach();
} }
if(getSelectedDrive()->state == Drive::TaskState::DELETE_SELECTED) if(getSelectedDrive()->state == Drive::TaskState::DELETE_SELECTED)
{ {
Logger::logThis()->info("Started delete for: " + getSelectedDrive()->getModelName() + "-" + getSelectedDrive()->getSerial()); Logger::logThis()->info("Started delete for: " + getSelectedDrive()->getModelName() + "-" + getSelectedDrive()->getSerial());
getSelectedDrive()->state = Drive::TaskState::DELETE_ACTIVE; getSelectedDrive()->state = Drive::TaskState::DELETE_ACTIVE;
// task for drive is running --> don't show more task options //task for drive is running --> don´t show more task options
thread(ThreadDelete).detach(); thread(ThreadDelete).detach();
} }
} }
@ -670,58 +510,5 @@ void reHDD::handleAbort()
} }
} }
bool reHDD::getSystemDrive(string &systemDrive)
{
char *cLine = NULL;
size_t len = 0;
bool systemDriveFound = false;
FILE *outputfileHwinfo = popen("lsblk -e 11 -o NAME,MOUNTPOINT", "r");
if (outputfileHwinfo == NULL)
{
Logger::logThis()->error("Unable to scan attached drives for system drive");
exit(EXIT_FAILURE);
}
while ((getline(&cLine, &len, outputfileHwinfo)) != -1)
{
string currentLine = cLine;
if (currentLine.find("NAME") != std::string::npos)
{
continue;
}
// Logger::logThis()->info(currentLine);
if ((cLine[0U] != '|') && (cLine[0U] != '`'))
{
systemDrive = currentLine;
systemDrive.erase(std::remove(systemDrive.begin(), systemDrive.end(), '\n'), systemDrive.end()); // remove newline
systemDrive.erase(std::remove(systemDrive.begin(), systemDrive.end(), ' '), systemDrive.end()); // remove spaces
// Logger::logThis()->info("Drive found: " + systemDrive);
}
if (currentLine.ends_with(" /boot/efi\n"s))
{
systemDriveFound = true;
break;
}
if (currentLine.ends_with(" /run/overlay/live\n"s))
{
systemDriveFound = true;
break;
}
if (currentLine.ends_with(" /\n"s))
{
systemDriveFound = true;
break;
}
}
pclose(outputfileHwinfo);
return systemDriveFound;
}

116
src/shred.cpp
View File

@ -2,20 +2,11 @@
* @file shred.cpp * @file shred.cpp
* @brief shred drive * @brief shred drive
* @author hendrik schutter * @author hendrik schutter
* @date 22.08.2022 * @date 03.05.2020
*/ */
#include "../include/reHDD.h" #include "../include/reHDD.h"
#ifdef __cplusplus
extern "C"
{
#endif
#include "../tfnoisegen/tfprng.h"
#ifdef __cplusplus
}
#endif
const static char *randomsrc = (char*) "/dev/urandom"; const static char *randomsrc = (char*) "/dev/urandom";
Shred::Shred() Shred::Shred()
@ -33,10 +24,6 @@ Shred::~Shred()
*/ */
int Shred::shredDrive(Drive* drive, int* ipSignalFd) int Shred::shredDrive(Drive* drive, int* ipSignalFd)
{ {
ostringstream address;
address << (void const *)&(*drive);
Logger::logThis()->info("Shred-Task started - Drive: " + drive->getModelName() + "-" + drive->getSerial() + " @" + address.str());
drive->bWasShredStarted = true; //Mark drive as partly shredded
#ifdef DRYRUN #ifdef DRYRUN
for(int i = 0; i<=500; i++) for(int i = 0; i<=500; i++)
@ -49,12 +36,10 @@ int Shred::shredDrive(Drive *drive, int *ipSignalFd)
write(*ipSignalFd, "A",1); write(*ipSignalFd, "A",1);
usleep(20000); usleep(20000);
} }
drive->bWasShredded = true;
#endif #endif
#ifndef DRYRUN #ifndef DRYRUN
const char *cpDrivePath = drive->getPath().c_str(); const char *cpDrivePath = drive->getPath().c_str();
unsigned char ucKey[TFNG_KEY_SIZE];
//open random source //open random source
randomSrcFileDiscr = open(randomsrc, O_RDONLY | O_LARGEFILE); randomSrcFileDiscr = open(randomsrc, O_RDONLY | O_LARGEFILE);
@ -78,22 +63,7 @@ int Shred::shredDrive(Drive *drive, int *ipSignalFd)
return -1; return -1;
} }
// read key for random generator
ssize_t readRet = read(randomSrcFileDiscr, ucKey, sizeof(ucKey));
if (readRet <= 0)
{
std::string errorMsg(strerror(readRet));
Logger::logThis()->error("Shred-Task: Read random key failed! " + errorMsg + " - Drive: " + drive->getSerial());
perror(randomsrc);
cleanup();
return -1;
}
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->sShredSpeed.ulSpeedMetricBytesWritten = 0U; // uses to calculate speed metric
#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());
@ -102,21 +72,44 @@ int Shred::shredDrive(Drive *drive, int *ipSignalFd)
for (unsigned int uiShredIterationCounter = 0U; uiShredIterationCounter < SHRED_ITERATIONS; uiShredIterationCounter++) for (unsigned int uiShredIterationCounter = 0U; uiShredIterationCounter < SHRED_ITERATIONS; uiShredIterationCounter++)
{ {
unsigned long ulDriveByteCounter = 0U; //used for one shred-iteration to keep track of the current drive position unsigned long ulDriveByteCounter = 0U; //used for one shred-iteration to keep track of the current drive position
uint32_t u32ChunkDimensionIndex = 0U;
if(uiShredIterationCounter == (SHRED_ITERATIONS-1)) if(uiShredIterationCounter == (SHRED_ITERATIONS-1))
{ {
// last shred iteration --> overwrite (just the write chunk) bytes with zeros instead with random data //last shred iteration --> overwrite with zeros instead with random data
memset(caTfngData, 0U, CHUNK_SIZE); memset(caChunk, 0U, CHUNK_DIMENSION*CHUNK_SIZE);
} }
while (ulDriveByteCounter < ulDriveByteSize) while (ulDriveByteCounter < ulDriveByteSize)
{ {
int iBytesToShred = 0; //Bytes that will be overwritten in this chunk-iteration int iBytesToShred = 0; //Bytes that will be overwritten in this chunk-iteration
if (uiShredIterationCounter != (SHRED_ITERATIONS - 1)) if((u32ChunkDimensionIndex == 0U) && (uiShredIterationCounter != (SHRED_ITERATIONS-1)))
{ {
// NOT last shred iteration --> generate new random data //read new chunks from random source if needed and this is NOT the last shred iteration
tfng_prng_genrandom(caTfngData, TFNG_DATA_SIZE); unsigned long ulBytesInChunkBuffer = 0U;
while (ulBytesInChunkBuffer < CHUNK_DIMENSION*CHUNK_SIZE)
{
//read new random bytes
int iReadBytes = read(randomSrcFileDiscr, caChunk, ((CHUNK_DIMENSION*CHUNK_SIZE)-ulBytesInChunkBuffer));
if (iReadBytes > 0)
{
ulBytesInChunkBuffer += iReadBytes;
}
else
{
std::string errorMsg(strerror(iReadBytes));
Logger::logThis()->error("Shred-Task: Read from random source failed! " + errorMsg + " - Drive: " + drive->getSerial());
perror("unable to read random data");
cleanup();
return -1;;
}
} //end chunk read
#ifdef LOG_LEVEL_HIGH
Logger::logThis()->info("Shred-Task: Read new random data - Drive: " + drive->getSerial());
#endif
} }
if((ulDriveByteSize-ulDriveByteCounter) < CHUNK_SIZE) if((ulDriveByteSize-ulDriveByteCounter) < CHUNK_SIZE)
@ -128,7 +121,7 @@ int Shred::shredDrive(Drive *drive, int *ipSignalFd)
iBytesToShred = CHUNK_SIZE; iBytesToShred = CHUNK_SIZE;
} }
int iByteShredded = write(driveFileDiscr, caTfngData, iBytesToShred); int iByteShredded = write(driveFileDiscr, caChunk[u32ChunkDimensionIndex], iBytesToShred);
if(iByteShredded <= 0) if(iByteShredded <= 0)
{ {
@ -139,20 +132,18 @@ int Shred::shredDrive(Drive *drive, int *ipSignalFd)
return -1; return -1;
} }
u32ChunkDimensionIndex = (u32ChunkDimensionIndex+1)%CHUNK_DIMENSION;
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
drive->setTaskPercentage(d32TmpPercent); drive->setTaskPercentage(d32TmpPercent);
d32TmpPercent = d32Percent; d32TmpPercent = d32Percent;
// signal process in shreding
write(*ipSignalFd, "A",1); write(*ipSignalFd, "A",1);
} }
@ -166,34 +157,24 @@ int Shred::shredDrive(Drive *drive, int *ipSignalFd)
cleanup(); cleanup();
return -1; return -1;
} }
// end one chunk write }//end one chunk write
}
if(0 != iRewindDrive(driveFileDiscr)) if(0 != iRewindDrive(driveFileDiscr))
{ {
Logger::logThis()->error("Shred-Task: Unable to rewind drive! - Drive: " + drive->getSerial());
cleanup(); cleanup();
return -1; return -1;
} }
// end one shred iteration } //end one shred iteration
}
// end of all shred iteratio
tfng_prng_seedkey(NULL); // reset random generator #ifdef ZERO_CHECK_ALERT
drive->u32DriveChecksumAferShredding = uiCalcChecksum(driveFileDiscr, drive, ipSignalFd);
drive->bWasShredded = true;
Logger::logThis()->info("Shred-Task finished - Drive: " + drive->getModelName() + "-" + drive->getSerial() + " @" + address.str());
#ifdef ZERO_CHECK
drive->state = Drive::CHECK_ACTIVE;
Logger::logThis()->info("Check-Task started - Drive: " + drive->getModelName() + "-" + drive->getSerial() + " @" + address.str());
drive->u32DriveChecksumAfterShredding = uiCalcChecksum(driveFileDiscr, drive, ipSignalFd);
#ifdef LOG_LEVEL_HIGH #ifdef LOG_LEVEL_HIGH
if (drive->u32DriveChecksumAfterShredding != 0) if (drive->u32DriveChecksumAferShredding != 0)
{ {
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->u32DriveChecksumAferShredding) + " - Drive: " + drive->getSerial());
} }
else else
{ {
Logger::logThis()->info("Shred-Task: Checksum zero: " + to_string(drive->u32DriveChecksumAfterShredding) + " - Drive: " + drive->getSerial()); Logger::logThis()->info("Shred-Task: Checksum zero: " + to_string(drive->u32DriveChecksumAferShredding) + " - Drive: " + drive->getSerial());
} }
#endif #endif
#endif #endif
@ -201,12 +182,12 @@ int Shred::shredDrive(Drive *drive, int *ipSignalFd)
cleanup(); cleanup();
if ((drive->state == Drive::SHRED_ACTIVE) || (drive->state == Drive::CHECK_ACTIVE)) if(drive->state == Drive::SHRED_ACTIVE)
{ {
drive->bWasShredded = true;
drive->state= Drive::NONE; drive->state= Drive::NONE;
drive->setTaskPercentage(0.0); drive->setTaskPercentage(0.0);
Printer::getPrinter()->print(drive); Logger::logThis()->info("Finished shred for: " + drive->getModelName() + "-" + drive->getSerial());
Logger::logThis()->info("Finished shred/check for: " + drive->getModelName() + "-" + drive->getSerial());
} }
return 0; return 0;
} }
@ -220,7 +201,7 @@ double Shred::calcProgress()
{ {
unsigned int uiMaxShredIteration = SHRED_ITERATIONS; unsigned int uiMaxShredIteration = SHRED_ITERATIONS;
#ifdef ZERO_CHECK #ifdef ZERO_CHECK_ALERT
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
return (double) (((double) ulDriveByteOverallCount) / ((double)this->ulDriveByteSize*uiMaxShredIteration))*100.0f; return (double) (((double) ulDriveByteOverallCount) / ((double)this->ulDriveByteSize*uiMaxShredIteration))*100.0f;
@ -269,31 +250,24 @@ unsigned int Shred::uiCalcChecksum(fileDescriptor file, Drive *drive, int *ipSig
{ {
iBytesToCheck = CHUNK_SIZE; iBytesToCheck = CHUNK_SIZE;
} }
int iReadBytes = read(file, caReadBuffer, iBytesToCheck); int iReadBytes = read(file, caChunk, iBytesToCheck);
for (int iReadBytesCounter = 0U; iReadBytesCounter < iReadBytes; iReadBytesCounter++) for (int iReadBytesCounter = 0U; iReadBytesCounter < iReadBytes; iReadBytesCounter++)
{ {
uiChecksum += caReadBuffer[iReadBytesCounter]; uiChecksum += caChunk[0][iReadBytesCounter];
} }
ulDriveByteCounter += iReadBytes; ulDriveByteCounter += iReadBytes;
ulDriveByteOverallCount += iReadBytes; ulDriveByteOverallCount += iReadBytes;
d32Percent = this->calcProgress(); d32Percent = this->calcProgress();
drive->sShredSpeed.ulSpeedMetricBytesWritten += iReadBytes;
#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());
#endif #endif
if((d32Percent-d32TmpPercent) >= 0.9)
if (((d32Percent - d32TmpPercent) >= 0.01) || (d32Percent == 100.0))
{ {
drive->setTaskPercentage(d32TmpPercent); drive->setTaskPercentage(d32TmpPercent);
d32TmpPercent = d32Percent; d32TmpPercent = d32Percent;
#ifdef LOG_LEVEL_HIGH
Logger::logThis()->info("send progress signal to main loop (check)");
#endif
write(*ipSignalFd, "A",1); write(*ipSignalFd, "A",1);
} }
} }
drive->bWasChecked = true;
return uiChecksum; return uiChecksum;
} }

207
src/smart.cpp
View File

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

230
src/tui.cpp
View File

@ -41,23 +41,12 @@ void TUI::initTUI()
init_pair(COLOR_AREA_STDSCR,COLOR_WHITE, COLOR_BLUE); init_pair(COLOR_AREA_STDSCR,COLOR_WHITE, COLOR_BLUE);
wbkgd(stdscr, COLOR_PAIR(COLOR_AREA_STDSCR)); wbkgd(stdscr, COLOR_PAIR(COLOR_AREA_STDSCR));
init_pair(COLOR_AREA_ENTRY_EVEN, COLOR_BLACK, COLOR_WHITE); init_pair(COLOR_AREA_ENTRY, COLOR_BLACK, COLOR_WHITE);
init_pair(COLOR_AREA_ENTRY_ODD, COLOR_BLUE, COLOR_WHITE); init_pair(COLOR_AREA_ENTRY_SELECTED, COLOR_BLACK, COLOR_RED);
#ifdef DRYRUN
init_pair(COLOR_AREA_ENTRY_SELECTED, COLOR_WHITE, COLOR_GREEN);
#else
init_pair(COLOR_AREA_ENTRY_SELECTED, COLOR_WHITE, COLOR_RED);
#endif
init_pair(COLOR_AREA_OVERVIEW, COLOR_BLACK, COLOR_WHITE); init_pair(COLOR_AREA_OVERVIEW, COLOR_BLACK, COLOR_WHITE);
init_pair(COLOR_AREA_DETAIL, COLOR_BLACK, COLOR_WHITE); init_pair(COLOR_AREA_DETAIL, COLOR_BLACK, COLOR_WHITE);
#ifdef DRYRUN
mvprintw(0, 2, "reHDD - HDD refurbishing tool - GPL 3.0 DRYRUN is active! Don't use in production!");
#else
mvprintw(0, 2, "reHDD - HDD refurbishing tool - GPL 3.0 "); mvprintw(0, 2, "reHDD - HDD refurbishing tool - GPL 3.0 ");
#endif
Logger::logThis()->info("UI successfully initialized"); Logger::logThis()->info("UI successfully initialized");
} }
@ -72,12 +61,10 @@ void TUI::updateTUI(list<Drive> *plistDrives, uint8_t u8SelectedEntry)
refresh(); refresh();
// overview window is 3/7 of the x-size overview=createOverViewWindow((int)(u16StdscrX/3), (u16StdscrY-3));
overview = createOverViewWindow((int)(u16StdscrX * (float)(3.0 / 7.0)), (u16StdscrY - 1));
wrefresh(overview); wrefresh(overview);
// system stat window is 2/7 of the x-size systemview=createSystemStats((int)(u16StdscrX/3), 10, u16StdscrX-(int)(u16StdscrX/3)-2, (u16StdscrY-11 ));
systemview = createSystemStats(((int)(u16StdscrX * (float)(2.0 / 7.0))) - 6, 12, (int)(u16StdscrX * (float)(5.0 / 7.0) + 4), (u16StdscrY - 13));
wrefresh(systemview); wrefresh(systemview);
delwin(detailview); delwin(detailview);
@ -87,15 +74,11 @@ void TUI::updateTUI(list<Drive> *plistDrives, uint8_t u8SelectedEntry)
for (it = plistDrives->begin(); it != plistDrives->end(); ++it) for (it = plistDrives->begin(); it != plistDrives->end(); ++it)
{ {
string sModelFamily = it->getModelFamily(); string sModelFamily = it->getModelFamily();
string sSerial = "SN: " + it->getSerial(); string sModelName = it->getModelName();
string sCapacity = it->sCapacityToText(); string sCapacity = it->sCapacityToText();
string sState = " "; string sState = " ";
string sSpeed = " ";
string sTime = " "; string sTime = " ";
string sTemp = it->sTemperatureToText();
string sConnection = (it->connectionType == Drive::USB ? "USB" : it->connectionType == Drive::SATA ? "SATA"
: it->connectionType == Drive::NVME ? "NVME"
: "");
bool bSelectedEntry = false; bool bSelectedEntry = false;
@ -104,16 +87,17 @@ void TUI::updateTUI(list<Drive> *plistDrives, uint8_t u8SelectedEntry)
bSelectedEntry = true; //mark this drive in entries list bSelectedEntry = true; //mark this drive in entries list
displaySelectedDrive(*it, u16StdscrX, u16StdscrY); displaySelectedDrive(*it, u16StdscrX, u16StdscrY);
if ((it->getPowerOnHours() >= WORSE_HOURS) || (it->getPowerCycles() >= WORSE_POWERUP) || (it->getErrorCount() > 0) || (it->getTemperature() >= WORSE_TEMPERATURE)) if((it->getPowerOnHours() >= WORSE_HOURS) || (it->getPowerCycles() >= WORSE_POWERUP) || (it->getErrorCount() > 0))
{ {
// smart values are bad --> show warning // smart values are bad --> show warning
smartWarning = createSmartWarning(50, 10, ((u16StdscrX) - (int)(u16StdscrX / 2) + 35), (int)(u16StdscrY / 2) - 5, it->getPath(), it->getPowerOnHours(), it->getPowerCycles(), it->getErrorCount(), it->getTemperature()); smartWarning=createSmartWarning(50, 10, ((u16StdscrX)-(int)(u16StdscrX/2)+35),(int)(u16StdscrY/2)-5, it->getPath(), it->getPowerOnHours(), it->getPowerCycles(), it->getErrorCount());
wrefresh(smartWarning); wrefresh(smartWarning);
} }
} }
stringstream stream; stringstream stream;
switch (it->state) switch (it->state)
{ {
case Drive::SHRED_ACTIVE: case Drive::SHRED_ACTIVE:
@ -123,46 +107,30 @@ void TUI::updateTUI(list<Drive> *plistDrives, uint8_t u8SelectedEntry)
it->calculateTaskDuration(); it->calculateTaskDuration();
sTime = this->formatTimeDuration(it->getTaskDuration()); sTime = this->formatTimeDuration(it->getTaskDuration());
sSpeed = this->formatSpeed(it->sShredSpeed.u32ShredTimeDelta, it->sShredSpeed.ulWrittenBytes);
break;
case Drive::CHECK_ACTIVE:
stream << fixed << setprecision(3) << (it->getTaskPercentage());
sState = "Checking: " + stream.str() + "%";
it->calculateTaskDuration();
sTime = this->formatTimeDuration(it->getTaskDuration());
sSpeed = this->formatSpeed(it->sShredSpeed.u32ShredTimeDelta, it->sShredSpeed.ulWrittenBytes);
break; break;
case Drive::DELETE_ACTIVE: case Drive::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::NONE:
case Drive::SHRED_SELECTED: case Drive::SHRED_SELECTED:
case Drive::DELETE_SELECTED: case Drive::DELETE_SELECTED:
if (it->bWasDeleted) if (it->bWasDeleteted)
{ {
sState = "DELETED"; //mark drive as deleted previously sState = "DELETED"; //mark drive as deleted previously
} }
if (it->bWasShredded) if (it->bWasShredded)
{ {
if (it->bWasChecked) sState = "SHREDDED"; //mark drive as shreded previously, overwrite if deleted
{
// drive was also checked after shredding
sState = "SHREDDED & CHECKED"; // mark drive as shredded previously and optional checked
}
else
{
// shredded and not checked yet
sState = "SHREDDED"; // mark drive as shredded previously
}
sTime = this->formatTimeDuration(it->getTaskDuration()); sTime = this->formatTimeDuration(it->getTaskDuration());
} }
#ifdef ZERO_CHECK #ifdef ZERO_CHECK_ALERT
if (bSelectedEntry && it->bWasChecked && (it->u32DriveChecksumAfterShredding != 0U)) if(bSelectedEntry && it->bWasShredded && (it->u32DriveChecksumAferShredding != 0U))
{ {
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->u32DriveChecksumAferShredding);
wrefresh(dialog); wrefresh(dialog);
} }
#endif #endif
@ -183,9 +151,7 @@ void TUI::updateTUI(list<Drive> *plistDrives, uint8_t u8SelectedEntry)
break; break;
} }
uint16_t u16StartOffsetY = (2 * (u8Index)); WINDOW * tmp = createEntryWindow( ((int)(u16StdscrX/3) - 2), 5, 3, (5* (u8Index) )+3, sModelFamily, sModelName, sCapacity, sState, sTime, bSelectedEntry);
WINDOW *tmp = createEntryWindow((int)(u16StdscrX * (float)(3.0 / 7.0) - 2), 2, 3, u16StartOffsetY + 2, (distance(plistDrives->begin(), it) + 1), sModelFamily, sSerial, sCapacity, sState, sTime, sSpeed, sTemp, sConnection, bSelectedEntry);
wrefresh(tmp); wrefresh(tmp);
u8Index++; u8Index++;
}//end loop though drives }//end loop though drives
@ -201,11 +167,11 @@ void TUI::updateTUI(list<Drive> *plistDrives, uint8_t u8SelectedEntry)
menustate.bDelete = false; menustate.bDelete = false;
menustate.bShred = false; menustate.bShred = false;
detailview = overwriteDetailViewWindow((u16StdscrX) - ((int)(u16StdscrX * (float)(3.0 / 7.0))) - 7, (u16StdscrY - 15), (int)(u16StdscrX * (float)(3.0 / 7.0) + 5)); menuview=createMenuView(((int)(u16StdscrX/3)-10 ), 10, (int)(u16StdscrX/3)+5,(u16StdscrY-11), menustate);
wrefresh(detailview);
menuview = createMenuView(((int)(u16StdscrX * (float)(2.0 / 7.0))) - 3, 12, (int)(u16StdscrX * (float)(3.0 / 7.0) + 5), (u16StdscrY - 13), menustate);
wrefresh(menuview); wrefresh(menuview);
detailview=overwriteDetailViewWindow(((u16StdscrX)-(int)(u16StdscrX/3)-7), (u16StdscrY-15), (int)(u16StdscrX/3)+5);
wrefresh(detailview);
} }
mxUIrefresh.unlock(); mxUIrefresh.unlock();
@ -237,12 +203,6 @@ enum TUI::UserInput TUI::readUserInput()
case 's': case 's':
return TUI::UserInput::Shred; return TUI::UserInput::Shred;
break; break;
case 'S':
return TUI::UserInput::ShredAll;
break;
case 'T':
return TUI::UserInput::Terminate;
break;
default: default:
return TUI::UserInput::Undefined; return TUI::UserInput::Undefined;
break; break;
@ -263,13 +223,10 @@ void TUI::centerTitle(WINDOW *pwin, const char *title)
waddch(pwin, ACS_LTEE); waddch(pwin, ACS_LTEE);
} }
/*
left window that contains the drive entries
*/
WINDOW* TUI::createOverViewWindow( int iXSize, int iYSize) WINDOW* TUI::createOverViewWindow( int iXSize, int iYSize)
{ {
WINDOW *newWindow; WINDOW *newWindow;
newWindow = newwin(iYSize, iXSize, 1, 2); newWindow = newwin(iYSize, iXSize, 2, 2);
wbkgd(newWindow, COLOR_PAIR(COLOR_AREA_OVERVIEW)); wbkgd(newWindow, COLOR_PAIR(COLOR_AREA_OVERVIEW));
box(newWindow, ACS_VLINE, ACS_HLINE); box(newWindow, ACS_VLINE, ACS_HLINE);
@ -282,7 +239,7 @@ WINDOW *TUI::createOverViewWindow(int iXSize, int iYSize)
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, 2, iXStart);
wbkgd(newWindow, COLOR_PAIR(COLOR_AREA_DETAIL)); wbkgd(newWindow, COLOR_PAIR(COLOR_AREA_DETAIL));
box(newWindow, ACS_VLINE, ACS_HLINE); box(newWindow, ACS_VLINE, ACS_HLINE);
@ -290,7 +247,7 @@ WINDOW *TUI::createDetailViewWindow(int iXSize, int iYSize, int iXStart, Drive d
centerTitle(newWindow, title.c_str()); centerTitle(newWindow, title.c_str());
string sPath = "Path: " +drive.getPath(); string sPath = "Path: " +drive.getPath();
string sModelFamily = "ModelFamily: " + drive.getModelFamily(); string sModelFamlily = "ModelFamily: " + drive.getModelFamily();
string sModelName = "ModelName: " + drive.getModelName(); string sModelName = "ModelName: " + drive.getModelName();
string sCapacity = "Capacity: " + drive.sCapacityToText(); string sCapacity = "Capacity: " + drive.sCapacityToText();
string sSerial = "Serial: " + drive.getSerial(); string sSerial = "Serial: " + drive.getSerial();
@ -301,7 +258,7 @@ WINDOW *TUI::createDetailViewWindow(int iXSize, int iYSize, int iXStart, Drive d
uint16_t u16Line = 2; uint16_t u16Line = 2;
mvwaddstr(newWindow,u16Line++, 3, sPath.c_str()); mvwaddstr(newWindow,u16Line++, 3, sPath.c_str());
mvwaddstr(newWindow, u16Line++, 3, sModelFamily.c_str()); mvwaddstr(newWindow,u16Line++, 3, sModelFamlily.c_str());
mvwaddstr(newWindow,u16Line++, 3, sModelName.c_str()); mvwaddstr(newWindow,u16Line++, 3, sModelName.c_str());
mvwaddstr(newWindow,u16Line++, 3, sCapacity.c_str()); mvwaddstr(newWindow,u16Line++, 3, sCapacity.c_str());
mvwaddstr(newWindow,u16Line++, 3, sSerial.c_str()); mvwaddstr(newWindow,u16Line++, 3, sSerial.c_str());
@ -318,7 +275,7 @@ WINDOW *TUI::createDetailViewWindow(int iXSize, int iYSize, int iXStart, Drive d
WINDOW* TUI::overwriteDetailViewWindow( int iXSize, int iYSize, int iXStart) WINDOW* TUI::overwriteDetailViewWindow( int iXSize, int iYSize, int iXStart)
{ {
WINDOW *newWindow; WINDOW *newWindow;
newWindow = newwin(iYSize, iXSize, 1, iXStart); newWindow = newwin(iYSize, iXSize, 2, iXStart);
wbkgd(newWindow, COLOR_PAIR(COLOR_AREA_DETAIL)); wbkgd(newWindow, COLOR_PAIR(COLOR_AREA_DETAIL));
box(newWindow, ACS_VLINE, ACS_HLINE); box(newWindow, ACS_VLINE, ACS_HLINE);
@ -330,7 +287,7 @@ WINDOW *TUI::overwriteDetailViewWindow(int iXSize, int iYSize, int iXStart)
string sLine03 = "Available under GPL 3.0"; string sLine03 = "Available under GPL 3.0";
string sLine04 = "https://git.mosad.xyz/localhorst/reHDD"; string sLine04 = "https://git.mosad.xyz/localhorst/reHDD";
string sLine05 = "Delete: Wipe format table - this is NOT secure"; string sLine05 = "Delete: Wipe format table - this is NOT secure";
string sLine06 = "Shred: Overwrite drive " + to_string(SHRED_ITERATIONS) + " iterations - this is secure"; string sLine06 = "Shred: Overwite drive " + to_string(SHRED_ITERATIONS) + " iterations - this is secure";
uint16_t u16Line = 5; uint16_t u16Line = 5;
@ -348,7 +305,7 @@ WINDOW *TUI::overwriteDetailViewWindow(int iXSize, int iYSize, int iXStart)
return newWindow; return newWindow;
} }
WINDOW *TUI::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) WINDOW* TUI::createEntryWindow(int iXSize, int iYSize, int iXStart, int iYStart, string sModelFamily, string sModelName, string sCapacity, string sState, string sTime, bool bSelected)
{ {
WINDOW *newWindow; WINDOW *newWindow;
newWindow = newwin(iYSize, iXSize, iYStart, iXStart); newWindow = newwin(iYSize, iXSize, iYStart, iXStart);
@ -356,67 +313,24 @@ WINDOW *TUI::createEntryWindow(int iXSize, int iYSize, int iXStart, int iYStart,
if(!bSelected) if(!bSelected)
{ {
// entry is NOT selected // entry is NOT selected
if (iListIndex % 2 == 0) attron(COLOR_PAIR(COLOR_AREA_ENTRY));
{ wbkgd(newWindow, COLOR_PAIR(COLOR_AREA_ENTRY));
// even
attron(COLOR_PAIR(COLOR_AREA_ENTRY_EVEN));
wbkgd(newWindow, COLOR_PAIR(COLOR_AREA_ENTRY_EVEN));
}
else
{
// odd
attron(COLOR_PAIR(COLOR_AREA_ENTRY_ODD));
wbkgd(newWindow, COLOR_PAIR(COLOR_AREA_ENTRY_ODD));
}
} }
else else
{ {
// entry IS selected // entry IS selected
attron(COLOR_PAIR(COLOR_AREA_ENTRY_SELECTED)); attron(COLOR_PAIR(COLOR_AREA_ENTRY));
wbkgd(newWindow, COLOR_PAIR(COLOR_AREA_ENTRY_SELECTED)); wbkgd(newWindow, COLOR_PAIR(COLOR_AREA_ENTRY_SELECTED));
} }
// box(newWindow, ACS_VLINE, ACS_HLINE); box(newWindow, ACS_VLINE, ACS_HLINE);
// index number mvwaddstr(newWindow,1, 1, sModelFamily.c_str());
mvwaddstr(newWindow, 0, 1, to_string(iListIndex).c_str()); mvwaddstr(newWindow,2, 1, sModelName.c_str());
mvwaddstr(newWindow,3, 1, sCapacity.c_str());
/* mvwaddstr(newWindow,2, iXSize-sState.length()-5, sState.c_str());
70 chars in x-axis mvwaddstr(newWindow,3, iXSize-sState.length()-5, sTime.c_str());
line:01
0: space
1: index number
2: space
3-35: ModelFamily
36: space
37-43: Capacity
44: space
47-49: Temp
57-60: Connection Type
line:02
0-2: space
3-31: Serial
32: space
33-45: Speed
46: space
47-58: Time
59: space
60-70: State (but right side aligned)
*/
vTruncateText(&sModelFamily, 32);
mvwaddstr(newWindow, 0, 3, sModelFamily.c_str());
mvwaddstr(newWindow, 0, 37, sCapacity.c_str());
mvwaddstr(newWindow, 0, 47, sTemp.c_str());
mvwaddstr(newWindow, 0, 57, sConnection.c_str());
vTruncateText(&sSerial, 28);
mvwaddstr(newWindow, 1, 3, sSerial.c_str());
mvwaddstr(newWindow, 1, 33, sSpeed.c_str());
mvwaddstr(newWindow, 1, 47, sTime.c_str());
mvwaddstr(newWindow, 1, iXSize - sState.length() - 2, sState.c_str());
return newWindow; return newWindow;
} }
@ -441,21 +355,15 @@ WINDOW *TUI::createSystemStats(int iXSize, int iYSize, int iXStart, int iYStart)
string sLine01 = "reHDD - hard drive refurbishing tool"; string sLine01 = "reHDD - hard drive refurbishing tool";
string sLine02 = "Version: " + string(REHDD_VERSION); string sLine02 = "Version: " + string(REHDD_VERSION);
string sLine03 = "Build time: "; string sLine03 = "Available under GPL 3.0";
sLine03.append(__DATE__); string sLine04 = "https://git.mosad.xyz/localhorst/reHDD";
sLine03.append(" ");
sLine03.append(__TIME__);
string sLine04 = "Available under GPL 3.0";
string sLine05 = "https://git.mosad.xyz/localhorst/reHDD";
uint16_t u16Line = 2; uint16_t u16Line = 2;
mvwaddstr(newWindow,u16Line++, (iXSize/2)-(sLine01.size()/2), sLine01.c_str()); mvwaddstr(newWindow,u16Line++, (iXSize/2)-(sLine01.size()/2), sLine01.c_str());
u16Line++;
mvwaddstr(newWindow,u16Line++, (iXSize/2)-(sLine01.size()/2), sLine02.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), sLine03.c_str());
mvwaddstr(newWindow,u16Line++, (iXSize/2)-(sLine01.size()/2), sLine04.c_str()); mvwaddstr(newWindow,u16Line++, (iXSize/2)-(sLine01.size()/2), sLine04.c_str());
mvwaddstr(newWindow, u16Line++, (iXSize / 2) - (sLine01.size() / 2), sLine05.c_str());
u16Line++; u16Line++;
mvwaddstr(newWindow,u16Line++, (iXSize/2)-(sLine01.size()/2), time.c_str()); mvwaddstr(newWindow,u16Line++, (iXSize/2)-(sLine01.size()/2), time.c_str());
@ -472,30 +380,26 @@ WINDOW *TUI::createMenuView(int iXSize, int iYSize, int iXStart, int iYStart, st
centerTitle(newWindow, "Controls"); centerTitle(newWindow, "Controls");
uint16_t u16Line = 4; uint16_t u16Line = 2;
if(menustate.bAbort) if(menustate.bAbort)
{ {
string sLineTmp = "Press a for Abort"; string sLineTmp = "Press A for Abort";
mvwaddstr(newWindow,u16Line++, (iXSize/2)-(sLineTmp.size()/2), sLineTmp.c_str()); mvwaddstr(newWindow,u16Line++, (iXSize/2)-(sLineTmp.size()/2), sLineTmp.c_str());
u16Line++; u16Line++;
} }
if(menustate.bShred) if(menustate.bShred)
{ {
string sLineTmp = "Press s for Shred (S for all drives)"; string sLineTmp = "Press S for Shred ";
mvwaddstr(newWindow,u16Line++, (iXSize/2)-(sLineTmp.size()/2), sLineTmp.c_str()); mvwaddstr(newWindow,u16Line++, (iXSize/2)-(sLineTmp.size()/2), sLineTmp.c_str());
u16Line++; u16Line++;
} }
if(menustate.bDelete) if(menustate.bDelete)
{ {
string sLineTmp = "Press d for Delete"; string sLineTmp = "Press D for Delete";
mvwaddstr(newWindow,u16Line++, (iXSize/2)-(sLineTmp.size()/2), sLineTmp.c_str()); mvwaddstr(newWindow,u16Line++, (iXSize/2)-(sLineTmp.size()/2), sLineTmp.c_str());
u16Line++;
} }
string sLineTmp = "Press T for terminating reHDD";
mvwaddstr(newWindow, u16Line++, (iXSize / 2) - (sLineTmp.size() / 2), sLineTmp.c_str());
return newWindow; return newWindow;
} }
@ -565,7 +469,7 @@ WINDOW *TUI::createZeroChecksumWarning(int iXSize, int iYSize, int iXStart, int
string sLine01 = "Please detach this drive and check it manually:"; string sLine01 = "Please detach this drive and check it manually:";
string sShredChecksum = "After shredding the checksum was: " + to_string(u32Checksum); string sShredChecksum = "After shredding the checksum was: " + to_string(u32Checksum);
string sLinePath = "Path: " +sPath; string sLinePath = "Path: " +sPath;
string sLineModelFamily = "ModelFamily: " + sModelFamily; string sLineModelFamlily = "ModelFamily: " + sModelFamily;
string sLineModelName = "ModelName: " + sModelName; string sLineModelName = "ModelName: " + sModelName;
string sLineSerial = "Serial: " + sSerial; string sLineSerial = "Serial: " + sSerial;
@ -578,7 +482,7 @@ WINDOW *TUI::createZeroChecksumWarning(int iXSize, int iYSize, int iXStart, int
mvwaddstr(newWindow,u16Line++, 3, sLine01.c_str()); mvwaddstr(newWindow,u16Line++, 3, sLine01.c_str());
u16Line++; u16Line++;
mvwaddstr(newWindow,u16Line++, 3, sLinePath.c_str()); mvwaddstr(newWindow,u16Line++, 3, sLinePath.c_str());
mvwaddstr(newWindow, u16Line++, 3, sLineModelFamily.c_str()); mvwaddstr(newWindow,u16Line++, 3, sLineModelFamlily.c_str());
mvwaddstr(newWindow,u16Line++, 3, sLineModelName.c_str()); mvwaddstr(newWindow,u16Line++, 3, sLineModelName.c_str());
mvwaddstr(newWindow,u16Line++, 3, sLineSerial.c_str()); mvwaddstr(newWindow,u16Line++, 3, sLineSerial.c_str());
u16Line++; u16Line++;
@ -602,30 +506,9 @@ string TUI::formatTimeDuration(time_t u32Duration)
return out.str(); return out.str();
} }
string TUI::formatSpeed(time_t u32ShredTimeDelta, unsigned long ulWrittenBytes)
{
std::ostringstream out;
double dDeltaSec = ((double)((u32ShredTimeDelta) / 1000000000.0)); // convert nano in sec
double speed = ((ulWrittenBytes / 1000000.0) / dDeltaSec);
char s[25];
sprintf(s, "%0.2lf MB/s", speed);
out << s;
return out.str();
}
void TUI::vTruncateText(string *psText, uint16_t u16MaxLenght)
{
if (psText->length() > u16MaxLenght)
{
psText->resize(u16MaxLenght - 3);
*psText = *psText + "...";
}
}
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;
menustate.bAbort = false; menustate.bAbort = false;
menustate.bConfirmDelete = false; menustate.bConfirmDelete = false;
menustate.bConfirmShred = false; menustate.bConfirmShred = false;
@ -647,10 +530,6 @@ void TUI::displaySelectedDrive(Drive drive, int stdscrX, int stdscrY)
menustate.bAbort = true; menustate.bAbort = true;
break; break;
case Drive::CHECK_ACTIVE: // check task running for this drive
menustate.bAbort = true;
break;
case Drive::DELETE_SELECTED : //delete task selected for this drive case Drive::DELETE_SELECTED : //delete task selected for this drive
menustate.bConfirmDelete = true; menustate.bConfirmDelete = true;
break; break;
@ -662,35 +541,29 @@ void TUI::displaySelectedDrive(Drive drive, int stdscrX, int stdscrY)
break; break;
} }
detailview = createDetailViewWindow((stdscrX) - ((int)(stdscrX * (float)(3.0 / 7.0))) - 7, (stdscrY - 15), (int)(stdscrX * (float)(3.0 / 7.0) + 5), drive); detailview=createDetailViewWindow(((stdscrX)-(int)(stdscrX/3)-7), (stdscrY-15), (int)(stdscrX/3)+5, drive);
wrefresh(detailview); wrefresh(detailview);
menuview = createMenuView(((int)(stdscrX * (float)(2.0 / 7.0))) - 3, 12, (int)(stdscrX * (float)(3.0 / 7.0) + 5), (stdscrY - 13), menustate); menuview=createMenuView(((int)(stdscrX/3)-10 ), 10, (int)(stdscrX/3)+5,(stdscrY-11), menustate);
wrefresh(menuview); wrefresh(menuview);
if(menustate.bConfirmShred == true) if(menustate.bConfirmShred == true)
{ {
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"); 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); wrefresh(dialog);
dialogIsActive = true;
} }
else if(menustate.bConfirmDelete == true) else if(menustate.bConfirmDelete == true)
{ {
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"); 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); wrefresh(dialog);
dialogIsActive = true;
} }
else else
{
if (dialogIsActive)
{ {
delwin(dialog); delwin(dialog);
dialogIsActive = false;
}
} }
} }
WINDOW *TUI::createSmartWarning(int iXSize, int iYSize, int iXStart, int iYStart, string sPath, uint32_t u32PowerOnHours, uint32_t u32PowerCycles, uint32_t u32ErrorCount, uint32_t u32Temperature) WINDOW* TUI::createSmartWarning(int iXSize, int iYSize, int iXStart, int iYStart, string sPath, uint32_t u32PowerOnHours, uint32_t u32PowerCycles, uint32_t u32ErrorCount)
{ {
WINDOW *newWindow; WINDOW *newWindow;
newWindow = newwin(iYSize, iXSize, iYStart, iXStart); newWindow = newwin(iYSize, iXSize, iYStart, iXStart);
@ -723,14 +596,7 @@ WINDOW *TUI::createSmartWarning(int iXSize, int iYSize, int iXStart, int iYStart
if(u32ErrorCount > 0) if(u32ErrorCount > 0)
{ {
string sLineTmp = "S.M.A.R.T. errors detected: " + to_string(u32ErrorCount); string sLineTmp = "S.M.A.R.T. erros detected: " + to_string(u32ErrorCount);
mvwaddstr(newWindow, u16Line++, (iXSize / 2) - (sLine01.size() / 2), sLineTmp.c_str());
u16Line++;
}
if (u32Temperature >= WORSE_TEMPERATURE)
{
string sLineTmp = "Drive too hot: " + to_string(u32Temperature) + " C";
mvwaddstr(newWindow,u16Line++, (iXSize/2)-(sLine01.size()/2), sLineTmp.c_str()); mvwaddstr(newWindow,u16Line++, (iXSize/2)-(sLine01.size()/2), sLineTmp.c_str());
} }
return newWindow; return newWindow;

1
tfnoisegen

@ -1 +0,0 @@
Subproject commit 488716ef22ac5a1aae235a59bea2997ac7e8e45a