/**
* Load image from a file
*/
bool Image::load_file(std::string infile) {
// Identify the image format
char header[5];
std::ifstream istream;
istream.open(infile, std::ios::binary|std::ios::in);
istream.read((char *)&header, 4);
istream.close();
if (identify_format(header, this->file_format, this->file_extension) < 0) {
std::cout << "Cannot identify image format" << std::endl;
return false;
}
// Open and resize the image with OpenCV
src = cv::imread(infile);
if (!src.data) {
std::cout << "Unable to read in the image" << std::endl;
return false;
}
return true;
}
//
// Loads a file of known hashes.
// First identifies the file type, then reads the file.
//
hashlist::loadstatus_t
hashlist::load_hash_file(display *ocb,const std::string &fn)
{
loadstatus_t status = loadstatus_ok;
hashfile_format type;
FILE *hl_handle = fopen(fn.c_str(),"rb");
if (NULL == hl_handle)
{
if (ocb)
ocb->error("%s: %s", fn.c_str(), strerror(errno));
return status_file_error;
}
type = identify_format(ocb,fn,hl_handle);
if (file_unknown == type)
{
if (ocb)
ocb->error("%s: Unable to identify file format", fn.c_str());
fclose(hl_handle);
hl_handle = 0;
return status_unknown_filetype;
}
bool contains_bad_lines = false;
bool record_valid;
// We start our counter at line number two for the two lines
// of header we've already read
uint64_t line_number = 2;
// TODO: Read the line directly into a std::string
char line[MAX_STRING_LENGTH];
while (fgets(line,MAX_STRING_LENGTH,hl_handle))
{
line_number++;
// Lines starting with a pound sign are comments and can be ignored
if ('#' == line[0])
continue;
// C++ typically fails with a bad_alloc, but you can make it return null
// http://www.cplusplus.com/reference/std/new/bad_alloc/
// http://www.cplusplus.com/reference/std/new/nothrow/
file_data_t *t = new (std::nothrow) file_data_t();
if (NULL == t)
{
ocb->fatal_error("%s: Out of memory in line %"PRIu64,
fn.c_str(), line_number);
}
chop_line(line);
record_valid = true;
// Convert the input line to a string for easier manipulations
std::string line_as_string(line);
std::vector<std::string> fields = split(line_as_string,',');
size_t column_number;
for (column_number=0 ; column_number<fields.size() ; column_number++)
{
std::string word = fields[column_number];
// The first column should always be the file size
if (0 == column_number)
{
t->file_bytes = (uint64_t)strtoll(word.c_str(),NULL,10);
continue;
}
if (column_number == filename_column)
{
// If the filename contained commas, it was split
// incorrectly by the 'split' statememt above. The filename
// will be split across more than one column.
// As such we need to 'find' everything
// in the string starting with the current location.
// The result should be closer to the end of the string than
// the start, so we can use rfind. (This also avoids a problem
// when the filename is the same as one of the hashes, which
// happens now and again.)
size_t start = line_as_string.rfind(word);
t->file_name = line_as_string.substr(start,std::string::npos);
// This should be the last column, so we break out now.
break;
}
// All other columns should contain a valid hash in hex
if ( !algorithm_t::valid_hash(hash_column[column_number],word))
{
if (ocb)
ocb->error("%s: Invalid %s hash in line %"PRIu64,
fn.c_str(),
hashes[hash_column[column_number]].name.c_str(),
line_number);
contains_bad_lines = true;
record_valid = false;
// Break out (done = true) and then process the next line
break;
}
// Convert the hash to a std::string and save it
lowercase(word);
t->hash_hex[hash_column[column_number]] = word;
}
if (record_valid)
add_fdt(t);
}
fclose(hl_handle);
hl_handle = 0;
if (contains_bad_lines)
return status_contains_bad_hashes;
return status;
}
