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.0
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.0" have entirely different histories.
master ... b0.2.0

44 changed files with 1751 additions and 2274 deletions
Show Stats Expand all files Collapse all files

8
.gitignore vendored
View File

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

3
.gitmodules vendored
View File

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

99
README.md
View File

@ -1,68 +1,79 @@
# 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/95828afcc2e417b9cb64a4add98ae9c3c7628e84/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` * clone repo
* `git submodule update` * make release
* `make release`
## Enable Label Printer ## ## Create Standalone with Debian
Just install [reHDDPrinter](https://git.mosad.xyz/localhorst/reHDDPrinter).
No further settings needed.
## 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.
* Start reHDD after boot without login (as a tty1 shell)
* Start dmesg after boot without login (as a tty2 shell)
* Start htop after boot without login (as a tty3 shell)
* Upload reHDD log every 12h if wanted
### Software requirements ### Software requirements
* `apt-get install hwinfo smartmontools curl htop sudo`
### Installation * apt-get install hwinfo
* wget http://ftp.de.debian.org/debian/pool/main/s/smartmontools/smartmontools_7.1-1_amd64.deb
* dpkg --install smartmontools_7.1-1_amd64.deb
clone this repo into /root/ ### Start reHDD after boot without login (as a tty shell)
nano /etc/systemd/system/reHDD.service
``` ```
git submodule init [Unit]
git submodule update Description=Custom user interface on tty1
Conflicts=getty@tty1.service
Before=getty.target
[Service]
WorkingDirectory=/root/reHDD
ExecStart=/root/reHDD/reHDD
StandardInput=tty
StandardOutput=tty
Restart=always
RestartSec=1
UtmpIdentifier=tty1
TTYPath=/dev/tty1
TTYReset=yes
TTYVHangup=yes
TTYVTDisallocate=yes
SendSIGHUP=yes
[Install]
WantedBy=multi-user.target
``` ```
`cd /root/reHDD/` nano /etc/systemd/system/reHDDSettings.service
```
[Service]
Type=oneshot
RemainAfterExit=yes
ExecStart=/usr/bin/bash /root/reHDDSettings.sh
`make release` [Install]
WantedBy=multi-user.target
```
`bash scripts/install_reHDD.bash` nano /root/reHDDSettings.sh
```
#!/bin/bash
dmesg -n 1 #disable overlay if a drive is attached/detached
rm -f /root/reHDD/reHDD.log
```
Make sure the binary reHDD is in /root/reHDD/
Add your system drive in /root/reHDD/ignoreDrives.conf like:
``` /dev/sdX:e102f49d-5ed5-462b-94c5-ef66a4345671```
Get your UUID via blkid /dev/sdX
If you want to upload the logs, edit `scripts/reHDDLogUploader.bash` with your nextcloud token systemctl enable reHDD.service
Add your system drive in `/root/reHDD/ignoreDrives.conf` like: systemctl enable reHDDSettings.service
```e102f49d```
Get the first 8 Bytes from your UUID via `blkid /dev/sdX`
`reboot`
## Build docs
`make docs`
open `doc/html/index.html` in browser

24
astyle.sh Normal file
View File

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

16
doc/doxyfile
View File

@ -467,7 +467,7 @@ LOOKUP_CACHE_SIZE = 0
# normally produced when WARNINGS is set to YES. # normally produced when WARNINGS is set to YES.
# The default value is: NO. # The default value is: NO.
EXTRACT_ALL = YES EXTRACT_ALL = NO
# If the EXTRACT_PRIVATE tag is set to YES, all private members of a class will # If the EXTRACT_PRIVATE tag is set to YES, all private members of a class will
# be included in the documentation. # be included in the documentation.
@ -904,7 +904,7 @@ FILE_PATTERNS = *.c \
# be searched for input files as well. # be searched for input files as well.
# The default value is: NO. # The default value is: NO.
RECURSIVE = YES RECURSIVE = NO
# The EXCLUDE tag can be used to specify files and/or directories that should be # The EXCLUDE tag can be used to specify files and/or directories that should be
# excluded from the INPUT source files. This way you can easily exclude a # excluded from the INPUT source files. This way you can easily exclude a
@ -1493,7 +1493,7 @@ ECLIPSE_DOC_ID = org.doxygen.Project
# The default value is: NO. # The default value is: NO.
# This tag requires that the tag GENERATE_HTML is set to YES. # This tag requires that the tag GENERATE_HTML is set to YES.
DISABLE_INDEX = YES DISABLE_INDEX = NO
# The GENERATE_TREEVIEW tag is used to specify whether a tree-like index # The GENERATE_TREEVIEW tag is used to specify whether a tree-like index
# structure should be generated to display hierarchical information. If the tag # structure should be generated to display hierarchical information. If the tag
@ -1510,7 +1510,7 @@ DISABLE_INDEX = YES
# The default value is: NO. # The default value is: NO.
# This tag requires that the tag GENERATE_HTML is set to YES. # This tag requires that the tag GENERATE_HTML is set to YES.
GENERATE_TREEVIEW = YES GENERATE_TREEVIEW = NO
# The ENUM_VALUES_PER_LINE tag can be used to set the number of enum values that # The ENUM_VALUES_PER_LINE tag can be used to set the number of enum values that
# doxygen will group on one line in the generated HTML documentation. # doxygen will group on one line in the generated HTML documentation.
@ -2260,7 +2260,7 @@ HIDE_UNDOC_RELATIONS = YES
# set to NO # set to NO
# The default value is: NO. # The default value is: NO.
HAVE_DOT = YES HAVE_DOT = NO
# The DOT_NUM_THREADS specifies the number of dot invocations doxygen is allowed # The DOT_NUM_THREADS specifies the number of dot invocations doxygen is allowed
# to run in parallel. When set to 0 doxygen will base this on the number of # to run in parallel. When set to 0 doxygen will base this on the number of
@ -2326,7 +2326,7 @@ GROUP_GRAPHS = YES
# The default value is: NO. # The default value is: NO.
# This tag requires that the tag HAVE_DOT is set to YES. # This tag requires that the tag HAVE_DOT is set to YES.
UML_LOOK = YES UML_LOOK = NO
# If the UML_LOOK tag is enabled, the fields and methods are shown inside the # If the UML_LOOK tag is enabled, the fields and methods are shown inside the
# class node. If there are many fields or methods and many nodes the graph may # class node. If there are many fields or methods and many nodes the graph may
@ -2377,7 +2377,7 @@ INCLUDED_BY_GRAPH = YES
# The default value is: NO. # The default value is: NO.
# This tag requires that the tag HAVE_DOT is set to YES. # This tag requires that the tag HAVE_DOT is set to YES.
CALL_GRAPH = YES CALL_GRAPH = NO
# If the CALLER_GRAPH tag is set to YES then doxygen will generate a caller # If the CALLER_GRAPH tag is set to YES then doxygen will generate a caller
# dependency graph for every global function or class method. # dependency graph for every global function or class method.
@ -2389,7 +2389,7 @@ CALL_GRAPH = YES
# The default value is: NO. # The default value is: NO.
# This tag requires that the tag HAVE_DOT is set to YES. # This tag requires that the tag HAVE_DOT is set to YES.
CALLER_GRAPH = YES CALLER_GRAPH = NO
# If the GRAPHICAL_HIERARCHY tag is set to YES then doxygen will graphical # If the GRAPHICAL_HIERARCHY tag is set to YES then doxygen will graphical
# hierarchy of all classes instead of a textual one. # hierarchy of all classes instead of a textual one.

60
doc/prototype_manual_DE.md Normal file
View File

@ -0,0 +1,60 @@
# Installation
**[1]** In terminal als root einloggen\
**[2]** In reHDD_prototype wechseln\
**[3]** Abhängigkeiten installieren\
`apt-get install smartmontools`\
`apt-get install hwinfo`\
`apt-get install util-linux`
**[4]** reHDD ausführbar machen\
`chmod +x reHDD`\
**[5]** ignoreDrives.conf bearbeiten
##### Ein Eintrag in der ignoreDrives-Datei sorgt dafür das die Software bestimmte Festplatten ignoriert. Dies ist wichtig damit nicht unbeabsichtigt die Systemfestplatte oder weitere Festplatten bearbeitet (gelöscht) werden.
Beispiel Inhalt:
```
/dev/sda:508eff7d-f039-4efb-9e2c-22dffdfdfdfd
/dev/sdb:07dfffff-c4b6-46e7-9cdf-3cfdfdffd53d
/dev/sdc:dfff974d-1af2-4dfd-9dfd-a2d8e4c43dff
```
Ein Eintrag setzt sich aus zwei Teilen zusammen:
**[Pfad]:[PARTUUID]**
Der Pfad kann mittels `fdisk -l` ermittelt werden.\
Die PARTUUID kann mittels `blkid /dev/sda` ermittelt werden, wobei `/dev/sda` derzuvor ermittelte Pfad ist.
# Benutzung
reHDD starten mit `./reHDD` (Wichtig ist das reHDD mit root-Rechen ausgeführt wird, entwender als root einloggen oder mit `sudo`)
reHDD sucht automatisch nach allen verfügbaren Festplatten und filtert die zu ignorierenden heraus.\
Für die verbleibenden Festplatten wird eine Übersicht ausgegeben.
Der Nutzer wird gefragt, welche Festplatte bearbeitet werden soll und gibt die Nummer ein.
Beispiel:
```
hostname@hendrik:/reHDD_prototype # ./reHDD
refurbishingHddTool
created app
app logic
search drives ...
------------DRIVES---------------
Drive: 0
Path: /dev/sdd
ModelFamily:
ModelName: ADATA SU650
Capacity: 120034123776
Serial: H50125K001601
PowerOnHours: 93
PowerCycle: 187
ErrorCount: 0
---------------------------------
Select drive to wipe:
0
Selected drive index: 0
wipe: shred -v /dev/sdd
shred: /dev/sdd: Durchgang 1/3 (random)…
shred: /dev/sdd: Durchgang 1/3 (random)…847MiB/112GiB 0%
...
```

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: 54 KiB

26
doc/update.sh Normal file
View File

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

6
ignoreDrives.conf
View File

@ -1,3 +1,3 @@
4673974d /dev/sdc:4673974d-1af2-44fd-996b-a2d8e4c43d9a
2cb3dea4 /dev/sda:508ef27d-5039-4e8b-9e2c-22d7528b7149
8ffbc421 /dev/sdb:32b66944-ffa0-40e9-817c-3f0c52eefaf4

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_

52
include/drive.h
View File

@ -14,49 +14,20 @@ 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;
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 +35,14 @@ 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)
private: private:
void setTimestamp(); void setTimestamp();
protected: protected:
public: public:
Drive(string path) Drive(string path)
{ {
@ -85,7 +57,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,23 +65,16 @@ 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);
void setActionStartTimestamp();
time_t getActionStartTimestamp();
void calculateTaskDuration();
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_

34
include/reHDD.h
View File

@ -8,32 +8,29 @@
#ifndef REHDD_H_ #ifndef REHDD_H_
#define REHDD_H_ #define REHDD_H_
#define REHDD_VERSION "V1.2.0" #define REHDD_VERSION "bV0.2.0"
// 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 3
#define SHRED_ITERATIONS 3U #define FROZEN_TIMEOUT 10 //After this timeout (minutes) the drive will be marked as frozen
#define FROZEN_TIMEOUT 20 // After this timeout (minutes) the drive will be marked as frozen, if no progress
#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 2020"
#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 scann thread
#ifndef LOG_LEVEL_HIGH #ifndef LOG_LEVEL_HIGH
#define LOG_LEVEL_LOW //log only user actions and tasks #define LOG_LEVEL_LOW //log only user actions and tasks
#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
//IPC pipes //IPC pipes
#define READ 0 #define READ 0
@ -61,16 +58,14 @@ using namespace std;
#include "drive.h" #include "drive.h"
#include "smart.h" #include "smart.h"
#include "shred.h" #include "shred/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 +73,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 +95,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_

55
include/shred.h
View File

@ -1,55 +0,0 @@
/**
* @file shred.h
* @brief shred drive
* @author hendrik schutter
* @date 03.05.2020
*/
#ifndef SHRED_H_
#define SHRED_H_
#include "reHDD.h"
#include <iostream>
#include <fstream>
#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>
#define CHUNK_SIZE 1024 * 1024 * 32 // amount of bytes that are overwritten at once --> 32MB
#define TFNG_DATA_SIZE CHUNK_SIZE // amount of bytes used by tfng
// #define DEMO_DRIVE_SIZE 1024*1024*256L // 256MB
// #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
typedef int fileDescriptor;
class Shred
{
protected:
public:
Shred();
~Shred();
int shredDrive(Drive *drive, int *ipSignalFd);
private:
fileDescriptor randomSrcFileDiscr;
fileDescriptor driveFileDiscr;
unsigned char caTfngData[TFNG_DATA_SIZE];
unsigned char caReadBuffer[CHUNK_SIZE];
unsigned long ulDriveByteSize;
unsigned long ulDriveByteOverallCount = 0; // all bytes shredded in all iterations + checking -> used for progress calculation
double d32Percent = 0.0;
double d32TmpPercent = 0.0;
inline double calcProgress();
int iRewindDrive(fileDescriptor file);
unsigned long getDriveSizeInBytes(fileDescriptor file);
unsigned int uiCalcChecksum(fileDescriptor file, Drive *drive, int *ipSignalFd);
void cleanup();
};
#endif // SHRED_H_

19
include/shred/machdefs.h Normal file
View File

@ -0,0 +1,19 @@
#ifndef _MACHINE_DEFINITIONS_HEADER
#define _MACHINE_DEFINITIONS_HEADER
#include <stdint.h>
#include <limits.h>
#undef MACHINE_16BIT
#undef MACHINE_32BIT
#undef MACHINE_64BIT
#if UINTPTR_MAX == UINT32_MAX
#define MACHINE_32BIT
#elif UINTPTR_MAX == UINT64_MAX
#define MACHINE_64BIT
#elif UINTPTR_MAX == UINT16_MAX
#define MACHINE_16BIT
#endif
#endif

98
include/shred/shred.h Normal file
View File

@ -0,0 +1,98 @@
/**
* @file shred.h
* @brief shred drive
* @author hendrik schutter
* @date 03.05.2020
*/
#ifndef SHRED_H_
#define SHRED_H_
#include "../reHDD.h"
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <string.h>
#include <stdio.h>
#include <errno.h>
#include <limits.h>
#include <libgen.h>
#include "tfdef.h"
#include "tfcore.h"
//#include "tfe.h"
#ifndef _DEFAULT_SOURCE
#define _DEFAULT_SOURCE
#endif
#ifndef _BSD_SOURCE
#define _BSD_SOURCE
#endif
#ifndef _XOPEN_SOURCE
#define _XOPEN_SOURCE 700
#endif
#ifndef _LARGEFILE64_SOURCE
#define _LARGEFILE64_SOURCE
#endif
#ifndef _FILE_OFFSET_BITS
#define _FILE_OFFSET_BITS 64
#endif
#ifndef _TFNG_STREAM_CIPHER_DEFS
#define _TFNG_STREAM_CIPHER_DEFS
#endif
#define PROCESS_BLOCKP(x,k1,k2,k3,k4,k5,k6) \
do { \
KE_MIX(Y, X, k1 + k2, k3, TFS_KS01); \
KE_MIX(T, Z, k4 + x, k5 + k6, TFS_KS02); \
\
BE_MIX(X, T, TFS_BS01); BE_MIX(Z, Y, TFS_BS02); \
BE_MIX(X, Y, TFS_BS03); BE_MIX(Z, T, TFS_BS04); \
BE_MIX(X, T, TFS_BS05); BE_MIX(Z, Y, TFS_BS06); \
} while (0)
#define PROCESS_BLOCKN(x,k1,k2,k3,k4,k5,k6) \
do { \
KE_MIX(Y, X, k1 + k2, k3, TFS_KS03); \
KE_MIX(T, Z, k4 + x, k5 + k6, TFS_KS04); \
\
BE_MIX(X, T, TFS_BS07); BE_MIX(Z, Y, TFS_BS08); \
BE_MIX(X, Y, TFS_BS09); BE_MIX(Z, T, TFS_BS10); \
BE_MIX(X, T, TFS_BS11); BE_MIX(Z, Y, TFS_BS12); \
} while (0)
#define NOSIZE ((size_t)-1)
#define XRET(x) if (!xret && xret < x) xret = x
class Shred
{
protected:
public:
Shred();
~Shred();
void shredDrive(Drive* drive, int* ipSignalFd);
private:
unsigned long blockcount = 0UL;
long blockcount_max;
double d32Percent;
inline double calcProgress();
inline void tfnge_init_iv(struct tfnge_stream *tfe, const void *key, const void *iv);
inline void tfnge_init(struct tfnge_stream *tfe, const void *key);
inline void tfng_encrypt_rawblk(TFNG_UNIT_TYPE *O, const TFNG_UNIT_TYPE *I, const TFNG_UNIT_TYPE *K);
inline void tfnge_emit(void *dst, size_t szdst, struct tfnge_stream *tfe);
};
#endif // SHRED_H_

51
include/shred/tfcore.h Normal file
View File

@ -0,0 +1,51 @@
#ifndef _THREEFISH_NOISE_GENERATOR_CIPHER_CORE_HEADER
#define _THREEFISH_NOISE_GENERATOR_CIPHER_CORE_HEADER
#ifndef _THREEFISH_NOISE_GENERATOR_CIPHER_DEFINITIONS_HEADER
#error Threefish definitions header is required! Include tfdef.h first.
#endif
#define ROL(x, s, max) ((x << s) | (x >> (-s & (max-1))))
#define ROR(x, s, max) ((x >> s) | (x << (-s & (max-1))))
#define KE_MIX(x, y, k1, k2, sl) \
do { \
x += k1; \
y += x; \
y += k2; \
x = ROL(x, sl, TFNG_UNIT_BITS); \
x ^= y; \
} while (0)
#define BE_MIX(x, y, sl) \
do { \
x += y; \
y = ROL(y, sl, TFNG_UNIT_BITS); \
y ^= x; \
} while (0)
#define KD_MIX(x, y, k1, k2, sr) \
do { \
x ^= y; \
x = ROR(x, sr, TFNG_UNIT_BITS); \
y -= x; \
y -= k2; \
x -= k1; \
} while (0)
#define BD_MIX(x, y, sr) \
do { \
y ^= x; \
y = ROR(y, sr, TFNG_UNIT_BITS); \
x -= y; \
} while (0)
enum tfng_rotations
{
TFS_KS01 = 7, TFS_KS02 = 25, TFS_KS03 = 19, TFS_KS04 = 7,
TFS_BS01 = 5, TFS_BS02 = 27, TFS_BS03 = 26, TFS_BS04 = 6,
TFS_BS05 = 14, TFS_BS06 = 11, TFS_BS07 = 24, TFS_BS08 = 18,
TFS_BS09 = 9, TFS_BS10 = 24, TFS_BS11 = 6, TFS_BS12 = 7,
};
#endif

39
include/shred/tfdef.h Normal file
View File

@ -0,0 +1,39 @@
#ifndef _THREEFISH_NOISE_GENERATOR_CIPHER_DEFINITIONS_HEADER
#define _THREEFISH_NOISE_GENERATOR_CIPHER_DEFINITIONS_HEADER
#ifndef _DEFAULT_SOURCE
#define _DEFAULT_SOURCE
#endif
#ifndef _BSD_SOURCE
#define _BSD_SOURCE
#endif
#include <stddef.h>
#include <stdint.h>
#include "machdefs.h"
#if defined(MACHINE_64BIT)
#define TFNG_UNIT_TYPE uint64_t
#define TFNG_NR_BLOCK_BITS 256
#define TFNG_NR_KEY_BITS 512
#else
#define TFNG_UNIT_TYPE uint32_t
#define TFNG_NR_BLOCK_BITS 128
#define TFNG_NR_KEY_BITS 256
#endif
#define TFNG_NR_BLOCK_UNITS 4
#define TFNG_NR_KEY_UNITS 8
#define TFNG_BYTE_TYPE uint8_t
#define TFNG_SIZE_UNIT (sizeof(TFNG_UNIT_TYPE))
#define TFNG_BLOCK_SIZE (TFNG_SIZE_UNIT * TFNG_NR_BLOCK_UNITS)
#define TFNG_KEY_SIZE (TFNG_SIZE_UNIT * TFNG_NR_KEY_UNITS)
#define TFNG_TO_BITS(x) ((x) * 8)
#define TFNG_FROM_BITS(x) ((x) / 8)
#define TFNG_MAX_BITS TFNG_NR_BLOCK_BITS
#define TFNG_UNIT_BITS (TFNG_SIZE_UNIT * 8)
#endif

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_

32
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,14 @@ 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, 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);
void displaySelectedDrive(Drive drive, int stdscrX, int stdscrY); void displaySelectedDrive(Drive drive, int stdscrX, int stdscrY);
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 $@

