/*
Traverse the hierarchy inside the container
*/
void TskL01Extract::traverse(ewf::libewf_file_entry_t *parent)
{
static Poco::Path currPath;
TskL01Extract::ArchivedFile fileInfo;
fileInfo.entry = parent;
fileInfo.type = getFileType(parent);
fileInfo.size = getFileSize(parent);
fileInfo.ctime = getEntryChangeTime(parent);
fileInfo.crtime = getCreationTime(parent);
fileInfo.atime = getAccessTime(parent);
fileInfo.mtime = getModifiedTime(parent);
std::string name = getName(parent);
bool saveDirectory = false;
if ((fileInfo.type == 'd') && !name.empty())
{
saveDirectory = true;
}
if (saveDirectory)
{
currPath.pushDirectory(name);
fileInfo.path = currPath;
m_archivedFiles.push_back(fileInfo);
}
else if (fileInfo.type == 'f')
{
Poco::Path tempPath = currPath;
tempPath.setFileName(name);
fileInfo.path = tempPath;
m_archivedFiles.push_back(fileInfo);
}
int num = 0;
ewf::libewf_error_t *ewfError = NULL;
ewf::libewf_file_entry_get_number_of_sub_file_entries(parent, &num, &ewfError);
if (num > 0)
{
//recurse
for (int i=0; i < num; ++i)
{
ewf::libewf_file_entry_t *child = NULL;
ewfError = NULL;
if (ewf::libewf_file_entry_get_sub_file_entry(parent, i, &child, &ewfError) == -1)
{
throw TskException("TskL01Extract::traverse - Error with libewf_file_entry_get_sub_file_entry: ");
}
traverse(child);
}
}
if (saveDirectory)
{
currPath.popDirectory();
}
}
void System::saveFile(TextEditInput *edit, strlib::String &path) {
if (!edit->save(path)) {
systemPrint("\nfailed to save: %s. error: %s\n", path.c_str(), strerror(errno));
alert(strerror(errno), "Failed to save file");
} else {
_modifiedTime = getModifiedTime();
}
}
Variant BaseAssetObjectItem::getData(int column, ItemRole::Id roleId) const
{
if (column != 0)
{
return Variant();
}
if (roleId == ValueRole::roleId_)
{
return getDisplayText(0);
}
else if (roleId == IndexPathRole::roleId_)
{
return getFullPath();
}
else if (roleId == ThumbnailRole::roleId_)
{
return getThumbnail(0);
}
else if (roleId == TypeIconRole::roleId_)
{
return getTypeIconResourceString();
}
else if (roleId == SizeRole::roleId_)
{
return getSize();
}
else if (roleId == CreatedTimeRole::roleId_)
{
return getCreatedTime();
}
else if (roleId == ModifiedTimeRole::roleId_)
{
return getModifiedTime();
}
else if (roleId == AccessedTimeRole::roleId_)
{
return getAccessedTime();
}
else if (roleId == IsDirectoryRole::roleId_)
{
return isDirectory();
}
else if (roleId == IsReadOnlyRole::roleId_)
{
return isReadOnly();
}
else if (roleId == IsCompressedRole::roleId_)
{
return isCompressed();
}
else if (roleId == ItemRole::itemIdId)
{
return intptr_t(this);
}
return Variant();
}
BOOL CPathDescriptor::getModifiedSince(CTime& lastTime) const
{
CTime modTime = getModifiedTime();
//LOG4(modTime.Format(), " last=", lastTime.Format(), "\r\n");
// CString s;
// s.Format("modified %s last %s", modTime.Format("%A, %B %d, %Y"), lastTime.Format("%A, %B %d, %Y"));
// AfxMessageBox(s);
return modTime > lastTime;
}
void System::waitForChange(bool error) {
while (!isBack() && !isClosing()) {
processEvents(0);
if (error && _userScreenId == -1) {
// back button presses while error displayed
setExit(true);
break;
}
if (_modifiedTime != getModifiedTime()) {
break;
}
dev_delay(CHANGE_WAIT_SLEEP);
}
}
int loadRuleFromCacheOrFile( int processType, char *irbSet, ruleStruct_t *inRuleStruct ) {
char r1[NAME_LEN], r2[RULE_SET_DEF_LENGTH], r3[RULE_SET_DEF_LENGTH];
snprintf( r2, sizeof( r2 ), "%s", irbSet );
int res = 0;
#ifdef DEBUG
/*Cache *cache;*/
#endif
/* get max timestamp */
char fn[MAX_NAME_LEN];
time_type timestamp = time_type_initializer, mtim;
while ( strlen( r2 ) > 0 ) {
rSplitStr( r2, r1, NAME_LEN, r3, RULE_SET_DEF_LENGTH, ',' );
getRuleBasePath( r1, fn );
if ( ( res = getModifiedTime( fn, &mtim ) ) != 0 ) {
return res;
}
if ( time_type_gt( mtim, timestamp ) ) {
time_type_set( timestamp, mtim );
}
snprintf( r2, sizeof( r2 ), "%s", r3 );
}
snprintf( r2, sizeof( r2 ), "%s", irbSet );
#ifdef CACHE_ENABLE
int update = 0;
unsigned char *buf = NULL;
/* try to find shared memory cache */
if ( processType == RULE_ENGINE_TRY_CACHE && inRuleStruct == &coreRuleStrct ) {
buf = prepareNonServerSharedMemory();
if ( buf != NULL ) {
Cache * cache = restoreCache( buf );
detachSharedMemory();
if ( cache == NULL ) {
rodsLog( LOG_ERROR, "Failed to restore cache." );
}
else {
int diffIrbSet = strcmp( cache->ruleBase, irbSet ) != 0;
if ( diffIrbSet ) {
rodsLog( LOG_DEBUG, "Rule base set changed, old value is %s", cache->ruleBase );
}
if ( diffIrbSet || time_type_gt( timestamp, cache->timestamp ) ) {
update = 1;
free( cache->address );
rodsLog( LOG_DEBUG, "Rule base set or rule files modified, force refresh." );
}
else {
cache->cacheStatus = INITIALIZED;
ruleEngineConfig = *cache;
/* generate extRuleSet */
generateRegions();
generateRuleSets();
generateFunctionDescriptionTables();
if ( inRuleStruct == &coreRuleStrct && ruleEngineConfig.ruleEngineStatus == UNINITIALIZED ) {
getSystemFunctions( ruleEngineConfig.sysFuncDescIndex->current, ruleEngineConfig.sysRegion );
}
/* ruleEngineConfig.extRuleSetStatus = LOCAL;
ruleEngineConfig.extFuncDescIndexStatus = LOCAL; */
/* createRuleIndex(inRuleStruct); */
ruleEngineConfig.ruleEngineStatus = INITIALIZED;
//free( cache );
return res;
}
}
//free( cache );
}
else {
rodsLog( LOG_DEBUG, "Cannot open shared memory." );
}
}
#endif
if ( ruleEngineConfig.ruleEngineStatus == INITIALIZED ) {
/* Reloading rule set, clear previously generated rule set */
unlinkFuncDescIndex();
clearRuleIndex( inRuleStruct );
}
generateRegions();
generateRuleSets();
generateFunctionDescriptionTables();
if ( inRuleStruct == &coreRuleStrct && ruleEngineConfig.ruleEngineStatus == UNINITIALIZED ) {
getSystemFunctions( ruleEngineConfig.sysFuncDescIndex->current, ruleEngineConfig.sysRegion );
}
/*ruleEngineConfig.extRuleSetStatus = LOCAL;
ruleEngineConfig.extFuncDescIndexStatus = LOCAL;*/
while ( strlen( r2 ) > 0 ) {
int i = rSplitStr( r2, r1, NAME_LEN, r3, RULE_SET_DEF_LENGTH, ',' );
if ( i == 0 ) {
i = readRuleStructAndRuleSetFromFile( r1, inRuleStruct );
}
#ifdef DEBUG
printf( "%d rules in core rule set\n", ruleEngineConfig.coreRuleSet->len );
#endif
if ( i != 0 ) {
res = i;
ruleEngineConfig.ruleEngineStatus = INITIALIZED;
return res;
}
snprintf( r2, sizeof( r2 ), "%s", r3 );
}
createRuleIndex( inRuleStruct );
/* set max timestamp */
time_type_set( ruleEngineConfig.timestamp, timestamp );
snprintf( ruleEngineConfig.ruleBase, sizeof( ruleEngineConfig.ruleBase ), "%s", irbSet );
#ifdef CACHE_ENABLE
if ( ( processType == RULE_ENGINE_INIT_CACHE || update ) && inRuleStruct == &coreRuleStrct ) {
unsigned char *shared = prepareServerSharedMemory();
if ( shared != NULL ) {
int ret = updateCache( shared, SHMMAX, &ruleEngineConfig, processType );
detachSharedMemory();
if ( ret != 0 ) {
removeSharedMemory();
}
}
else {
rodsLog( LOG_ERROR, "Cannot open shared memory." );
}
}
#endif
ruleEngineConfig.ruleEngineStatus = INITIALIZED;
return res;
}
