440 lines
15 KiB
C++
440 lines
15 KiB
C++
/**
|
||
* @file reHDD.cpp
|
||
* @brief app logic
|
||
* @author hendrik schutter
|
||
* @date 01.05.2020
|
||
*/
|
||
|
||
#include "../include/reHDD.h"
|
||
|
||
|
||
static int fdSearchDrives[2];//File descriptor for pipe that informs if new drives are found
|
||
|
||
static int fdUserInput[2];//File descriptor for pipe that informs if a user input occoures
|
||
|
||
static int fdWhipe[2];//File descriptor for pipe that informs if a wipe thread signals
|
||
|
||
static std::mutex mxScannDrives;
|
||
|
||
static vector <Drive> vecNewDrives; //store found drives that are updated every 5sec
|
||
|
||
static vector <Drive> vecDrives; //stores all drive data from scann thread
|
||
|
||
TUI *ui;
|
||
|
||
static int32_t i32SelectedEntry;
|
||
|
||
static fd_set selectSet;
|
||
|
||
static struct TUI::MenuState menustate;
|
||
|
||
/**
|
||
* \brief app constructor
|
||
* \param void
|
||
* \return instance of App
|
||
*/
|
||
reHDD::reHDD(void)
|
||
{
|
||
cout << "created app" << endl;
|
||
i32SelectedEntry = 0;
|
||
}
|
||
|
||
/**
|
||
* \brief app logic
|
||
* \param void
|
||
* \return void
|
||
*/
|
||
void reHDD::app_logic(void)
|
||
{
|
||
cout << "app logic" << endl;
|
||
ui = new TUI();
|
||
ui->initTUI();
|
||
|
||
pipe(fdSearchDrives);
|
||
pipe(fdWhipe);
|
||
|
||
FD_ZERO(&selectSet);
|
||
FD_SET(fdSearchDrives[0], &selectSet);
|
||
FD_SET(fdWhipe[0], &selectSet);
|
||
|
||
thread thDevices(ThreadScannDevices); //start thread that scanns for drives
|
||
thread thUserInput(ThreadUserInput); //start thread that reads user input
|
||
|
||
while(1)
|
||
{
|
||
select(FD_SETSIZE, &selectSet, NULL, NULL, NULL);
|
||
|
||
if( FD_ISSET(fdSearchDrives[0], &selectSet))
|
||
{
|
||
char dummy;
|
||
read (fdSearchDrives[0],&dummy,1);
|
||
mxScannDrives.lock();
|
||
|
||
filterNewDrives(&vecDrives, &vecNewDrives); //filter and copy to app logic vector
|
||
mxScannDrives.unlock();
|
||
//printDrives(&vecDrives);
|
||
//TODO update UI
|
||
|
||
ui->updateTUI(&vecDrives, i32SelectedEntry, menustate);
|
||
}
|
||
else if (FD_ISSET(fdWhipe[0], &selectSet))
|
||
{
|
||
cout << "Whipe signal" << endl;
|
||
//update percantage & state
|
||
//update ui
|
||
}
|
||
} //endless loop
|
||
thDevices.join();
|
||
thUserInput.join();
|
||
}
|
||
|
||
void reHDD::ThreadScannDevices()
|
||
{
|
||
while(true)
|
||
{
|
||
// cout << "Thread" << endl;
|
||
mxScannDrives.lock();
|
||
vecNewDrives.clear();
|
||
searchDrives(&vecNewDrives); //search for new drives and store them in list
|
||
filterIgnoredDrives(&vecNewDrives); //filter out ignored drives
|
||
addSMARTData(&vecNewDrives); //add S.M.A.R.T. Data to the drives
|
||
mxScannDrives.unlock();
|
||
write (fdSearchDrives[1], "A",1);
|
||
sleep(5); //sleep 5 sec
|
||
}
|
||
}
|
||
|
||
void reHDD::ThreadUserInput()
|
||
{
|
||
while(true)
|
||
{
|
||
// cout << TUI::readUserInput() << endl;
|
||
switch (TUI::readUserInput())
|
||
{
|
||
case TUI::UserInput::DownKey:
|
||
//cout << "Down" << endl;
|
||
handleArrowKey(TUI::UserInput::DownKey);
|
||
ui->updateTUI(&vecDrives, i32SelectedEntry, menustate);
|
||
break;
|
||
case TUI::UserInput::UpKey:
|
||
//cout << "Up" << endl;
|
||
handleArrowKey(TUI::UserInput::UpKey);
|
||
ui->updateTUI(&vecDrives, i32SelectedEntry, menustate);
|
||
break;
|
||
case TUI::UserInput::Undefined:
|
||
//cout << "Undefined" << endl;
|
||
break;
|
||
case TUI::UserInput::Abort:
|
||
//cout << "Abort" << endl;
|
||
|
||
handleAbort();
|
||
|
||
break;
|
||
case TUI::UserInput::Delete:
|
||
//cout << "Delete" << endl;
|
||
|
||
if(SELECTED_DRIVE.state == Drive::NONE)
|
||
{
|
||
|
||
SELECTED_DRIVE.state = Drive::DELETE_SELECTED;
|
||
}
|
||
|
||
break;
|
||
case TUI::UserInput::Shred:
|
||
//cout << "Shred" << endl;
|
||
|
||
if(SELECTED_DRIVE.state == Drive::NONE)
|
||
{
|
||
|
||
SELECTED_DRIVE.state = Drive::SHRED_SELECTED;
|
||
}
|
||
|
||
break;
|
||
case TUI::UserInput::Enter:
|
||
//cout << "Enter" << endl;
|
||
handleEnter();
|
||
break;
|
||
case TUI::UserInput::ESC:
|
||
//cout << "ESC" << endl;
|
||
break;
|
||
default:
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
void reHDD::filterNewDrives(vector <Drive>* pvecOldDrives, vector <Drive>* pvecNewDrives)
|
||
{
|
||
|
||
vector <Drive>::iterator itOld; //Iterator for current (old) drive list
|
||
vector <Drive>::iterator itNew; //Iterator for new drive list that was created from to scann thread
|
||
|
||
for (itOld = pvecOldDrives->begin(); itOld != pvecOldDrives->end(); ++itOld)
|
||
{
|
||
bool bOldDriveIsOffline = true;
|
||
for (itNew = pvecNewDrives->begin(); itNew != pvecNewDrives->end(); ++itNew)
|
||
{
|
||
if(itOld->getSerial() == itNew->getSerial())
|
||
{
|
||
bOldDriveIsOffline = false;
|
||
// cout << "already online drive found: " << itOld->getPath() << endl;
|
||
itNew->state = itOld->state;
|
||
itNew->setTaskPercentage(itOld->getTaskPercentage());
|
||
}
|
||
}
|
||
|
||
if(bOldDriveIsOffline == true)
|
||
{
|
||
//cout << "offline drive found: " << itOld->getPath() << endl;
|
||
//TODO kill task thread if running
|
||
}
|
||
}
|
||
|
||
pvecOldDrives->clear();
|
||
for (long unsigned int i=0; i<pvecNewDrives->size(); i++)
|
||
{
|
||
pvecOldDrives->push_back((*pvecNewDrives)[i]);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* \brief search attached drives on /dev/sd*
|
||
* \param pointer of vector <Drive>* pvecDrives
|
||
* \return void
|
||
*/
|
||
void reHDD::searchDrives(vector <Drive>* pvecDrives)
|
||
{
|
||
// cout << "search drives ..." << endl;
|
||
char * cLine = NULL;
|
||
size_t len = 0;
|
||
|
||
FILE* outputfileHwinfo = popen("hwinfo --short --disk", "r");
|
||
|
||
if (outputfileHwinfo == NULL)
|
||
{
|
||
exit(EXIT_FAILURE);
|
||
}
|
||
|
||
while ((getline(&cLine, &len, outputfileHwinfo)) != -1)
|
||
{
|
||
if (string(cLine).find("/dev/sd") != string::npos)
|
||
{
|
||
Drive* tmpDrive = new Drive(string(cLine).substr (2,8));
|
||
pvecDrives->push_back(*tmpDrive);
|
||
}
|
||
}
|
||
fclose(outputfileHwinfo);
|
||
}
|
||
|
||
/**
|
||
* \brief filter out drives that are listed in "ignoreDrives.conf"
|
||
* \param pointer of vector <Drive>* pvecDrives
|
||
* \return void
|
||
*/
|
||
void reHDD::filterIgnoredDrives(vector <Drive>* pvecDrives)
|
||
{
|
||
string sDelimiter = ":";
|
||
string sIgnoredDrivePath;
|
||
string sIgnoredDriveUUID;
|
||
|
||
vector<tuple<string, string>> vtlIgnoredDevices; //store drives from ingnore file
|
||
|
||
//vector <Drive> vecTmpDrives
|
||
|
||
ifstream input( "ignoreDrives.conf" ); //read ingnore file
|
||
|
||
for(string sLine; getline( input, sLine );)
|
||
{
|
||
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());
|
||
sIgnoredDriveUUID = sLine;
|
||
} //end while
|
||
//cout << "Path: " << sIgnoredDrivePath << std::endl;
|
||
//cout << "UUID: " << sIgnoredDriveUUID << std::endl;
|
||
vtlIgnoredDevices.emplace_back(sIgnoredDrivePath, sIgnoredDriveUUID); //add found path and uuid from ingnore file to vector
|
||
}
|
||
}
|
||
//loop through found entries in ingnore file
|
||
for(auto row : vtlIgnoredDevices)
|
||
{
|
||
vector <Drive>::iterator it;
|
||
for (it = pvecDrives->begin(); it != pvecDrives->end(); ++it)
|
||
{
|
||
string sUUID;
|
||
if (!get<0>(row).compare(it->getPath())) //find same drive based on path
|
||
{
|
||
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;
|
||
}
|
||
}
|
||
fclose(outputfileBlkid);
|
||
//cout << "blkid uuid:" << sUUID << endl;
|
||
|
||
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;
|
||
exit(EXIT_FAILURE); // exit to prevent accidentally shred a system drive
|
||
}
|
||
else
|
||
{
|
||
// same uuid found than in ignore file --> ignore this drive
|
||
it = pvecDrives->erase(it);
|
||
it--;
|
||
//cout << "same uuid found than in ignore file --> ignore this drive:" << it->getPath() << endl;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
/**
|
||
* \brief print drives with all information
|
||
* \param pointer of vector <Drive>* pvecDrives
|
||
* \return void
|
||
*/
|
||
void reHDD::printDrives(vector <Drive>* pvecDrives)
|
||
{
|
||
cout << "------------DRIVES---------------" << endl;
|
||
vector <Drive>::iterator it;
|
||
for (it = pvecDrives->begin(); it != pvecDrives->end(); ++it)
|
||
{
|
||
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;
|
||
}
|
||
cout << "---------------------------------" << endl;
|
||
}
|
||
|
||
/**
|
||
* \brief add S.M.A.R.T data from SMART
|
||
* \param pointer of vector <Drive>* pvecDrives
|
||
* \return void
|
||
*/
|
||
void reHDD::addSMARTData(vector <Drive>* pvecDrives)
|
||
{
|
||
vector <Drive>::iterator it;
|
||
for (it = pvecDrives->begin(); it != pvecDrives->end(); ++it)
|
||
{
|
||
Drive* pTmpDrive = iterator_to_pointer<Drive, std::vector<Drive>::iterator > (it);
|
||
SMART::readSMARTData(pTmpDrive);
|
||
}
|
||
}
|
||
|
||
void reHDD::handleArrowKey(TUI::UserInput userInput)
|
||
{
|
||
int32_t i32EntrySize = (int32_t) vecDrives.size();
|
||
switch (userInput)
|
||
{
|
||
case TUI::UserInput::DownKey:
|
||
i32SelectedEntry++;
|
||
if(i32SelectedEntry >= i32EntrySize)
|
||
{
|
||
i32SelectedEntry = 0;
|
||
}
|
||
break;
|
||
case TUI::UserInput::UpKey:
|
||
i32SelectedEntry--;
|
||
if(i32SelectedEntry < 0)
|
||
{
|
||
i32SelectedEntry = (i32EntrySize-1);
|
||
}
|
||
break;
|
||
default:
|
||
i32SelectedEntry = 0;
|
||
break;
|
||
}
|
||
|
||
|
||
if(SELECTED_DRIVE.state == Drive::TaskState::SHRED_ACTIVE || SELECTED_DRIVE.state == Drive::TaskState::DELETE_ACTIVE)
|
||
{
|
||
//task for drive is running --> don´t show more task options
|
||
menustate.bAbort = true; //activate abort
|
||
menustate.bConfirmAbort = false;
|
||
menustate.bDelete = false;
|
||
menustate.bShred = false;
|
||
menustate.bConfirmDelete = false;
|
||
menustate.bConfirmShred = false;
|
||
|
||
}
|
||
else
|
||
{
|
||
//no task for drive is running --> show more task options
|
||
menustate.bAbort = false; //deactivate abort
|
||
menustate.bConfirmAbort = false;
|
||
menustate.bDelete = true;
|
||
menustate.bShred = true;
|
||
menustate.bConfirmDelete = false;
|
||
menustate.bConfirmShred = false;
|
||
|
||
}
|
||
}
|
||
|
||
void reHDD::handleEnter()
|
||
{
|
||
if(SELECTED_DRIVE.state == Drive::TaskState::SHRED_SELECTED)
|
||
{
|
||
SELECTED_DRIVE.state = Drive::TaskState::SHRED_ACTIVE;
|
||
//TODO start shredding
|
||
}
|
||
|
||
if(SELECTED_DRIVE.state == Drive::TaskState::DELETE_SELECTED)
|
||
{
|
||
SELECTED_DRIVE.state = Drive::TaskState::DELETE_ACTIVE;
|
||
//TODO start deleting
|
||
}
|
||
}
|
||
|
||
|
||
void reHDD::handleESC()
|
||
{
|
||
if(SELECTED_DRIVE.state == Drive::TaskState::SHRED_SELECTED)
|
||
{
|
||
SELECTED_DRIVE.state = Drive::TaskState::NONE;
|
||
}
|
||
|
||
if(SELECTED_DRIVE.state == Drive::TaskState::DELETE_SELECTED)
|
||
{
|
||
SELECTED_DRIVE.state = Drive::TaskState::NONE;
|
||
}
|
||
}
|
||
|
||
void reHDD::handleAbort()
|
||
{
|
||
if(SELECTED_DRIVE.state == Drive::SHRED_ACTIVE || SELECTED_DRIVE.state == Drive::DELETE_ACTIVE )
|
||
{
|
||
// TODO cancle shred or delete
|
||
SELECTED_DRIVE.state = Drive::NONE;
|
||
}
|
||
} |