17
scripts/getty@tty1.service.d_override.conf
View File

@ -1,17 +0,0 @@
[Unit]
Description=reHDD on tty1
[Service]
WorkingDirectory=/root/reHDD/
ExecStart=
ExecStart=-/root/reHDD/reHDD
StandardInput=tty
StandardOutput=tty
Restart=always
RestartSec=1
UtmpIdentifier=tty1
TTYPath=/dev/tty1
TTYReset=yes
TTYVHangup=yes
TTYVTDisallocate=yes
SendSIGHUP=yes

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

@ -1,17 +0,0 @@
[Unit]
Description=dmesg on tty2
[Service]
WorkingDirectory=/usr/bin/
ExecStart=
ExecStart=-/usr/bin/dmesg -wHT
StandardInput=tty
StandardOutput=tty
Restart=always
RestartSec=1
UtmpIdentifier=tty2
TTYPath=/dev/tty2
TTYReset=yes
TTYVHangup=yes
TTYVTDisallocate=yes
SendSIGHUP=yes

17
scripts/getty@tty3.service.d_override.conf
View File

@ -1,17 +0,0 @@
[Unit]
Description=htop on tty3
[Service]
WorkingDirectory=/usr/bin/
ExecStart=
ExecStart=-/usr/bin/htop
StandardInput=tty
StandardOutput=tty
Restart=always
RestartSec=1
UtmpIdentifier=tty3
TTYPath=/dev/tty3
TTYReset=yes
TTYVHangup=yes
TTYVTDisallocate=yes
SendSIGHUP=yes

