2020-05-01 18:31:02 +02:00
/**
2020-05-02 22:06:47 +02:00
* @ file reHDD . cpp
* @ brief app logic
* @ author hendrik schutter
* @ date 01.05 .2020
2020-05-01 18:31:02 +02:00
*/
2020-05-02 22:06:47 +02:00
# include "../include/reHDD.h"
2020-05-01 18:31:02 +02:00
2020-08-23 09:26:32 +02:00
static int fdNewDrivesInformPipe [ 2 ] ; //File descriptor for pipe that informs if new drives are found
2020-08-04 11:59:45 +02:00
2020-08-23 09:26:32 +02:00
static int fdShredInformPipe [ 2 ] ; //File descriptor for pipe that informs if a wipe thread signals
2020-08-04 22:35:29 +02:00
2020-08-04 11:59:45 +02:00
static std : : mutex mxScannDrives ;
2020-09-16 15:13:32 +02:00
list < Drive > listNewDrives ; //store found drives that are updated every 5sec
2020-08-04 11:59:45 +02:00
2020-09-16 15:13:32 +02:00
static list < Drive > listDrives ; //stores all drive data from scann thread
2020-08-07 11:38:00 +02:00
TUI * ui ;
2020-08-26 18:38:39 +02:00
static uint8_t u8SelectedEntry ;
2020-08-04 11:59:45 +02:00
static fd_set selectSet ;
2020-08-03 22:40:07 +02:00
2020-05-01 18:31:02 +02:00
/**
* \ brief app constructor
2020-05-02 17:15:55 +02:00
* \ param void
2020-05-01 18:31:02 +02:00
* \ return instance of App
*/
2020-05-02 22:06:47 +02:00
reHDD : : reHDD ( void )
2020-05-02 17:15:55 +02:00
{
2020-08-26 18:38:39 +02:00
u8SelectedEntry = 0U ;
2020-05-01 18:31:02 +02:00
}
/**
* \ brief app logic
2020-05-02 17:15:55 +02:00
* \ param void
2020-05-01 18:31:02 +02:00
* \ return void
*/
2020-05-02 22:06:47 +02:00
void reHDD : : app_logic ( void )
2020-05-01 18:31:02 +02:00
{
2020-08-04 22:35:29 +02:00
ui = new TUI ( ) ;
ui - > initTUI ( ) ;
2020-08-03 22:40:07 +02:00
2020-08-23 09:26:32 +02:00
pipe ( fdNewDrivesInformPipe ) ;
pipe ( fdShredInformPipe ) ;
2020-08-04 17:18:32 +02:00
thread thDevices ( ThreadScannDevices ) ; //start thread that scanns for drives
2020-08-06 22:45:05 +02:00
thread thUserInput ( ThreadUserInput ) ; //start thread that reads user input
2020-09-11 17:18:53 +02:00
thread thCheckFrozenDrives ( ThreadCheckFrozenDrives ) ; //start thread that checks timeout for drives
2020-08-03 22:40:07 +02:00
2020-08-07 11:38:00 +02:00
while ( 1 )
{
2020-08-23 09:26:32 +02:00
FD_ZERO ( & selectSet ) ;
FD_SET ( fdNewDrivesInformPipe [ 0 ] , & selectSet ) ;
FD_SET ( fdShredInformPipe [ 0 ] , & selectSet ) ;
2020-08-07 11:38:00 +02:00
select ( FD_SETSIZE , & selectSet , NULL , NULL , NULL ) ;
2020-09-20 00:12:18 +02:00
if ( FD_ISSET ( fdNewDrivesInformPipe [ 0 ] , & selectSet ) )
2020-08-07 11:38:00 +02:00
{
2020-09-20 00:12:18 +02:00
mxScannDrives . lock ( ) ;
2020-08-07 11:38:00 +02:00
char dummy ;
2020-08-23 09:26:32 +02:00
read ( fdNewDrivesInformPipe [ 0 ] , & dummy , 1 ) ;
2020-09-21 21:47:29 +02:00
filterNewDrives ( & listDrives , & listNewDrives ) ; //filter and copy to app logic vector
printDrives ( & listDrives ) ;
2020-09-20 00:12:18 +02:00
mxScannDrives . unlock ( ) ;
2020-08-07 11:38:00 +02:00
}
2020-09-20 00:12:18 +02:00
if ( FD_ISSET ( fdShredInformPipe [ 0 ] , & selectSet ) )
2020-08-07 11:38:00 +02:00
{
2020-08-23 09:26:32 +02:00
char dummy ;
read ( fdShredInformPipe [ 0 ] , & dummy , 1 ) ;
2020-09-20 00:12:18 +02:00
# ifdef LOG_LEVEL_HIGH
Logger : : logThis ( ) - > info ( " got progress signal from a shred task " ) ;
# endif
2020-08-07 11:38:00 +02:00
}
2020-09-21 21:47:29 +02:00
ui - > updateTUI ( & listDrives , u8SelectedEntry ) ;
2020-08-07 11:38:00 +02:00
} //endless loop
2020-08-04 22:35:29 +02:00
thDevices . join ( ) ;
2020-08-06 22:45:05 +02:00
thUserInput . join ( ) ;
2020-09-11 17:18:53 +02:00
thCheckFrozenDrives . join ( ) ;
2020-08-03 22:40:07 +02:00
}
2020-08-26 18:38:39 +02:00
Drive * reHDD : : getSelectedDrive ( )
{
2020-09-16 15:13:32 +02:00
if ( u8SelectedEntry < listDrives . size ( ) )
2020-08-26 18:38:39 +02:00
{
2020-09-16 15:13:32 +02:00
list < Drive > : : iterator it = listDrives . begin ( ) ;
advance ( it , u8SelectedEntry ) ;
2020-09-16 15:27:25 +02:00
return & ( * it ) ;
2020-08-26 18:38:39 +02:00
}
else
{
2020-09-07 17:23:15 +02:00
Logger : : logThis ( ) - > warning ( " selected drive not present " ) ;
2020-08-26 18:38:39 +02:00
return { } ;
}
}
2020-08-07 11:38:00 +02:00
void reHDD : : ThreadScannDevices ( )
{
while ( true )
{
mxScannDrives . lock ( ) ;
2020-09-16 15:13:32 +02:00
listNewDrives . clear ( ) ;
searchDrives ( & listNewDrives ) ; //search for new drives and store them in list
filterIgnoredDrives ( & listNewDrives ) ; //filter out ignored drives
addSMARTData ( & listNewDrives ) ; //add S.M.A.R.T. Data to the drives
2020-08-07 11:38:00 +02:00
mxScannDrives . unlock ( ) ;
2020-08-23 09:26:32 +02:00
write ( fdNewDrivesInformPipe [ 1 ] , " A " , 1 ) ;
2020-08-07 11:38:00 +02:00
sleep ( 5 ) ; //sleep 5 sec
}
2020-08-04 17:18:32 +02:00
}
2020-08-03 22:40:07 +02:00
2020-09-11 17:18:53 +02:00
void reHDD : : ThreadCheckFrozenDrives ( )
{
while ( true )
{
mxScannDrives . lock ( ) ;
2020-09-16 15:13:32 +02:00
for ( auto it = begin ( listDrives ) ; it ! = end ( listDrives ) ; + + it )
2020-09-11 17:18:53 +02:00
{
if ( it - > state = = Drive : : SHRED_ACTIVE )
{
it - > checkFrozenDrive ( ) ;
}
}
mxScannDrives . unlock ( ) ;
2020-09-20 00:12:18 +02:00
sleep ( 13 ) ; //sleep 13 sec
2020-09-11 17:18:53 +02:00
}
}
2020-08-07 11:38:00 +02:00
void reHDD : : ThreadUserInput ( )
{
while ( true )
2020-08-06 22:45:05 +02:00
{
2020-08-07 11:38:00 +02:00
// cout << TUI::readUserInput() << endl;
switch ( TUI : : readUserInput ( ) )
{
case TUI : : UserInput : : DownKey :
//cout << "Down" << endl;
handleArrowKey ( TUI : : UserInput : : DownKey ) ;
2020-09-16 15:13:32 +02:00
ui - > updateTUI ( & listDrives , u8SelectedEntry ) ;
2020-08-07 11:38:00 +02:00
break ;
case TUI : : UserInput : : UpKey :
//cout << "Up" << endl;
handleArrowKey ( TUI : : UserInput : : UpKey ) ;
2020-09-16 15:13:32 +02:00
ui - > updateTUI ( & listDrives , u8SelectedEntry ) ;
2020-08-07 11:38:00 +02:00
break ;
case TUI : : UserInput : : Undefined :
//cout << "Undefined" << endl;
break ;
case TUI : : UserInput : : Abort :
//cout << "Abort" << endl;
2020-08-09 21:41:28 +02:00
handleAbort ( ) ;
2020-09-16 15:13:32 +02:00
ui - > updateTUI ( & listDrives , u8SelectedEntry ) ;
2020-08-07 11:38:00 +02:00
break ;
case TUI : : UserInput : : Delete :
//cout << "Delete" << endl;
2020-08-26 18:38:39 +02:00
if ( getSelectedDrive ( ) ! = nullptr )
2020-08-09 21:41:28 +02:00
{
2020-08-26 18:38:39 +02:00
if ( getSelectedDrive ( ) - > state = = Drive : : NONE )
{
getSelectedDrive ( ) - > state = Drive : : DELETE_SELECTED ;
}
2020-08-09 21:41:28 +02:00
}
2020-09-16 15:13:32 +02:00
ui - > updateTUI ( & listDrives , u8SelectedEntry ) ;
2020-08-07 11:38:00 +02:00
break ;
case TUI : : UserInput : : Shred :
//cout << "Shred" << endl;
2020-08-26 18:38:39 +02:00
if ( getSelectedDrive ( ) ! = nullptr )
2020-08-09 21:41:28 +02:00
{
2020-08-26 18:38:39 +02:00
if ( getSelectedDrive ( ) - > state = = Drive : : NONE )
{
getSelectedDrive ( ) - > state = Drive : : SHRED_SELECTED ;
}
2020-08-09 21:41:28 +02:00
}
2020-09-16 15:13:32 +02:00
ui - > updateTUI ( & listDrives , u8SelectedEntry ) ;
2020-08-07 11:38:00 +02:00
break ;
case TUI : : UserInput : : Enter :
//cout << "Enter" << endl;
2020-08-09 21:41:28 +02:00
handleEnter ( ) ;
2020-09-16 15:13:32 +02:00
ui - > updateTUI ( & listDrives , u8SelectedEntry ) ;
2020-08-07 11:38:00 +02:00
break ;
case TUI : : UserInput : : ESC :
//cout << "ESC" << endl;
2020-08-09 23:05:32 +02:00
handleESC ( ) ;
2020-09-16 15:13:32 +02:00
ui - > updateTUI ( & listDrives , u8SelectedEntry ) ;
2020-08-07 11:38:00 +02:00
break ;
default :
break ;
}
2020-08-06 22:45:05 +02:00
}
}
2020-08-04 22:35:29 +02:00
2020-08-23 09:26:32 +02:00
void reHDD : : ThreadShred ( )
{
2020-08-26 18:38:39 +02:00
if ( getSelectedDrive ( ) ! = nullptr )
{
2020-09-08 13:01:09 +02:00
Shred * pShredTask = new Shred ( ) ; //create new shred task
pShredTask - > shredDrive ( getSelectedDrive ( ) , & fdShredInformPipe [ 1 ] ) ; //start new shred task
delete pShredTask ; //delete shred task
2020-09-16 15:13:32 +02:00
ui - > updateTUI ( & listDrives , u8SelectedEntry ) ;
2020-08-26 18:38:39 +02:00
}
2020-08-23 09:26:32 +02:00
}
2020-09-21 16:50:33 +02:00
void reHDD : : ThreadDelete ( )
{
if ( getSelectedDrive ( ) ! = nullptr )
{
Delete : : deleteDrive ( getSelectedDrive ( ) ) ; //blocking, no thread
getSelectedDrive ( ) - > state = Drive : : TaskState : : NONE ; //delete finished
getSelectedDrive ( ) - > bWasDeleteted = true ;
Logger : : logThis ( ) - > info ( " Finished delete for: " + getSelectedDrive ( ) - > getModelName ( ) + " - " + getSelectedDrive ( ) - > getSerial ( ) ) ;
2020-09-21 21:47:29 +02:00
ui - > updateTUI ( & listDrives , u8SelectedEntry ) ;
2020-09-21 16:50:33 +02:00
}
}
2020-09-21 21:47:29 +02:00
void reHDD : : filterNewDrives ( list < Drive > * plistOldDrives , list < Drive > * plistNewDrives )
2020-08-07 11:38:00 +02:00
{
2020-09-16 15:13:32 +02:00
list < Drive > : : iterator itOld ; //Iterator for current (old) drive list
list < Drive > : : iterator itNew ; //Iterator for new drive list that was created from to scann thread
2020-08-03 22:40:07 +02:00
2020-09-09 16:11:25 +02:00
//remove offline old drives from previously run
2020-09-16 15:13:32 +02:00
for ( itOld = plistOldDrives - > begin ( ) ; itOld ! = plistOldDrives - > end ( ) ; )
2020-09-09 16:11:25 +02:00
{
if ( itOld - > bIsOffline = = true )
{
Logger : : logThis ( ) - > warning ( " Offline drive found: " + itOld - > getPath ( ) ) ;
2020-09-16 15:13:32 +02:00
itOld = plistOldDrives - > erase ( itOld ) ;
2020-09-09 16:11:25 +02:00
/*
2020-09-16 15:13:32 +02:00
if ( plistOldDrives - > size ( ) > 0 ) { //This can be a risk if the user starts a task for the selected drive and the selected drive changes
2020-09-09 16:11:25 +02:00
u8SelectedEntry = 0U ;
}
*/
}
else
{
+ + itOld ;
}
}
//search offline drives and mark them
2020-09-16 15:13:32 +02:00
for ( itOld = plistOldDrives - > begin ( ) ; itOld ! = plistOldDrives - > end ( ) ; + + itOld )
2020-08-04 17:18:32 +02:00
{
2020-09-09 16:11:25 +02:00
itOld - > bIsOffline = true ; //set offline befor seachring in the new list
2020-09-16 15:13:32 +02:00
for ( itNew = plistNewDrives - > begin ( ) ; itNew ! = plistNewDrives - > end ( ) ; )
2020-08-07 11:38:00 +02:00
{
2020-09-15 11:11:53 +02:00
if ( ( itOld - > getSerial ( ) = = itNew - > getSerial ( ) ) | | ( itOld - > getPath ( ) = = itNew - > getPath ( ) ) )
2020-08-07 11:38:00 +02:00
{
2020-09-09 16:11:25 +02:00
itOld - > bIsOffline = false ; //drive is still attached
# ifdef LOG_LEVEL_HIGH
Logger : : logThis ( ) - > info ( " Delete new drive, because allready attached: " + itNew - > getModelName ( ) ) ;
# endif
2020-09-16 15:13:32 +02:00
itNew = plistNewDrives - > erase ( itNew ) ; //This drive is allready attached, remove from new list
2020-09-09 16:11:25 +02:00
}
else
{
+ + itNew ;
2020-08-07 11:38:00 +02:00
}
}
2020-09-09 16:11:25 +02:00
}
2020-05-01 18:31:02 +02:00
2020-09-09 16:11:25 +02:00
//mark offline old drives
2020-09-16 15:13:32 +02:00
for ( itOld = plistOldDrives - > begin ( ) ; itOld ! = plistOldDrives - > end ( ) ; + + itOld )
2020-09-09 16:11:25 +02:00
{
if ( itOld - > bIsOffline = = true )
2020-08-07 11:38:00 +02:00
{
//cout << "offline drive found: " << itOld->getPath() << endl;
2020-09-09 16:11:25 +02:00
Logger : : logThis ( ) - > warning ( " Mark offline drive found: " + itOld - > getPath ( ) ) ;
itOld - > state = Drive : : NONE ; //clear state --> shred task will terminate
2020-08-07 11:38:00 +02:00
}
2020-08-04 19:51:34 +02:00
}
2020-08-03 22:40:07 +02:00
2020-09-09 16:11:25 +02:00
//add new drives to drive list
2020-09-16 15:13:32 +02:00
for ( itNew = plistNewDrives - > begin ( ) ; itNew ! = plistNewDrives - > end ( ) ; + + itNew )
2020-08-07 11:38:00 +02:00
{
2020-09-16 15:13:32 +02:00
plistOldDrives - > push_back ( * itNew ) ;
2020-09-09 16:11:25 +02:00
Logger : : logThis ( ) - > info ( " Add new drive: " + itNew - > getModelName ( ) ) ;
2020-08-07 11:38:00 +02:00
}
2020-09-16 15:13:32 +02:00
plistNewDrives - > clear ( ) ;
2020-08-03 22:40:07 +02:00
}
2020-05-01 18:31:02 +02:00
/**
* \ brief search attached drives on / dev / sd *
2020-09-21 21:56:26 +02:00
* \ param pointer of list < Drive > * plistDrives
2020-05-01 18:31:02 +02:00
* \ return void
*/
2020-09-16 15:13:32 +02:00
void reHDD : : searchDrives ( list < Drive > * plistDrives )
2020-05-01 18:31:02 +02:00
{
2020-09-08 13:01:09 +02:00
Logger : : logThis ( ) - > info ( " --> search drives <-- " ) ;
2020-05-01 18:31:02 +02:00
char * cLine = NULL ;
size_t len = 0 ;
2022-01-26 15:15:34 +01:00
FILE * outputfileHwinfo = popen ( " lsblk -I 8 -d -o NAME " , " r " ) ;
2020-05-01 18:31:02 +02:00
if ( outputfileHwinfo = = NULL )
2020-08-07 11:38:00 +02:00
{
2022-01-26 13:52:21 +01:00
Logger : : logThis ( ) - > error ( " Unable to scan attached drives " ) ;
2020-08-07 11:38:00 +02:00
exit ( EXIT_FAILURE ) ;
}
2020-05-01 18:31:02 +02:00
while ( ( getline ( & cLine , & len , outputfileHwinfo ) ) ! = - 1 )
{
2022-01-26 15:15:34 +01:00
if ( string ( cLine ) . length ( ) = = 4 )
2020-08-07 11:38:00 +02:00
{
2022-01-26 15:15:34 +01:00
Drive * tmpDrive = new Drive ( " /dev/ " + string ( cLine ) . substr ( 0 , 3 ) ) ;
2020-08-26 15:07:53 +02:00
tmpDrive - > state = Drive : : NONE ;
2020-09-09 16:11:25 +02:00
tmpDrive - > bIsOffline = false ;
2020-09-16 15:13:32 +02:00
plistDrives - > push_back ( * tmpDrive ) ;
2022-01-26 15:44:32 +01:00
//Logger::logThis()->info("drive found: " + tmpDrive->getPath());
2020-08-07 11:38:00 +02:00
}
2020-05-01 18:31:02 +02:00
}
2022-01-26 15:44:32 +01:00
pclose ( outputfileHwinfo ) ;
2020-05-01 18:31:02 +02:00
}
/**
* \ brief filter out drives that are listed in " ignoreDrives.conf "
2020-09-21 21:56:26 +02:00
* \ param pointer of list < Drive > * plistDrives
2020-05-01 18:31:02 +02:00
* \ return void
*/
2020-09-16 15:13:32 +02:00
void reHDD : : filterIgnoredDrives ( list < Drive > * plistDrives )
2020-05-01 18:31:02 +02:00
{
2022-01-26 19:21:38 +01:00
//string sDelimiter = ":";
// string sIgnoredDrivePath;
2020-05-01 18:31:02 +02:00
string sIgnoredDriveUUID ;
2022-01-26 19:21:38 +01:00
list < tuple < string > > vtlIgnoredDevices ; //store drives from ingnore file
2020-05-01 18:31:02 +02:00
ifstream input ( " ignoreDrives.conf " ) ; //read ingnore file
for ( string sLine ; getline ( input , sLine ) ; )
{
2022-01-26 19:21:38 +01:00
// if (string(sLine).find("/dev/sd") != string::npos)
// {
//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());
2020-08-07 11:38:00 +02:00
sIgnoredDriveUUID = sLine ;
2022-01-26 19:21:38 +01:00
// } //end while
Logger : : logThis ( ) - > info ( " read uuid: " + sIgnoredDriveUUID ) ;
vtlIgnoredDevices . emplace_back ( sIgnoredDriveUUID ) ; //add found path and uuid from ignore file to vector
// }
2020-05-01 18:31:02 +02:00
}
//loop through found entries in ingnore file
for ( auto row : vtlIgnoredDevices )
{
2020-09-16 15:13:32 +02:00
list < Drive > : : iterator it ;
for ( it = plistDrives - > begin ( ) ; it ! = plistDrives - > end ( ) ; + + it )
2020-05-01 18:31:02 +02:00
{
2020-08-07 11:38:00 +02:00
string sUUID ;
2022-01-26 19:21:38 +01:00
//if (!get<0>(row).compare(it->getPath())) //find same drive based on path
// {
2020-08-07 11:38:00 +02:00
char * cLine = NULL ;
size_t len = 0 ;
string sCMD = " blkid " ;
sCMD . append ( it - > getPath ( ) ) ;
//cout << "cmd: " << sCMD << endl;
FILE * outputfileBlkid = popen ( sCMD . c_str ( ) , " r " ) ; //get UUID from drive
if ( outputfileBlkid = = NULL )
{
exit ( EXIT_FAILURE ) ;
}
while ( ( getline ( & cLine , & len , outputfileBlkid ) ) ! = - 1 ) //parse UUID from blkid
{
if ( string ( cLine ) . find ( " PTUUID " ) ! = string : : npos )
{
string sBlkidOut = string ( cLine ) ;
sBlkidOut . erase ( 0 , 18 ) ;
sBlkidOut . erase ( 36 , sBlkidOut . length ( ) - 36 ) ;
sUUID = sBlkidOut ;
//cout << "blkid uuid:" << sUUID << endl;
}
}
2022-01-26 15:44:32 +01:00
pclose ( outputfileBlkid ) ;
2020-08-07 11:38:00 +02:00
//cout << "blkid uuid:" << sUUID << endl;
2022-01-26 19:21:38 +01:00
if ( get < 0 > ( row ) . compare ( sUUID ) ) //compare uuid from ignore file and uuid from drive
2020-08-07 11:38:00 +02:00
{
2022-01-26 19:21:38 +01:00
//cout << "[ERROR] different uuid found than in ignore file:" << it->getPath() << endl;
//Logger::logThis()->error("different uuid found than in ignore file: " + it->getPath() + " uuid from drive: " + sUUID);
//exit(EXIT_FAILURE); // exit to prevent accidentally shred a system drive
2020-08-07 11:38:00 +02:00
}
else
{
// same uuid found than in ignore file --> ignore this drive
2020-09-08 13:01:09 +02:00
# ifdef LOG_LEVEL_HIGH
2020-09-07 17:23:15 +02:00
Logger : : logThis ( ) - > info ( " same uuid found than in ignore file --> ignore this drive: " + it - > getPath ( ) ) ;
2020-09-08 13:01:09 +02:00
# endif
2020-09-16 15:13:32 +02:00
it = plistDrives - > erase ( it ) ;
2020-08-07 11:38:00 +02:00
it - - ;
}
2022-01-26 19:21:38 +01:00
// }
2020-05-01 18:31:02 +02:00
}
}
}
/**
* \ brief print drives with all information
2020-09-21 21:56:26 +02:00
* \ param pointer of list < Drive > * plistDrives
2020-05-01 18:31:02 +02:00
* \ return void
*/
2020-09-16 15:13:32 +02:00
void reHDD : : printDrives ( list < Drive > * plistDrives )
2020-05-01 18:31:02 +02:00
{
2020-09-08 13:01:09 +02:00
# ifdef LOG_LEVEL_HIGH
2020-09-20 00:12:18 +02:00
Logger : : logThis ( ) - > info ( " ------------DRIVES START------------ " ) ;
2020-09-08 13:01:09 +02:00
//cout << "------------DRIVES---------------" << endl;
2020-09-16 15:13:32 +02:00
list < Drive > : : iterator it ;
uint8_t u8Index = 0 ;
for ( it = plistDrives - > begin ( ) ; it ! = plistDrives - > end ( ) ; + + it )
2020-08-07 11:38:00 +02:00
{
2020-09-08 13:01:09 +02:00
/*
cout < < " Drive: " < < distance ( pvecDrives - > begin ( ) , it ) < < endl ;
cout < < " Path: " < < it - > getPath ( ) < < endl ;
cout < < " ModelFamily: " < < it - > getModelFamily ( ) < < endl ;
cout < < " ModelName: " < < it - > getModelName ( ) < < endl ;
cout < < " Capacity: " < < it - > getCapacity ( ) < < endl ;
cout < < " Serial: " < < it - > getSerial ( ) < < endl ;
cout < < " PowerOnHours: " < < it - > getPowerOnHours ( ) < < endl ;
cout < < " PowerCycle: " < < it - > getPowerCycles ( ) < < endl ;
cout < < " ErrorCount: " < < it - > getErrorCount ( ) < < endl ;
cout < < endl ; */
2020-09-09 16:11:25 +02:00
ostringstream address ;
2020-09-21 21:47:29 +02:00
address < < ( void const * ) & ( * it ) ;
Logger : : logThis ( ) - > info ( to_string ( u8Index + + ) + " : " + it - > getPath ( ) + " - " + it - > getModelFamily ( ) + " - " + it - > getSerial ( ) + " @ " + address . str ( ) ) ;
2020-08-07 11:38:00 +02:00
}
2020-09-20 00:12:18 +02:00
Logger : : logThis ( ) - > info ( " ------------DRIVES END-------------- " ) ;
2020-09-08 13:01:09 +02:00
//cout << "---------------------------------" << endl;
# endif
2020-05-01 18:31:02 +02:00
}
2020-05-02 00:49:11 +02:00
2020-05-02 17:15:55 +02:00
/**
* \ brief add S . M . A . R . T data from SMART
2020-09-21 21:56:26 +02:00
* \ param pointer of list < Drive > * plistDrives
2020-05-02 17:15:55 +02:00
* \ return void
*/
2020-09-16 15:13:32 +02:00
void reHDD : : addSMARTData ( list < Drive > * plistDrives )
2020-05-02 17:15:55 +02:00
{
2020-09-16 15:13:32 +02:00
list < Drive > : : iterator it ;
for ( it = plistDrives - > begin ( ) ; it ! = plistDrives - > end ( ) ; + + it )
2020-08-07 11:38:00 +02:00
{
2020-09-16 15:13:32 +02:00
Drive * pTmpDrive = iterator_to_pointer < Drive , std : : list < Drive > : : iterator > ( it ) ;
2020-08-07 11:38:00 +02:00
SMART : : readSMARTData ( pTmpDrive ) ;
}
}
void reHDD : : handleArrowKey ( TUI : : UserInput userInput )
{
2020-09-16 15:13:32 +02:00
int8_t u8EntrySize = ( int8_t ) listDrives . size ( ) ;
2020-08-07 11:38:00 +02:00
switch ( userInput )
{
case TUI : : UserInput : : DownKey :
2020-08-26 18:38:39 +02:00
u8SelectedEntry + + ;
if ( u8SelectedEntry > = u8EntrySize )
2020-08-07 11:38:00 +02:00
{
2020-08-26 18:38:39 +02:00
u8SelectedEntry = 0 ;
2020-08-07 11:38:00 +02:00
}
break ;
case TUI : : UserInput : : UpKey :
2020-08-26 18:38:39 +02:00
if ( u8SelectedEntry = = 0 )
2020-08-07 11:38:00 +02:00
{
2020-08-26 18:38:39 +02:00
u8SelectedEntry = ( u8EntrySize - 1 ) ;
}
else
{
u8SelectedEntry - - ;
2020-08-07 11:38:00 +02:00
}
break ;
default :
2020-08-26 18:38:39 +02:00
u8SelectedEntry = 0 ;
2020-08-07 11:38:00 +02:00
break ;
}
2020-09-07 17:23:15 +02:00
2020-09-08 13:01:09 +02:00
Logger : : logThis ( ) - > info ( " ArrowKey - selected drive: " + to_string ( u8SelectedEntry ) ) ;
2020-08-09 21:41:28 +02:00
}
void reHDD : : handleEnter ( )
{
2020-08-26 18:38:39 +02:00
if ( getSelectedDrive ( ) ! = nullptr )
2020-08-09 21:41:28 +02:00
{
2020-08-26 18:38:39 +02:00
if ( getSelectedDrive ( ) - > state = = Drive : : TaskState : : SHRED_SELECTED )
{
2020-09-07 17:23:15 +02:00
Logger : : logThis ( ) - > info ( " Started shred for: " + getSelectedDrive ( ) - > getModelName ( ) + " - " + getSelectedDrive ( ) - > getSerial ( ) ) ;
2020-08-26 18:38:39 +02:00
getSelectedDrive ( ) - > state = Drive : : TaskState : : SHRED_ACTIVE ;
//task for drive is running --> don´ t show more task options
thread ( ThreadShred ) . detach ( ) ;
}
2020-08-09 21:41:28 +02:00
2020-08-26 18:38:39 +02:00
if ( getSelectedDrive ( ) - > state = = Drive : : TaskState : : DELETE_SELECTED )
{
2020-09-07 17:23:15 +02:00
Logger : : logThis ( ) - > info ( " Started delete for: " + getSelectedDrive ( ) - > getModelName ( ) + " - " + getSelectedDrive ( ) - > getSerial ( ) ) ;
2020-08-26 18:38:39 +02:00
getSelectedDrive ( ) - > state = Drive : : TaskState : : DELETE_ACTIVE ;
//task for drive is running --> don´ t show more task options
2020-09-21 16:50:33 +02:00
thread ( ThreadDelete ) . detach ( ) ;
2020-08-26 18:38:39 +02:00
}
2020-08-09 21:41:28 +02:00
}
}
void reHDD : : handleESC ( )
{
2020-08-26 18:38:39 +02:00
if ( getSelectedDrive ( ) ! = nullptr )
2020-08-09 21:41:28 +02:00
{
2020-08-26 18:38:39 +02:00
if ( getSelectedDrive ( ) - > state = = Drive : : TaskState : : SHRED_SELECTED )
{
getSelectedDrive ( ) - > state = Drive : : TaskState : : NONE ;
//task for drive is selected --> remove selection
}
2020-08-09 21:41:28 +02:00
2020-08-26 18:38:39 +02:00
if ( getSelectedDrive ( ) - > state = = Drive : : TaskState : : DELETE_SELECTED )
{
getSelectedDrive ( ) - > state = Drive : : TaskState : : NONE ;
//task for drive is selected --> remove selection
}
2020-08-09 21:41:28 +02:00
}
}
void reHDD : : handleAbort ( )
{
2020-08-26 18:38:39 +02:00
if ( getSelectedDrive ( ) ! = nullptr )
2020-08-09 21:41:28 +02:00
{
2020-08-26 18:38:39 +02:00
if ( getSelectedDrive ( ) - > state = = Drive : : SHRED_ACTIVE | | getSelectedDrive ( ) - > state = = Drive : : DELETE_ACTIVE )
{
getSelectedDrive ( ) - > state = Drive : : NONE ;
2020-09-09 16:11:25 +02:00
Logger : : logThis ( ) - > info ( " Abort-Shred-Signal for: " + getSelectedDrive ( ) - > getModelName ( ) + " - " + getSelectedDrive ( ) - > getSerial ( ) ) ;
2020-08-26 18:38:39 +02:00
//task for drive is running --> remove selection
}
2020-08-09 21:41:28 +02:00
}
2020-08-23 09:26:32 +02:00
}
2020-08-30 12:03:37 +02:00
2020-08-26 00:12:39 +02:00