int main(int argc, char *argv[])
{
QApplication a(argc, argv);
MainWindow w;
PCSCResourceManager manager;
Flowmeter flowmeter;
RealtimeRunningData runningData(&g_gps, &flowmeter);
RunningDataUploader uploader(&runningData, g_settings.ServerIP(), g_settings.ServerPort());
BInputMethod inputMethod;
QWSServer::setCurrentInputMethod(&inputMethod);
g_gps.start();
w.setDriver(&g_driver);
w.show();
g_driver.connectPCSCResourceManager(&manager);
g_warehouseProxy.setAttachedDriver(&g_driver);
manager.start();
runningData.start();
uploader.start();
return a.exec();
}
bool
FileStore::upload(QWidget *parent, FileStore *store, RideItem *item)
{
// open a dialog to do it
FileStoreUploadDialog uploader(parent, store, item);
int ret = uploader.exec();
// was it successfull ?
if (ret == QDialog::Accepted) return true;
else return false;
}
void CBackupStatusUpdater::run()
{
CUploader uploader(_ctx);
CTQueue<CAsset> & localMd5Done = _ctx._localMd5DoneQueue;
bool remoteExists;
while ( (!localMd5Done.isEmpty()) || (!localMd5Done.done()) )
{
CAsset * p = getNext(remoteExists);
if (p) {
assert( !p->isFolder());
if (!remoteExists)
{
p->setBackupStatus(BACKUP_ITEM_STATUS::TO_BE_CREATED);
} else {
const CHash localH = p->getSrcHash();
const CHash remoteH= p->getDstHash();
assert( remoteH._computed && localH._computed );
if (localH == remoteH)
{
if (_ctx.crypted())
{
// check if password changed
if (_ctx._options->_cryptoKey != p->getRemoteCryptoKey() )
p->setBackupStatus(BACKUP_ITEM_STATUS::UPDATE_PWD_CHANGED);
else
p->setBackupStatus(BACKUP_ITEM_STATUS::UP_TO_DATE);
} else // not crypted
p->setBackupStatus(BACKUP_ITEM_STATUS::UP_TO_DATE);
} else // md5 are differents
p->setBackupStatus(BACKUP_ITEM_STATUS::UPDATE_CONTENT_CHANGED);
}
_ctx._todoQueue.add(p);
LOGI("{} {}", (int) p->getBackupStatus(), p->getRelativePath());
}
if (_ctx.aborted())
break;
std::this_thread::sleep_for(std::chrono::milliseconds(1));
}
_ctx._todoQueue.setDone();
LOGD("{} DONE", __PRETTY_FUNCTION__);
}
void FilteredModelTests::setSelectedForUploadTest() {
DECLARE_MODELS_AND_GENERATE(10);
Models::ArtworkUploader uploader(NULL);
commandManagerMock.InjectDependency(&uploader);
for (int i = 0; i < 10; ++i) {
Models::ArtworkMetadata *metadata = artItemsModelMock.getArtwork(i);
metadata->initialize("title", "description", QStringList() << "keyword1" << "keyword2");
if (i % 2) {
metadata->setIsSelected(true);
}
}
filteredItemsModel.setSelectedForUpload();
const QVector<Models::ArtworkMetadata*> &artworks = uploader.getArtworkList();
QCOMPARE(artworks.length(), 5);
}
void CSynchronizer::run()
{
CUploader uploader(_ctx);
CTQueue<CAsset> & todo = _ctx._todoQueue;
while ( (!todo.isEmpty()) || (!todo.done()) )
{
CAsset * p = todo.get();
if (p) {
switch ( p->getBackupStatus() )
{
case BACKUP_ITEM_STATUS::UNKNOWN:
case BACKUP_ITEM_STATUS::IGNORED:
case BACKUP_ITEM_STATUS::TO_BE_DELETED:
case BACKUP_ITEM_STATUS::IS_A_FOLDER:
assert( false );
break;
case BACKUP_ITEM_STATUS::UP_TO_DATE:
LOGD("up to date '{}'", p->getRelativePath().string());
break;
case BACKUP_ITEM_STATUS::UPDATE_CONTENT_CHANGED:
case BACKUP_ITEM_STATUS::UPDATE_PWD_CHANGED:
case BACKUP_ITEM_STATUS::TO_BE_CREATED:
LOGI("{} '{}'", uploadLabel(p->getBackupStatus()), p->getRelativePath().string());
if (!uploader.upload(p))
_ctx.abort();
break;
}
}
std::this_thread::sleep_for(std::chrono::milliseconds(1));
if (_ctx.aborted())
break;
}
LOGD("{} DONE", __PRETTY_FUNCTION__);
}
bool CCVideoLayerImpl::copyPlaneData(CCRenderer* layerRenderer, CCGraphicsContext* context)
{
size_t softwarePlaneCount = m_frame->planes();
if (!softwarePlaneCount)
return true;
GraphicsContext3D* context3d = context->context3D();
if (!context3d) {
// FIXME: Implement this path for software compositing.
return false;
}
LayerTextureSubImage uploader(true);
for (size_t softwarePlaneIndex = 0; softwarePlaneIndex < softwarePlaneCount; ++softwarePlaneIndex) {
CCVideoLayerImpl::FramePlane& plane = m_framePlanes[softwarePlaneIndex];
const uint8_t* softwarePlanePixels = static_cast<const uint8_t*>(m_frame->data(softwarePlaneIndex));
IntRect planeRect(IntPoint(), plane.size);
context3d->bindTexture(GraphicsContext3D::TEXTURE_2D, plane.textureId);
uploader.setSubImageSize(plane.size);
uploader.upload(softwarePlanePixels, planeRect, planeRect, planeRect, plane.format, context);
}
return true;
}
void
Analyzer::stop()
{
LOG(INFO, "Analyzer: stopping");
onProcessEventConnection.disconnect();
onRegistryEventConnection.disconnect();
onFileEventConnection.disconnect();
onNetworkEventConnection.disconnect();
if(captureNetworkPackets)
{
LOG(INFO, "Analyzer: stopping network dumper");
networkPacketDumper->stop();
}
if(collectModifiedFiles)
{
LOG(INFO, "Analyzer: copying modified files");
fileMonitor->setMonitorModifiedFiles(false);
fileMonitor->copyCreatedFiles();
}
if(OptionsManager::getInstance()->getOption(L"server") != L"") { //only when connected to server
if(collectModifiedFiles || captureNetworkPackets) //then we zip what we have and send to server
{
//if malicious && capture malicious set to false, then delete pcap
if(malicious && (OptionsManager::getInstance()->getOption(L"capture-network-packets-malicious") == L"false")) {
if(networkPacketDumper)
networkPacketDumper->deleteAdapterFiles();
}
//if benign && capture benign set to false, then delete pcap
if(!malicious && (OptionsManager::getInstance()->getOption(L"capture-network-packets-benign") == L"false")) {
if(networkPacketDumper)
networkPacketDumper->deleteAdapterFiles();
}
if(!malicious) {
LOG(INFO, "Analyzer: deleting modified files");
wchar_t* szFullPathDF = new wchar_t[1024];
GetFullPathName(L"logs\\deleted_files", 1024, szFullPathDF, NULL);
SHFILEOPSTRUCT deleteDeletedFilesDirectory;
deleteDeletedFilesDirectory.hwnd = NULL;
deleteDeletedFilesDirectory.pTo = NULL;
deleteDeletedFilesDirectory.lpszProgressTitle = NULL;
deleteDeletedFilesDirectory.wFunc = FO_DELETE;
deleteDeletedFilesDirectory.pFrom = szFullPathDF;
deleteDeletedFilesDirectory.fFlags = FOF_NOCONFIRMATION | FOF_SILENT | FOF_NOERRORUI;
SHFileOperation(&deleteDeletedFilesDirectory);
delete [] szFullPathDF;
wchar_t* szFullPathMF = new wchar_t[1024];
GetFullPathName(L"logs\\modified_files", 1024, szFullPathMF, NULL);
SHFILEOPSTRUCT deleteModifiedFilesDirectory;
deleteModifiedFilesDirectory.hwnd = NULL;
deleteModifiedFilesDirectory.pTo = NULL;
deleteModifiedFilesDirectory.lpszProgressTitle = NULL;
deleteModifiedFilesDirectory.wFunc = FO_DELETE;
deleteModifiedFilesDirectory.pFrom = szFullPathMF;
deleteModifiedFilesDirectory.fFlags = FOF_NOCONFIRMATION | FOF_SILENT | FOF_NOERRORUI;
SHFileOperation(&deleteModifiedFilesDirectory);
delete [] szFullPathMF;
}
SYSTEMTIME st;
GetLocalTime(&st);
if((malicious && collectModifiedFiles) || (!malicious && (OptionsManager::getInstance()->getOption(L"capture-network-packets-benign") == L"true")) ||
(malicious && (OptionsManager::getInstance()->getOption(L"capture-network-packets-malicious") == L"true")))
{
wchar_t* szLogFileName = new wchar_t[1024];
std::wstring log = L"capture_";
log += boost::lexical_cast<std::wstring>(st.wDay);
log += boost::lexical_cast<std::wstring>(st.wMonth);
log += boost::lexical_cast<std::wstring>(st.wYear);
log += L"_";
log += boost::lexical_cast<std::wstring>(st.wHour);
log += boost::lexical_cast<std::wstring>(st.wMinute);
log += L".zip";
GetFullPathName(log.c_str(), 1024, szLogFileName, NULL);
bool compressed = compressLogDirectory(szLogFileName);
if(server.isConnected() && compressed)
{
LOG(INFO, "Analyzer: sending log file to server");
FileUploader uploader(server);
uploader.sendFile(szLogFileName);
}
if(compressed)
{
DeleteFile(szLogFileName);
}
delete [] szLogFileName;
}
}
/* Delete the log directory */
LOG(INFO, "Analyzer: deleting logs");
wchar_t* szFullPath = new wchar_t[1024];
GetFullPathName(L"logs", 1024, szFullPath, NULL);
SHFILEOPSTRUCT deleteLogDirectory;
deleteLogDirectory.hwnd = NULL;
deleteLogDirectory.pTo = NULL;
deleteLogDirectory.lpszProgressTitle = NULL;
deleteLogDirectory.wFunc = FO_DELETE;
deleteLogDirectory.pFrom = szFullPath;
deleteLogDirectory.fFlags = FOF_NOCONFIRMATION | FOF_SILENT | FOF_NOERRORUI;
SHFileOperation(&deleteLogDirectory);
delete [] szFullPath;
}
LOG(INFO, "Analyzer: stopped");
}
int main()
{
LogUploader uploader("log", getUserName());
uploader.run();
}