27
scripts/install_reHDD.bash
View File

@ -1,27 +0,0 @@
#!/bin/bash
cd /root/reHDD/scripts/
chmod +x reHDDLogUploader.bash
cp reHDDLogUploader.service /lib/systemd/system/reHDDLogUploader.service
cp reHDDLogUploader.timer /lib/systemd/system/reHDDLogUploader.timer
systemctl daemon-reload
systemctl enable /lib/systemd/system/reHDDLogUploader.timer
chmod +x reHDDStartHelper.bash
cp reHDDStartHelper.service /lib/systemd/system/reHDDStartHelper.service
systemctl daemon-reload
systemctl enable /lib/systemd/system/reHDDStartHelper.service
mkdir -p /lib/systemd/system/getty@tty1.service.d
cp getty@tty1.service.d_override.conf /lib/systemd/system/getty@tty1.service.d/override.conf
systemctl daemon-reload
mkdir -p /lib/systemd/system/getty@tty2.service.d
cp getty@tty2.service.d_override.conf /lib/systemd/system/getty@tty2.service.d/override.conf
systemctl daemon-reload
mkdir -p /lib/systemd/system/getty@tty3.service.d
cp getty@tty3.service.d_override.conf /lib/systemd/system/getty@tty3.service.d/override.conf
systemctl daemon-reload

