/** Writes group fields to the stream. Returns true on success, false in case of error. */
bool PwGroupV3::writeToStream(QDataStream& stream) {
stream << FIELD_GROUP_ID;
PwStreamUtilsV3::writeInt32(stream, getId());
stream << FIELD_NAME;
PwStreamUtilsV3::writeString(stream, getName());
stream << FIELD_CREATION_TIME;
PwStreamUtilsV3::writeTimestamp(stream, getCreationTime());
stream << FIELD_LAST_MODIFIED_TIME;
PwStreamUtilsV3::writeTimestamp(stream, getLastModificationTime());
stream << FIELD_LAST_ACCESS_TIME;
PwStreamUtilsV3::writeTimestamp(stream, getLastAccessTime());
stream << FIELD_EXPIRATION_TIME;
PwStreamUtilsV3::writeTimestamp(stream, getExpiryTime());
stream << FIELD_ICON_ID;
PwStreamUtilsV3::writeInt32(stream, getIconId());
stream << FIELD_GROUP_LEVEL;
PwStreamUtilsV3::writeUInt16(stream, getLevel());
stream << FIELD_GROUP_FLAGS;
PwStreamUtilsV3::writeInt32(stream, getFlags());
stream << FIELD_END << (qint32)0;
return (stream.status() == QDataStream::Ok);
}
/*
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();
}
}
// Render atom to a file stream
bool
PVA_FF_MovieHeaderAtom::renderToFileStream(MP4_AUTHOR_FF_FILE_IO_WRAP *fp)
{
int32 rendered = 0; // Keep track of number of bytes rendered
// Render PVA_FF_Atom type and size
if (!renderAtomBaseMembers(fp))
{
return false;
}
rendered += getDefaultSize();
if (!PVA_FF_AtomUtils::render32(fp, getCreationTime()))
{
return false;
}
if (!PVA_FF_AtomUtils::render32(fp, getModificationTime()))
{
return false;
}
if (!PVA_FF_AtomUtils::render32(fp, getTimeScale()))
{
return false;
}
/*
* To ensure that the total track duration includes the duration of the
* last sample as well, which in our case fp same as the last but one.
*/
//uint32 totalDuration = getDuration() + _deltaTS;
uint32 totalDuration = getDuration();
if (!PVA_FF_AtomUtils::render32(fp, totalDuration))
{
return false;
}
rendered += 16;
uint32 reserved = 0x00010000;
if (!PVA_FF_AtomUtils::render32(fp, reserved))
{
return false;
}
rendered += 4;
reserved = 0x0100;
if (!PVA_FF_AtomUtils::render16(fp, (uint16)(reserved)))
{
return false;
}
rendered += 2;
// const bit(32)[2]
reserved = 0;
if (!PVA_FF_AtomUtils::render16(fp, (uint16)(reserved)))
{
return false;
}
if (!PVA_FF_AtomUtils::render32(fp, reserved))
{
return false;
}
if (!PVA_FF_AtomUtils::render32(fp, reserved))
{
return false;
}
rendered += 10;
// const bit(32)[9]
reserved = 0x00010000;
if (!PVA_FF_AtomUtils::render32(fp, reserved))
{
return false;
}
rendered += 4;
reserved = 0;
if (!PVA_FF_AtomUtils::render32(fp, reserved))
{
return false;
}
if (!PVA_FF_AtomUtils::render32(fp, reserved))
{
return false;
}
if (!PVA_FF_AtomUtils::render32(fp, reserved))
{
return false;
}
rendered += 12;
reserved = 0x00010000;
if (!PVA_FF_AtomUtils::render32(fp, reserved))
{
return false;
}
rendered += 4;
reserved = 0;
if (!PVA_FF_AtomUtils::render32(fp, reserved))
{
return false;
}
if (!PVA_FF_AtomUtils::render32(fp, reserved))
{
return false;
}
if (!PVA_FF_AtomUtils::render32(fp, reserved))
{
return false;
}
rendered += 12;
reserved = 0x40000000;
if (!PVA_FF_AtomUtils::render32(fp, reserved))
{
return false;
}
rendered += 4;
// const bit(32)[6] reserved = 0
reserved = 0;
if (!PVA_FF_AtomUtils::render32(fp, reserved))
{
return false;
}
if (!PVA_FF_AtomUtils::render32(fp, reserved))
{
return false;
}
if (!PVA_FF_AtomUtils::render32(fp, reserved))
{
return false;
}
if (!PVA_FF_AtomUtils::render32(fp, reserved))
{
return false;
}
if (!PVA_FF_AtomUtils::render32(fp, reserved))
{
return false;
}
if (!PVA_FF_AtomUtils::render32(fp, reserved))
{
return false;
}
rendered += 24;
// _nextTrackID
if (!PVA_FF_AtomUtils::render32(fp, _nextTrackID))
{
return false;
}
rendered += 4;
return true;
}
// Rendering the PVA_FF_Atom in proper format (bitlengths, etc.) to an ostream.
bool
PVA_FF_TrackHeaderAtom::renderToFileStream(MP4_AUTHOR_FF_FILE_IO_WRAP *fp)
{
int32 rendered = 0; // Keep track of number of bytes rendered
uint32 trackID = 0;
// Render PVA_FF_Atom type and size
if (!renderAtomBaseMembers(fp))
{
return false;
}
rendered += getDefaultSize();
if (getVersion() == 0)
{
if (!PVA_FF_AtomUtils::render32(fp,
Oscl_Int64_Utils::get_uint64_lower32(getCreationTime())))
{
return false;
}
if (!PVA_FF_AtomUtils::render32(fp,
Oscl_Int64_Utils::get_uint64_lower32(getModificationTime())))
{
return false;
}
}
else // getVersion() == 1
{
if (!PVA_FF_AtomUtils::render64(fp, getCreationTime()))
{
return false;
}
if (!PVA_FF_AtomUtils::render64(fp, getModificationTime()))
{
return false;
}
}
trackID = getTrackID();
if (!PVA_FF_AtomUtils::render32(fp, trackID))
{
return false;
}
if (getVersion() == 0)
{
rendered += 12;
}
else
{
rendered += 20;
}
if (!PVA_FF_AtomUtils::render32(fp, _reserved1))
{
return false;
}
rendered += 4;
/*
* To ensure that the total track duration includes the duration of the
* last sample as well, which in our case is same as the last but one.
*/
uint64 totalDuration = getDuration();
if (totalDuration == 0)
{
totalDuration = _currTrackDuration;
}
if (getVersion() == 0)
{
if (!PVA_FF_AtomUtils::render32(fp,
Oscl_Int64_Utils::get_uint64_lower32(totalDuration)))
{
return false;
}
rendered += 4;
}
else // getVersion() == 1
{
if (!PVA_FF_AtomUtils::render64(fp, totalDuration))
{
return false;
}
rendered += 8;
}
if (!PVA_FF_AtomUtils::render32(fp, _reserved2[0]))
{
return false;
}
if (!PVA_FF_AtomUtils::render32(fp, _reserved2[1]))
{
return false;
}
if (!PVA_FF_AtomUtils::render32(fp, _reserved2[2]))
{
return false;
}
if (!PVA_FF_AtomUtils::render16(fp, _reserved3))
{
return false;
}
if (!PVA_FF_AtomUtils::render16(fp, _reserved4))
{
return false;
}
if (!PVA_FF_AtomUtils::render32(fp, _reserved5[0]))
{
return false;
}
if (!PVA_FF_AtomUtils::render32(fp, _reserved5[1]))
{
return false;
}
if (!PVA_FF_AtomUtils::render32(fp, _reserved5[2]))
{
return false;
}
if (!PVA_FF_AtomUtils::render32(fp, _reserved5[3]))
{
return false;
}
if (!PVA_FF_AtomUtils::render32(fp, _reserved5[4]))
{
return false;
}
if (!PVA_FF_AtomUtils::render32(fp, _reserved5[5]))
{
return false;
}
if (!PVA_FF_AtomUtils::render32(fp, _reserved5[6]))
{
return false;
}
if (!PVA_FF_AtomUtils::render32(fp, _reserved5[7]))
{
return false;
}
if (!PVA_FF_AtomUtils::render32(fp, _reserved5[8]))
{
return false;
}
if (!PVA_FF_AtomUtils::render32(fp, _reserved6))
{
return false;
}
if (!PVA_FF_AtomUtils::render32(fp, _reserved7))
{
return false;
}
rendered += 60;
return true;
}
BlockInputStreams StorageSystemDictionaries::read(
const Names & column_names,
const ASTPtr & query,
const Context & context,
QueryProcessingStage::Enum & processed_stage,
const size_t max_block_size,
const unsigned)
{
check(column_names);
processed_stage = QueryProcessingStage::FetchColumns;
ColumnWithTypeAndName col_name{std::make_shared<ColumnString>(), std::make_shared<DataTypeString>(), "name"};
ColumnWithTypeAndName col_origin{std::make_shared<ColumnString>(), std::make_shared<DataTypeString>(), "origin"};
ColumnWithTypeAndName col_type{std::make_shared<ColumnString>(), std::make_shared<DataTypeString>(), "type"};
ColumnWithTypeAndName col_key{std::make_shared<ColumnString>(), std::make_shared<DataTypeString>(), "key"};
ColumnWithTypeAndName col_attribute_names{
std::make_shared<ColumnArray>(std::make_shared<ColumnString>()),
std::make_shared<DataTypeArray>(std::make_shared<DataTypeString>()),
"attribute.names"
};
ColumnWithTypeAndName col_attribute_types{
std::make_shared<ColumnArray>(std::make_shared<ColumnString>()),
std::make_shared<DataTypeArray>(std::make_shared<DataTypeString>()),
"attribute.types"
};
ColumnWithTypeAndName col_has_hierarchy{std::make_shared<ColumnUInt8>(), std::make_shared<DataTypeUInt8>(), "has_hierarchy"};
ColumnWithTypeAndName col_bytes_allocated{std::make_shared<ColumnUInt64>(), std::make_shared<DataTypeUInt64>(), "bytes_allocated"};
ColumnWithTypeAndName col_query_count{std::make_shared<ColumnUInt64>(), std::make_shared<DataTypeUInt64>(), "query_count"};
ColumnWithTypeAndName col_hit_rate{std::make_shared<ColumnFloat64>(), std::make_shared<DataTypeFloat64>(), "hit_rate"};
ColumnWithTypeAndName col_element_count{std::make_shared<ColumnUInt64>(), std::make_shared<DataTypeUInt64>(), "element_count"};
ColumnWithTypeAndName col_load_factor{std::make_shared<ColumnFloat64>(), std::make_shared<DataTypeFloat64>(), "load_factor"};
ColumnWithTypeAndName col_creation_time{std::make_shared<ColumnUInt32>(), std::make_shared<DataTypeDateTime>(), "creation_time"};
ColumnWithTypeAndName col_last_exception{std::make_shared<ColumnString>(), std::make_shared<DataTypeString>(), "last_exception"};
ColumnWithTypeAndName col_source{std::make_shared<ColumnString>(), std::make_shared<DataTypeString>(), "source"};
const auto & external_dictionaries = context.getExternalDictionaries();
const std::lock_guard<std::mutex> lock{external_dictionaries.dictionaries_mutex};
for (const auto & dict_info : external_dictionaries.dictionaries)
{
col_name.column->insert(dict_info.first);
col_origin.column->insert(dict_info.second.origin);
if (dict_info.second.dict)
{
const auto dict_ptr = dict_info.second.dict->get();
col_type.column->insert(dict_ptr->getTypeName());
const auto & dict_struct = dict_ptr->getStructure();
col_key.column->insert(dict_struct.getKeyDescription());
col_attribute_names.column->insert(ext::map<Array>(dict_struct.attributes, [] (auto & attr) -> decltype(auto) {
return attr.name;
}));
col_attribute_types.column->insert(ext::map<Array>(dict_struct.attributes, [] (auto & attr) -> decltype(auto) {
return attr.type->getName();
}));
col_bytes_allocated.column->insert(dict_ptr->getBytesAllocated());
col_query_count.column->insert(dict_ptr->getQueryCount());
col_hit_rate.column->insert(dict_ptr->getHitRate());
col_element_count.column->insert(dict_ptr->getElementCount());
col_load_factor.column->insert(dict_ptr->getLoadFactor());
col_creation_time.column->insert(std::chrono::system_clock::to_time_t(dict_ptr->getCreationTime()));
col_source.column->insert(dict_ptr->getSource()->toString());
}
else
{
col_type.column->insertDefault();
col_key.column->insertDefault();
col_attribute_names.column->insertDefault();
col_attribute_types.column->insertDefault();
col_bytes_allocated.column->insertDefault();
col_query_count.column->insertDefault();
col_hit_rate.column->insertDefault();
col_element_count.column->insertDefault();
col_load_factor.column->insertDefault();
col_creation_time.column->insertDefault();
col_source.column->insertDefault();
}
if (dict_info.second.exception)
{
try
{
std::rethrow_exception(dict_info.second.exception);
}
catch (...)
{
col_last_exception.column->insert(getCurrentExceptionMessage(false));
}
}
else
col_last_exception.column->insertDefault();
}
Block block{
col_name,
col_origin,
col_type,
col_key,
col_attribute_names,
col_attribute_types,
col_bytes_allocated,
col_query_count,
col_hit_rate,
col_element_count,
col_load_factor,
col_creation_time,
col_last_exception,
col_source
};
return BlockInputStreams{1, std::make_shared<OneBlockInputStream>(block)};
}
/*
*******************************************************************
* Function:
*
* Description:
*
* Parameters:
*
* Returns:
*
*******************************************************************
*/
TNL::U32 xDistributedSession::packUpdate(TNL::GhostConnection *connection, TNL::U32 updateMask, TNL::BitStream *stream)
{
xNetInterface *netInterface = (xNetInterface*) connection->getInterface();
if (netInterface)
{
//the first time ? : we write out all necessary attributes for the client :
if(stream->writeFlag(updateMask & InitialMask))
{
if(stream->writeFlag(true))
{
//write out name :
stream->writeString(GetName().getString(),strlen(GetName().getString()));
//retrieve its class :
xDistributedClass *distClass = getDistributedClass();
if (distClass)
{
//write out the class name :
stream->writeString(distClass->getClassName().getString(),strlen(distClass->getClassName().getString()));
//write out the class base type :
stream->writeInt(distClass->getEnitityType(),32);
//write out users id :
vtConnection *con = (vtConnection*)connection;
int uid = getUserID();
stream->writeInt(getUserID(),32);
//write out server side id :
int serverID = connection->getGhostIndex(this);
stream->writeInt(connection->getGhostIndex(this),32);
setServerID(connection->getGhostIndex(this));
float time = getCreationTime();
//write out creation time
stream->write(getCreationTime());
// xLogger::xLog(ELOGINFO,XL_START,"server:init pack update of %s: %f , %d , ",GetName().getString(),time,uid);
stream->writeInt(getSessionID(),32);
stream->writeInt(getMaxUsers(),32);
stream->writeString(getPassword().getString(),strlen(getPassword().getString()));
//netInterface->deploySessionClasses(connection);
}
setNetInterface(netInterface);
}
}
/************************************************************************/
/* */
/************************************************************************/
stream->writeSignedInt(getUpdateBits().getMask(),32);
//xLogger::xLog(ELOGINFO,XL_START,"server is updating ghosts %d", getUpdateBits().getMask() );
xDistributedPropertyArrayType &props = *getDistributedPorperties();
for (unsigned int i = 0 ; i < props.size() ; i++ )
{
xDistributedProperty *prop = props[i];
xDistributedPropertyInfo*propInfo = prop->getPropertyInfo();
int blockIndex = prop->getBlockIndex();
if (propInfo)
{
if (getUpdateBits().testStrict(1<<blockIndex))
{
prop->updateGhostValue(stream);
//xLogger::xLog(ELOGINFO,XL_START,"server is updating ghosts %d",blockIndex);
}
}
}
//getUpdateBits().clear();
}
return 0;
}
void StorageSystemModels::fillData(MutableColumns & res_columns, const Context & context, const SelectQueryInfo &) const
{
const auto & external_models = context.getExternalModels();
auto objects_map = external_models.getObjectsMap();
const auto & models = objects_map.get();
for (const auto & model_info : models)
{
res_columns[0]->insert(model_info.first);
res_columns[1]->insert(model_info.second.origin);
if (model_info.second.loadable)
{
const auto model_ptr = std::static_pointer_cast<IModel>(model_info.second.loadable);
res_columns[2]->insert(model_ptr->getTypeName());
res_columns[3]->insert(static_cast<UInt64>(std::chrono::system_clock::to_time_t(model_ptr->getCreationTime())));
}
else
{
res_columns[2]->insertDefault();
res_columns[3]->insertDefault();
}
if (model_info.second.exception)
{
try
{
std::rethrow_exception(model_info.second.exception);
}
catch (...)
{
res_columns[4]->insert(getCurrentExceptionMessage(false));
}
}
else
res_columns[4]->insertDefault();
}
}