6
scripts/reHDDLogUploader.bash
View File

@ -1,6 +0,0 @@
#!/bin/bash
# remove comment for the following to activate log telemetie
curl -k -T /root/reHDD/reHDD.log -u "__Place_your_token_here__:" -H 'X-Requested-With: XMLHttpRequest' https://schuttercloud.com/public.php/webdav/`echo $(date '+%Y-%m-%d_%H-%M')`_reHDD.log
rm -f /root/reHDD/reHDD.log

18
scripts/reHDDLogUploader.service
View File

@ -1,18 +0,0 @@
[Unit]
Description=reHDD log uploader
After=syslog.target
After=network.target
After=network-online.target
Wants=network-online.target
[Service]
Type=oneshot
User=root
Group=root
RemainAfterExit=yes
ExecStart=/usr/bin/bash /root/reHDD/scripts/reHDDLogUploader.bash
[Install]
WantedBy=multi-user.target

11
scripts/reHDDLogUploader.timer
View File

@ -1,11 +0,0 @@
[Unit]
Description=reHDD log uploader timer
[Timer]
OnActiveSec=30s
OnBootSec=10min
OnUnitActiveSec=12h
[Install]
WantedBy=basic.target

4
scripts/reHDDStartHelper.bash
View File

@ -1,4 +0,0 @@
#!/bin/bash
dmesg -n 1 #disable overlay if a drive is attached/detached

16
scripts/reHDDStartHelper.service
View File

@ -1,16 +0,0 @@
[Install]
WantedBy=multi-user.target
[Unit]
Description=reHDD start helper
After=syslog.target
[Service]
Type=oneshot
User=root
Group=root
RemainAfterExit=yes
ExecStart=/usr/bin/bash /root/reHDD/scripts/reHDDStartHelper.bash
[Install]
WantedBy=multi-user.target

36
scripts/update.sh
View File

@ -1,36 +0,0 @@
#! /usr/bin/bash
echo starting update
systemctl stop /lib/systemd/system/getty@tty1.service.d
cd /root/reHDD/
FILE=../ignoreDrives.conf
if test -f "$FILE"; then
echo "backup exits already"
else
cp /root/reHDD/ignoreDrives.conf /root/ignoreDrives.conf
fi
git reset
git stash force
git stash
git checkout master
git pull
git submodule init
git submodule update
make clean
make release
cp /root/ignoreDrives.conf /root/reHDD/ignoreDrives.conf
systemctl start /lib/systemd/system/getty@tty1.service.d

12
shred_dummy.sh Normal file
View File

@ -0,0 +1,12 @@
#! /bin/bash
echo "starting SHRED DUMMY"
for i in {0..100..10}
do
#echo "DUMMY shred $i%"
echo $date > out.txt
sleep 1
done
echo "finished SHRED DUMMY"

6
src/delete.cpp
View File

@ -32,15 +32,11 @@ 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)
{ {
//wipefs running //wipefs running
} }
pclose(deleteCmdOutput); fclose(deleteCmdOutput);
}
} }

93
src/drive.cpp
View File

@ -14,57 +14,51 @@ 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()
{ {
char acBuffer[16]; if(getCapacity() <= (999*1000000000UL))
double dSize = (double)getCapacity();
uint16_t u16UnitIndex = 0;
const char *units[] = {"B", "kB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"};
while (dSize >= 1000) // using the marketing capacity
{ {
dSize /= 1000; // Less or even 999 GB --> GB
u16UnitIndex++; return to_string(getCapacity() / 1000000000UL) + " GB";
} }
else
sprintf(acBuffer, "%.*f %s", u16UnitIndex - 3, dSize, units[u16UnitIndex]); {
return acBuffer; // More 999 GB --> TB
return to_string(getCapacity() / 1000000000000UL) + " TB";
}
return "ERROR";
} }
string Drive::sErrorCountToText() string Drive::sErrorCountToText()
@ -72,6 +66,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 +91,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 +104,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 +114,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,56 +122,32 @@ 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()
{ {
time(&this->u32Timestamp); time(&this->u32Timestamp);
} }
void Drive::setActionStartTimestamp()
{
time(&this->u32TimestampTaskStart);
}
time_t Drive::getActionStartTimestamp()
{
return this->u32TimestampTaskStart;
}
void Drive::calculateTaskDuration()
{
time_t u32localtime;
time(&u32localtime);
this->u32TaskDuration = u32localtime - this->u32TimestampTaskStart;
}
time_t Drive::getTaskDuration()
{
return this->u32TaskDuration;
}
void Drive::checkFrozenDrive(void) 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
}
}

330
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,18 @@ 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
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);
} }
@ -225,10 +209,9 @@ void reHDD::ThreadDelete()
{ {
if (getSelectedDrive() != nullptr) if (getSelectedDrive() != nullptr)
{ {
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 +220,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 +244,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 +277,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 +287,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"); // cout << "search drives ..." << endl;
if (!fp) Logger::logThis()->info("--> search drives <--");
char * cLine = NULL;
size_t len = 0;
FILE* outputfileHwinfo = popen("ls -1 /dev/sd*", "r");
if (outputfileHwinfo == NULL)
{ {
Logger::logThis()->error("Unable to execute lsblk to scan drives"); Logger::logThis()->error("Unable to scann 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() == 9)
std::istringstream iss(line); {
iss >> devName >> transport; Drive* tmpDrive = new Drive(string(cLine).substr(0, 8));
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() +
" (type: " +
(tmpDrive->connectionType == Drive::USB ? "USB" : tmpDrive->connectionType == Drive::SATA ? "SATA"
: tmpDrive->connectionType == Drive::NVME ? "NVME"
: "UNKNOWN") +
")");
} }
}
pclose(fp); fclose(outputfileHwinfo);
} }
/** /**
@ -360,41 +322,39 @@ void reHDD::searchDrives(std::list<Drive> *plistDrives)
*/ */
void reHDD::filterIgnoredDrives(list <Drive>* plistDrives) void reHDD::filterIgnoredDrives(list <Drive>* plistDrives)
{ {
string systemDrivePath; string sDelimiter = ":";
if (getSystemDrive(systemDrivePath)) string sIgnoredDrivePath;
{ string sIgnoredDriveUUID;
// Logger::logThis()->info("Found system drive: " + systemDrivePath);
list<Drive>::iterator it; list<tuple<string, string>> vtlIgnoredDevices; //store drives from ingnore file
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 ingnore 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); if (string(sLine).find("/dev/sd") != string::npos)
vtlIgnoredDevices.emplace_back(sLine); // add found path and uuid from ignore file to vector {
size_t pos = 0;
string token;
while ((pos = sLine.find(sDelimiter)) != string::npos)
{
token = sLine.substr(0, pos);
sIgnoredDrivePath = token;
sLine.erase(0, pos + sDelimiter.length());
sIgnoredDriveUUID = sLine;
} //end while
vtlIgnoredDevices.emplace_back(sIgnoredDrivePath, sIgnoredDriveUUID); //add found path and uuid from ingnore 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;
for (it = plistDrives->begin(); it != plistDrives->end(); ++it) for (it = plistDrives->begin(); it != plistDrives->end(); ++it)
{ {
string sUUID; string sUUID;
if (!get<0>(row).compare(it->getPath())) //find same drive based on path
{
char * cLine = NULL; char * cLine = NULL;
size_t len = 0; size_t len = 0;
string sCMD = "blkid "; string sCMD = "blkid ";
@ -412,15 +372,21 @@ void reHDD::filterIgnoredDrives(list<Drive> *plistDrives)
{ {
string sBlkidOut = string(cLine); string sBlkidOut = string(cLine);
sBlkidOut.erase(0, 18); sBlkidOut.erase(0, 18);
sBlkidOut.erase(8, sBlkidOut.length()); sBlkidOut.erase(36, sBlkidOut.length() - 36);
sUUID = sBlkidOut; sUUID = sBlkidOut;
//cout << "blkid uuid:" << sUUID << endl; //cout << "blkid uuid:" << sUUID << endl;
} }
} }
pclose(outputfileBlkid); fclose(outputfileBlkid);
//cout << "blkid uuid:" << sUUID << endl; //cout << "blkid uuid:" << sUUID << endl;
if (!get<0>(row).compare(sUUID)) // compare uuid from ignore file and uuid from drive if (get<1>(row).compare(sUUID)) //compare uuid from ignore file and uuid from drive
{
cout << "[ERROR] different uuid found than in ignore file:" << it->getPath() << endl;
Logger::logThis()->error("[ERROR] different uuid found than in ignore file: " + it->getPath());
exit(EXIT_FAILURE); // exit to prevent accidentally shred a system drive
}
else
{ {
// same uuid found than in ignore file --> ignore this drive // same uuid found than in ignore file --> ignore this drive
#ifdef LOG_LEVEL_HIGH #ifdef LOG_LEVEL_HIGH
@ -432,80 +398,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();
} }
/** /**
@ -543,33 +435,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 +477,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 +533,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;
}

304
src/shred.cpp
View File

@ -1,304 +0,0 @@
/**
* @file shred.cpp
* @brief shred drive
* @author hendrik schutter
* @date 22.08.2022
*/
#include "../include/reHDD.h"
#ifdef __cplusplus
extern "C"
{
#endif
#include "../tfnoisegen/tfprng.h"
#ifdef __cplusplus
}
#endif
const static char *randomsrc = (char *)"/dev/urandom";
Shred::Shred()
{
}
Shred::~Shred()
{
}
/**
* \brief shred drive with shred
* \param pointer of Drive instance
* \return void
*/
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
for (int i = 0; i <= 500; i++)
{
if (drive->state != Drive::SHRED_ACTIVE)
{
return 0;
}
drive->setTaskPercentage(i + 0.05);
write(*ipSignalFd, "A", 1);
usleep(20000);
}
drive->bWasShredded = true;
#endif
#ifndef DRYRUN
const char *cpDrivePath = drive->getPath().c_str();
unsigned char ucKey[TFNG_KEY_SIZE];
// open random source
randomSrcFileDiscr = open(randomsrc, O_RDONLY | O_LARGEFILE);
if (randomSrcFileDiscr == -1)
{
std::string errorMsg(strerror(randomSrcFileDiscr));
Logger::logThis()->error("Shred-Task: Open random source failed! " + errorMsg + " - Drive: " + drive->getSerial());
perror(randomsrc);
cleanup();
return -1;
}
// open disk
driveFileDiscr = open(cpDrivePath, O_RDWR | O_LARGEFILE);
if (driveFileDiscr == -1)
{
std::string errorMsg(strerror(driveFileDiscr));
Logger::logThis()->error("Shred-Task: Open drive failed! " + errorMsg + " - Drive: " + drive->getSerial());
perror(cpDrivePath);
cleanup();
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);
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
Logger::logThis()->info("Shred-Task: Bytes-Size of Drive: " + to_string(this->ulDriveByteSize) + " - Drive: " + drive->getSerial());
#endif
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
if (uiShredIterationCounter == (SHRED_ITERATIONS - 1))
{
// last shred iteration --> overwrite (just the write chunk) bytes with zeros instead with random data
memset(caTfngData, 0U, CHUNK_SIZE);
}
while (ulDriveByteCounter < ulDriveByteSize)
{
int iBytesToShred = 0; // Bytes that will be overwritten in this chunk-iteration
if (uiShredIterationCounter != (SHRED_ITERATIONS - 1))
{
// NOT last shred iteration --> generate new random data
tfng_prng_genrandom(caTfngData, TFNG_DATA_SIZE);
}
if ((ulDriveByteSize - ulDriveByteCounter) < CHUNK_SIZE)
{
iBytesToShred = (ulDriveByteSize - ulDriveByteCounter);
}
else
{
iBytesToShred = CHUNK_SIZE;
}
int iByteShredded = write(driveFileDiscr, caTfngData, iBytesToShred);
if (iByteShredded <= 0)
{
std::string errorMsg(strerror(iByteShredded));
Logger::logThis()->error("Shred-Task: Write to drive failed! " + errorMsg + " - Drive: " + drive->getSerial());
perror("unable to write random data");
cleanup();
return -1;
}
ulDriveByteCounter += iByteShredded;
ulDriveByteOverallCount += iByteShredded;
d32Percent = this->calcProgress();
drive->sShredSpeed.ulSpeedMetricBytesWritten += iByteShredded;
#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());
#endif
if ((d32Percent - d32TmpPercent) >= 0.01)
{
// set shred percantage
drive->setTaskPercentage(d32TmpPercent);
d32TmpPercent = d32Percent;
// signal process in shreding
write(*ipSignalFd, "A", 1);
}
if (drive->state != Drive::SHRED_ACTIVE)
{
drive->setTaskPercentage(0);
d32Percent = 0.00;
d32TmpPercent = 0.00;
ulDriveByteCounter = 0U;
Logger::logThis()->info("Aborted shred for: " + drive->getModelName() + "-" + drive->getSerial());
cleanup();
return -1;
}
// end one chunk write
}
if (0 != iRewindDrive(driveFileDiscr))
{
Logger::logThis()->error("Shred-Task: Unable to rewind drive! - Drive: " + drive->getSerial());
cleanup();
return -1;
}
// end one shred iteration
}
// end of all shred iteratio
tfng_prng_seedkey(NULL); // reset random generator
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
if (drive->u32DriveChecksumAfterShredding != 0)
{
Logger::logThis()->info("Shred-Task: Checksum not zero: " + to_string(drive->u32DriveChecksumAfterShredding) + " - Drive: " + drive->getSerial());
}
else
{
Logger::logThis()->info("Shred-Task: Checksum zero: " + to_string(drive->u32DriveChecksumAfterShredding) + " - Drive: " + drive->getSerial());
}
#endif
#endif
#endif
cleanup();
if ((drive->state == Drive::SHRED_ACTIVE) || (drive->state == Drive::CHECK_ACTIVE))
{
drive->state = Drive::NONE;
drive->setTaskPercentage(0.0);
Printer::getPrinter()->print(drive);
Logger::logThis()->info("Finished shred/check for: " + drive->getModelName() + "-" + drive->getSerial());
}
return 0;
}
/**
* \brief calc shredding progress in %
* \param current byte index of the drive
* \param current shred iteration
* \return double percentage
*/
double Shred::calcProgress()
{
unsigned int uiMaxShredIteration = SHRED_ITERATIONS;
#ifdef ZERO_CHECK
uiMaxShredIteration++; // increment because we will check after SHRED_ITERATIONS the drive for non-zero bytes
#endif
return (double)(((double)ulDriveByteOverallCount) / ((double)this->ulDriveByteSize * uiMaxShredIteration)) * 100.0f;
}
int Shred::iRewindDrive(fileDescriptor file)
{
if (0 != lseek(file, 0L, SEEK_SET))
{
perror("unable to rewind drive");
return -1;
}
else
{
return 0;
}
}
unsigned long Shred::getDriveSizeInBytes(fileDescriptor file)
{
unsigned long ulDriveSizeTmp = lseek(file, 0L, SEEK_END);
if (0 != iRewindDrive(file))
{
ulDriveSizeTmp = 0U;
}
#ifdef DEMO_DRIVE_SIZE
ulDriveSizeTmp = DEMO_DRIVE_SIZE;
#endif
return ulDriveSizeTmp;
}
unsigned int Shred::uiCalcChecksum(fileDescriptor file, Drive *drive, int *ipSignalFd)
{
unsigned int uiChecksum = 0;
unsigned long ulDriveByteCounter = 0U;
while (ulDriveByteCounter < ulDriveByteSize)
{
int iBytesToCheck = 0;
if ((ulDriveByteSize - ulDriveByteCounter) < CHUNK_SIZE)
{
iBytesToCheck = (ulDriveByteSize - ulDriveByteCounter);
}
else
{
iBytesToCheck = CHUNK_SIZE;
}
int iReadBytes = read(file, caReadBuffer, iBytesToCheck);
for (int iReadBytesCounter = 0U; iReadBytesCounter < iReadBytes; iReadBytesCounter++)
{
uiChecksum += caReadBuffer[iReadBytesCounter];
}
ulDriveByteCounter += iReadBytes;
ulDriveByteOverallCount += iReadBytes;
d32Percent = this->calcProgress();
drive->sShredSpeed.ulSpeedMetricBytesWritten += iReadBytes;
#ifdef LOG_LEVEL_HIGH
Logger::logThis()->info("Shred-Task (Checksum): ByteCount: " + to_string(ulDriveByteCounter) + " - progress: " + to_string(d32Percent) + " - Drive: " + drive->getSerial());
#endif
if (((d32Percent - d32TmpPercent) >= 0.01) || (d32Percent == 100.0))
{
drive->setTaskPercentage(d32TmpPercent);
d32TmpPercent = d32Percent;
#ifdef LOG_LEVEL_HIGH
Logger::logThis()->info("send progress signal to main loop (check)");
#endif
write(*ipSignalFd, "A", 1);
}
}
drive->bWasChecked = true;
return uiChecksum;
}
void Shred::cleanup()
{
close(driveFileDiscr);
close(randomSrcFileDiscr);
}

404
src/shred/shred.cpp Normal file
View File

@ -0,0 +1,404 @@
/**
* @file shred.cpp
* @brief shred drive
* @author hendrik schutter
* @date 03.05.2020
*/
#include "../../include/reHDD.h"
#ifndef DRYRUN
static char *randsrc = (char*) "/dev/urandom";
static int force = 0, rmf = 0, zrf = 0, noround = 0, verbose = 0, syncio = 0, alwaysrand = 0, reqrand = 0;
static char sfbuf[PATH_MAX*2];
struct tfnge_stream
{
TFNG_UNIT_TYPE key[TFNG_NR_KEY_UNITS];
TFNG_UNIT_TYPE iv[TFNG_NR_BLOCK_UNITS];
TFNG_BYTE_TYPE carry_block[TFNG_BLOCK_SIZE];
size_t carry_bytes;
};
static struct tfnge_stream tfnge;
#endif
Shred::Shred()
{
}
Shred::~Shred()
{
}
/**
* \brief shred drive with shred
* \param pointer of Drive instance
* \return void
*/
void Shred::shredDrive(Drive* drive, int* ipSignalFd)
{
#ifdef DRYRUN
for(int i = 0; i<=100; i++)
{
if(drive->state != Drive::SHRED_ACTIVE)
{
return;
}
drive->setTaskPercentage(i+0.05);
write(*ipSignalFd, "A",1);
usleep(20000);
}
#endif
#ifndef DRYRUN
struct stat st;
char *buf, *s, *d, rc = 0;
int f, rsf;
int xret = 0, pat = 0, last = 0, special = 0, iIteration = 0;
size_t blksz = 0, x, y;
size_t l, ll = NOSIZE;
const char *cpDrivePath = drive->getPath().c_str();
blockcount_max = SHRED_ITERATIONS*(drive->getCapacity()/4096);
#ifdef LOG_LEVEL_HIGH
Logger::logThis()->info("Shred-Task: Max-BlockCount: " + to_string(blockcount_max) + " - Drive: " + drive->getSerial());
#endif
d32Percent = 0U;
rsf = open(randsrc, O_RDONLY | O_LARGEFILE);
if (rsf == -1)
{
perror(randsrc);
exit(1);
}
special = pat = 0;
iIteration = SHRED_ITERATIONS;
if (verbose) fprintf(stderr, "destroying %s ...\n", cpDrivePath);
if (stat(cpDrivePath, &st) == -1)
{
perror(cpDrivePath);
XRET(1);
goto _return;
}
if (!blksz) blksz = (size_t)st.st_blksize;
else l = ll = st.st_size;
if (l == 0 && !S_ISREG(st.st_mode)) special = 1;
memset(&st, 0, sizeof(struct stat));
if (force) if (chmod(cpDrivePath, S_IRUSR|S_IWUSR) == -1)
{
perror(cpDrivePath);
XRET(1);
}
f = open(cpDrivePath, O_WRONLY | O_LARGEFILE | O_NOCTTY | syncio);
if (f == -1)
{
XRET(1);
perror(cpDrivePath);
goto _return;
}
buf = (char*) malloc(blksz);
if (!buf)
{
perror("malloc");
XRET(2);
fprintf(stderr, "Continuing with fixed buffer (%zu bytes long)\n", sizeof(sfbuf));
buf = sfbuf;
blksz = sizeof(sfbuf);
}
memset(buf, 0, blksz);
if (read(rsf, buf, blksz) <= 0) fprintf(stderr, "%s: read 0 bytes (wanted %zu)\n", randsrc, blksz);
tfnge_init(&tfnge, buf);
//iteration loop
while (iIteration)
{
lseek(f, 0L, SEEK_SET);
if (iIteration <= 1 && zrf)
{
pat = 1;
rc = 0;
}
else if (iIteration == SHRED_ITERATIONS && reqrand)
{
pat = 0;
}
else if (!alwaysrand)
{
if (read(rsf, &rc, 1) <= 0) fprintf(stderr, "%s: read 0 bytes (wanted 1)\n", randsrc);
pat = rc%2;
if (read(rsf, &rc, 1) <= 0) fprintf(stderr, "%s: read 0 bytes (wanted 1)\n", randsrc);
}
else pat = 0;
if (verbose)
{
if (pat) fprintf(stderr, "iteration (pat) %d (%02hhx%02hhx%02hhx) ...\n", SHRED_ITERATIONS-iIteration+1, rc, rc, rc);
else fprintf(stderr, "iteration (!pat) %d (random) ...\n", SHRED_ITERATIONS-iIteration+1);
}
// write block loop
while (1)
{
if(drive->state != Drive::SHRED_ACTIVE)
{
drive->setTaskPercentage(0);
d32Percent = 0.00;
blockcount = 0;
blockcount_max = 0;
Logger::logThis()->info("Aborted shred for: " + drive->getModelName() + "-" + drive->getSerial());
goto _return;
}
double d32TmpPercent = calcProgress();
if((d32TmpPercent-d32Percent) >= 0.09)
{
drive->setTaskPercentage(d32TmpPercent);
d32Percent = d32TmpPercent;
#ifdef LOG_LEVEL_HIGH
Logger::logThis()->info("Shred-Task: BlockCount: " + to_string(blockcount) + " - progress: " + to_string(d32Percent) + " - Drive: " + drive->getSerial());
#endif
write(*ipSignalFd, "A",1);
}
if (!pat)
{
tfnge_emit(buf, blksz, &tfnge);
}
else
{
memset(buf, rc, blksz);
}
if (l <= blksz && !special)
{
last = 1;
}
errno = 0;
l -= write(f, buf, (noround && last) ? l : blksz);
if (errno)
{
perror(cpDrivePath);
errno = 0;
break;
}
if (last)
{
last = 0;
break;
}
}
// write block loop end
l = ll;
fdatasync(f);
iIteration--;
} //iteration loop end
if (rmf)
{
close(f);
f = open(cpDrivePath, O_WRONLY | O_TRUNC | O_LARGEFILE | O_NOCTTY | syncio);
if (verbose) fprintf(stderr, "removing %s ...\n", cpDrivePath);
x = strnlen(cpDrivePath, sizeof(sfbuf)/2);
s = sfbuf+(sizeof(sfbuf)/2);
memcpy(sfbuf, cpDrivePath, x);
*(sfbuf+x) = 0;
d = strrchr(sfbuf, '/');
if (d)
{
d++;
y = d-sfbuf;
memset(d, '0', x-(d-sfbuf));
}
else
{
y = 0;
memset(sfbuf, '0', x);
}
memcpy(s, sfbuf, x);
*(s+x) = 0;
/* Somehow I need to rename original to destination */
if (access(s, R_OK) != -1)
{
fprintf(stderr, "%s already exists!\n", s);
unlink(cpDrivePath);
goto _return;
}
if (verbose) fprintf(stderr, "%s -> %s\n", cpDrivePath, s);
if (rename(cpDrivePath, s) == -1)
{
perror(s);
goto _return;
}
while (x > y+1)
{
*(sfbuf+x) = 0;
x--;
*(s+x) = 0;
if (access(s, R_OK) != -1)
{
fprintf(stderr, "%s already exists!\n", s);
unlink(sfbuf);
goto _return;
}
if (verbose) fprintf(stderr, "%s -> %s\n", sfbuf, s);
if (rename(sfbuf, s) == -1)
{
perror(s);
goto _return;
}
}
if (verbose) fprintf(stderr, "remove %s\n", s);
unlink(s);
if (verbose) fprintf(stderr, "done away with %s.\n", cpDrivePath);
}
tfnge_emit(NULL, 0, &tfnge);
if (buf && buf != sfbuf) free(buf);
if (f != -1) close(f);
_return:
optind++;
close(rsf);
#endif
if(drive->state == Drive::SHRED_ACTIVE)
{
drive->bWasShredded = true;
drive->state= Drive::NONE;
drive->setTaskPercentage(0);
Logger::logThis()->info("Finished shred for: " + drive->getModelName() + "-" + drive->getSerial());
}
}
#ifndef DRYRUN
double Shred::calcProgress()
{
blockcount++;
return ((((double)blockcount/(double)blockcount_max))*100);
}
void Shred::tfnge_init_iv(struct tfnge_stream *tfe, const void *key, const void *iv)
{
memset(tfe, 0, sizeof(struct tfnge_stream));
memcpy(tfe->key, key, TFNG_KEY_SIZE);
if (iv) memcpy(tfe->iv, iv, TFNG_BLOCK_SIZE);
tfe->carry_bytes = 0;
}
void Shred::tfnge_init(struct tfnge_stream *tfe, const void *key)
{
tfnge_init_iv(tfe, key, NULL);
}
void Shred::tfng_encrypt_rawblk(TFNG_UNIT_TYPE *O, const TFNG_UNIT_TYPE *I, const TFNG_UNIT_TYPE *K)
{
TFNG_UNIT_TYPE X, Y, Z, T;
TFNG_UNIT_TYPE K0, K1, K2, K3;
TFNG_UNIT_TYPE K4, T0, T1, T2;
X = I[0];
Y = I[1];
Z = I[2];
T = I[3];
K0 = K[0];
K1 = K[1];
K2 = K[2];
K3 = K[3];
K4 = K[4];
T0 = K[5];
T1 = K[6];
T2 = K[7];
PROCESS_BLOCKP( 1,K1,T0,K0,K3,K2,T1);
PROCESS_BLOCKN( 2,K2,T1,K1,K4,K3,T2);
PROCESS_BLOCKP( 3,K3,T2,K2,K0,K4,T0);
PROCESS_BLOCKN( 4,K4,T0,K3,K1,K0,T1);
PROCESS_BLOCKP( 5,K0,T1,K4,K2,K1,T2);
PROCESS_BLOCKN( 6,K1,T2,K0,K3,K2,T0);
PROCESS_BLOCKP( 7,K2,T0,K1,K4,K3,T1);
PROCESS_BLOCKN( 8,K3,T1,K2,K0,K4,T2);
PROCESS_BLOCKP( 9,K4,T2,K3,K1,K0,T0);
PROCESS_BLOCKN(10,K0,T0,K4,K2,K1,T1);
PROCESS_BLOCKP(11,K1,T1,K0,K3,K2,T2);
PROCESS_BLOCKN(12,K2,T2,K1,K4,K3,T0);
O[0] = X + K3;
O[1] = Y + K4 + T0;
O[2] = Z + K0 + T1;
O[3] = T + K1 + 18;
}
void Shred::tfnge_emit(void *dst, size_t szdst, struct tfnge_stream *tfe)
{
TFNG_BYTE_TYPE *udst = (uint8_t*) dst;
size_t sz = szdst;
if (!dst && szdst == 0)
{
memset(tfe, 0, sizeof(struct tfnge_stream));
return;
}
if (tfe->carry_bytes > 0)
{
if (tfe->carry_bytes > szdst)
{
memcpy(udst, tfe->carry_block, szdst);
memmove(tfe->carry_block, tfe->carry_block+szdst, tfe->carry_bytes-szdst);
tfe->carry_bytes -= szdst;
return;
}
memcpy(udst, tfe->carry_block, tfe->carry_bytes);
udst += tfe->carry_bytes;
sz -= tfe->carry_bytes;
tfe->carry_bytes = 0;
}
if (sz >= TFNG_BLOCK_SIZE)
{
do
{
tfng_encrypt_rawblk(tfe->iv, tfe->iv, tfe->key);
memcpy(udst, tfe->iv, TFNG_BLOCK_SIZE);
udst += TFNG_BLOCK_SIZE;
}
while ((sz -= TFNG_BLOCK_SIZE) >= TFNG_BLOCK_SIZE);
}
if (sz)
{
tfng_encrypt_rawblk(tfe->iv, tfe->iv, tfe->key);
memcpy(udst, tfe->iv, sz);
udst = (TFNG_BYTE_TYPE *)tfe->iv;
tfe->carry_bytes = TFNG_BLOCK_SIZE-sz;
memcpy(tfe->carry_block, udst+sz, tfe->carry_bytes);
}
}
#endif

209
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);
} }
fclose(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;
}
}

287
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,9 @@ 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 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,10 +85,10 @@ 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);
} }
} }
@ -118,58 +99,28 @@ void TUI::updateTUI(list<Drive> *plistDrives, uint8_t u8SelectedEntry)
{ {
case Drive::SHRED_ACTIVE: case Drive::SHRED_ACTIVE:
stream << fixed << setprecision(3) << (it->getTaskPercentage()); stream << fixed << setprecision(2) << (it->getTaskPercentage());
sState = "Shredding: " + stream.str() + "%"; sState = "Shredding: " + stream.str() + "%";
break;
it->calculateTaskDuration();
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;
case Drive::DELETE_ACTIVE: case Drive::DELETE_ACTIVE:
sState = "Deleting ..."; sState = "Deleting ...";
it->calculateTaskDuration();
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());
}
#ifdef ZERO_CHECK
if (bSelectedEntry && it->bWasChecked && (it->u32DriveChecksumAfterShredding != 0U))
{
dialog = createZeroChecksumWarning(70, 16, ((u16StdscrX) - (int)(u16StdscrX / 2) - 20), (int)(u16StdscrY / 2) - 8, it->getPath(), it->getModelFamily(), it->getModelName(), it->getSerial(), it->u32DriveChecksumAfterShredding);
wrefresh(dialog);
}
#endif
break; break;
case Drive::FROZEN: case Drive::FROZEN:
stream << fixed << setprecision(3) << (it->getTaskPercentage()); stream << fixed << setprecision(2) << (it->getTaskPercentage());
#ifdef FROZEN_ALERT #ifdef FROZEN_ALERT
if(bSelectedEntry) if(bSelectedEntry)
{ {
@ -183,9 +134,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, 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 +150,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 +186,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 +206,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 +222,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 +230,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 +241,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 +258,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 +270,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 +288,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, bool bSelected)
{ {
WINDOW *newWindow; WINDOW *newWindow;
newWindow = newwin(iYSize, iXSize, iYStart, iXStart); newWindow = newwin(iYSize, iXSize, iYStart, iXStart);
@ -356,67 +296,23 @@ 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
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 +337,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 +362,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;
} }
@ -553,79 +439,9 @@ WINDOW *TUI::createFrozenWarning(int iXSize, int iYSize, int iXStart, int iYStar
return newWindow; return newWindow;
} }
WINDOW *TUI::createZeroChecksumWarning(int iXSize, int iYSize, int iXStart, int iYStart, string sPath, string sModelFamily, string sModelName, string sSerial, uint32_t u32Checksum)
{
WINDOW *newWindow;
newWindow = newwin(iYSize, iXSize, iYStart, iXStart);
wbkgd(newWindow, COLOR_PAIR(COLOR_AREA_ENTRY_SELECTED));
box(newWindow, ACS_VLINE, ACS_HLINE);
string sHeader = "Drive " + sPath + " is NOT successfully shredded!";
string sLine01 = "Please detach this drive and check it manually:";
string sShredChecksum = "After shredding the checksum was: " + to_string(u32Checksum);
string sLinePath = "Path: " + sPath;
string sLineModelFamily = "ModelFamily: " + sModelFamily;
string sLineModelName = "ModelName: " + sModelName;
string sLineSerial = "Serial: " + sSerial;
string sLine02 = "reHDD was not able to write zero into every byte on the drive.";
string sLine03 = "This can be caused by an malfunctioning drive.";
centerTitle(newWindow, sHeader.c_str());
uint16_t u16Line = 2;
mvwaddstr(newWindow, u16Line++, 3, sLine01.c_str());
u16Line++;
mvwaddstr(newWindow, u16Line++, 3, sLinePath.c_str());
mvwaddstr(newWindow, u16Line++, 3, sLineModelFamily.c_str());
mvwaddstr(newWindow, u16Line++, 3, sLineModelName.c_str());
mvwaddstr(newWindow, u16Line++, 3, sLineSerial.c_str());
u16Line++;
mvwaddstr(newWindow, u16Line++, 3, sLine02.c_str());
mvwaddstr(newWindow, u16Line++, 3, sLine03.c_str());
mvwaddstr(newWindow, u16Line++, 3, sShredChecksum.c_str());
return newWindow;
}
string TUI::formatTimeDuration(time_t u32Duration)
{
std::ostringstream out;
int dy = (int)((u32Duration) / 86400);
int hr = (int)(((u32Duration) / 3600) % 24);
int min = ((int)((u32Duration) / 60)) % 60;
int sec = (int)((u32Duration) % 60);
char s[25];
sprintf(s, "%02d:%02d:%02d:%02d", dy, hr, min, sec);
out << s;
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 +463,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 +474,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 +529,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