// ************************************************************************** // * This file is part of the FreeFileSync project. It is distributed under * // * GNU General Public License: http://www.gnu.org/licenses/gpl.html * // * Copyright (C) 2008-2010 ZenJu (zhnmju123 AT gmx.de) * // ************************************************************************** // #include "dbFile.h" #include #include #include "../shared/globalFunctions.h" #include "../shared/fileError.h" #include #include "../shared/stringConv.h" #include "../shared/fileHandling.h" #include #include "../shared/serialize.h" #include "../shared/fileIO.h" #include "../shared/loki/ScopeGuard.h" #ifdef FFS_WIN #include //includes "windows.h" #include "../shared/longPathPrefix.h" #endif using namespace FreeFileSync; namespace { //------------------------------------------------------------------------------------------------------------------------------- const char FILE_FORMAT_DESCR[] = "FreeFileSync"; const int FILE_FORMAT_VER = 3; //------------------------------------------------------------------------------------------------------------------------------- //yet another layer of indirection: Since 32/64 bit builds are binary incompatible, we want them to write into "distinct parts" of the db-file //just like we were actually accessing different files class FileInputStreamDB : public FileInputStream { public: FileInputStreamDB(const Zstring& filename) : //throw FileError() FileInputStream(filename) { //read FreeFileSync file identifier char formatDescr[sizeof(FILE_FORMAT_DESCR)]; Read(formatDescr, sizeof(formatDescr)); //throw (FileError) formatDescr[sizeof(formatDescr) - 1] = 0; if (std::string(formatDescr) != FILE_FORMAT_DESCR) throw FileError(wxString(_("Incompatible synchronization database format:")) + wxT(" \n") + wxT("\"") + zToWx(filename) + wxT("\"")); } private: }; class FileOutputStreamDB : public FileOutputStream { public: FileOutputStreamDB(const Zstring& filename) : //throw FileError() FileOutputStream(filename) { //write FreeFileSync file identifier Write(FILE_FORMAT_DESCR, sizeof(FILE_FORMAT_DESCR)); //throw (FileError) } private: }; } //####################################################################################################################################### class ReadDirInfo : public Utility::ReadInputStream { public: ReadDirInfo(wxInputStream& stream, const wxString& errorObjName, DirInformation& dirInfo) : ReadInputStream(stream, errorObjName) { //read filter settings dirInfo.filter = BaseFilter::loadFilter(getStream()); check(); //start recursion execute(dirInfo.baseDirContainer); } private: void execute(DirContainer& dirCont) { unsigned int fileCount = readNumberC(); while (fileCount-- != 0) readSubFile(dirCont); unsigned int dirCount = readNumberC(); while (dirCount-- != 0) readSubDirectory(dirCont); } void readSubFile(DirContainer& dirCont) { //attention: order of function argument evaluation is undefined! So do it one after the other... const Zstring shortName = readStringC(); //file name const long modHigh = readNumberC(); const unsigned long modLow = readNumberC(); const unsigned long sizeHigh = readNumberC(); const unsigned long sizeLow = readNumberC(); //const Utility::FileID fileIdentifier(stream_); //check(); dirCont.addSubFile(shortName, FileDescriptor(wxLongLong(modHigh, modLow), wxULongLong(sizeHigh, sizeLow))); } void readSubDirectory(DirContainer& dirCont) { const Zstring shortName = readStringC(); //directory name DirContainer& subDir = dirCont.addSubDir(shortName); execute(subDir); //recurse } }; typedef boost::shared_ptr > MemoryStreamPtr; //byte stream representing DirInformation typedef std::map DirectoryTOC; //list of streams ordered by a UUID pointing to their partner database typedef std::pair DbStreamData; //header data: UUID representing this database, item data: list of dir-streams /* Example left side right side --------- ---------- DB-ID 123 <-\ /-> DB-ID 567 \/ Partner-ID 111 /\ Partner-ID 222 Partner-ID 567 _/ \_ Partner-ID 123 ... ... */ class ReadFileStream : public Utility::ReadInputStream { public: ReadFileStream(wxInputStream& stream, const wxString& filename, DbStreamData& output) : ReadInputStream(stream, filename) { if (readNumberC() != FILE_FORMAT_VER) //read file format version throw FileError(wxString(_("Incompatible synchronization database format:")) + wxT(" \n") + wxT("\"") + filename + wxT("\"")); //read DB id output.first = Utility::UniqueId(getStream()); check(); DirectoryTOC& dbList = output.second; dbList.clear(); size_t dbCount = readNumberC(); //number of databases: one for each sync-pair while (dbCount-- != 0) { const Utility::UniqueId partnerID(getStream()); //DB id of partner databases check(); CharArray buffer = readArrayC(); //read db-entry stream (containing DirInformation) dbList.insert(std::make_pair(partnerID, buffer)); } } }; DbStreamData loadFile(const Zstring& filename) //throw (FileError) { if (!FreeFileSync::fileExists(filename)) throw FileError(wxString(_("Initial synchronization:")) + wxT(" \n\n") + _("One of the FreeFileSync database files is not yet existing:") + wxT(" \n") + wxT("\"") + zToWx(filename) + wxT("\"")); //read format description (uncompressed) FileInputStreamDB uncompressed(filename); //throw (FileError) wxZlibInputStream input(uncompressed, wxZLIB_ZLIB); DbStreamData output; ReadFileStream(input, zToWx(filename), output); return output; } std::pair FreeFileSync::loadFromDisk(const BaseDirMapping& baseMapping) //throw (FileError) { const Zstring fileNameLeft = baseMapping.getDBFilename(); const Zstring fileNameRight = baseMapping.getDBFilename(); try { //read file data: db ID + mapping of partner-ID/DirInfo-stream const DbStreamData dbEntriesLeft = ::loadFile(fileNameLeft); const DbStreamData dbEntriesRight = ::loadFile(fileNameRight); //find associated DirInfo-streams DirectoryTOC::const_iterator dbLeft = dbEntriesLeft.second.find(dbEntriesRight.first); //find left db-entry that corresponds to right database if (dbLeft == dbEntriesLeft.second.end()) throw FileError(wxString(_("Initial synchronization:")) + wxT(" \n\n") + _("One of the FreeFileSync database entries within the following file is not yet existing:") + wxT(" \n") + wxT("\"") + zToWx(fileNameLeft) + wxT("\"")); DirectoryTOC::const_iterator dbRight = dbEntriesRight.second.find(dbEntriesLeft.first); //find left db-entry that corresponds to right database if (dbRight == dbEntriesRight.second.end()) throw FileError(wxString(_("Initial synchronization:")) + wxT(" \n\n") + _("One of the FreeFileSync database entries within the following file is not yet existing:") + wxT(" \n") + wxT("\"") + zToWx(fileNameRight) + wxT("\"")); //read streams into DirInfo boost::shared_ptr dirInfoLeft(new DirInformation); wxMemoryInputStream buffer(&(*dbLeft->second)[0], dbLeft->second->size()); //convert char-array to inputstream: no copying, ownership not transferred ReadDirInfo(buffer, zToWx(fileNameLeft), *dirInfoLeft); //read file/dir information boost::shared_ptr dirInfoRight(new DirInformation); wxMemoryInputStream buffer2(&(*dbRight->second)[0], dbRight->second->size()); //convert char-array to inputstream: no copying, ownership not transferred ReadDirInfo(buffer2, zToWx(fileNameRight), *dirInfoRight); //read file/dir information return std::make_pair(dirInfoLeft, dirInfoRight); } catch (const std::bad_alloc&) //this is most likely caused by a corrupted database file { throw FileError(wxString(_("Error reading from synchronization database:")) + wxT(" (bad_alloc)")); } } //------------------------------------------------------------------------------------------------------------------------- template struct IsNonEmpty { bool operator()(const FileSystemObject& fsObj) const { return !fsObj.isEmpty(); } }; template class SaveDirInfo : public Utility::WriteOutputStream { public: SaveDirInfo(const BaseDirMapping& baseMapping, const wxString& errorObjName, wxOutputStream& stream) : WriteOutputStream(errorObjName, stream) { //save filter settings baseMapping.getFilter()->saveFilter(getStream()); check(); //start recursion execute(baseMapping); } private: template friend Function std::for_each(Iterator, Iterator, Function); void execute(const HierarchyObject& hierObj) { writeNumberC(std::count_if(hierObj.useSubFiles().begin(), hierObj.useSubFiles().end(), IsNonEmpty())); //number of (existing) files std::for_each(hierObj.useSubFiles().begin(), hierObj.useSubFiles().end(), *this); writeNumberC(std::count_if(hierObj.useSubDirs().begin(), hierObj.useSubDirs().end(), IsNonEmpty())); //number of (existing) directories std::for_each(hierObj.useSubDirs().begin(), hierObj.useSubDirs().end(), *this); } void operator()(const FileMapping& fileMap) { if (!fileMap.isEmpty()) { writeStringC(fileMap.getObjShortName()); //file name writeNumberC( fileMap.getLastWriteTime().GetHi()); //last modification time writeNumberC(fileMap.getLastWriteTime().GetLo()); // writeNumberC(fileMap.getFileSize().GetHi()); //filesize writeNumberC(fileMap.getFileSize().GetLo()); // //fileMap.getFileID().toStream(stream_); //unique file identifier //check(); } } void operator()(const DirMapping& dirMap) { if (!dirMap.isEmpty()) { writeStringC(dirMap.getObjShortName()); //directory name execute(dirMap); //recurse } } }; class WriteFileStream : public Utility::WriteOutputStream { public: WriteFileStream(const DbStreamData& input, const wxString& filename, wxOutputStream& stream) : WriteOutputStream(filename, stream) { //save file format version writeNumberC(FILE_FORMAT_VER); //write DB id input.first.toStream(getStream()); check(); const DirectoryTOC& dbList = input.second; writeNumberC(dbList.size()); //number of database records: one for each sync-pair for (DirectoryTOC::const_iterator i = dbList.begin(); i != dbList.end(); ++i) { i->first.toStream(getStream()); //DB id of partner database check(); writeArrayC(*(i->second)); //write DirInformation stream } } }; //save/load DirContainer void saveFile(const DbStreamData& dbStream, const Zstring& filename) //throw (FileError) { { //write format description (uncompressed) FileOutputStreamDB uncompressed(filename); //throw (FileError) wxZlibOutputStream output(uncompressed, 4, wxZLIB_ZLIB); /* 4 - best compromise between speed and compression: (scanning 200.000 objects) 0 (uncompressed) 8,95 MB - 422 ms 2 2,07 MB - 470 ms 4 1,87 MB - 500 ms 6 1,77 MB - 613 ms 9 (maximal compression) 1,74 MB - 3330 ms */ WriteFileStream(dbStream, zToWx(filename), output); } //(try to) hide database file #ifdef FFS_WIN ::SetFileAttributes(FreeFileSync::applyLongPathPrefix(filename).c_str(), FILE_ATTRIBUTE_HIDDEN); #endif } void FreeFileSync::saveToDisk(const BaseDirMapping& baseMapping) //throw (FileError) { //transactional behaviour! write to tmp files first const Zstring fileNameLeftTmp = baseMapping.getDBFilename() + DefaultStr(".tmp"); const Zstring fileNameRightTmp = baseMapping.getDBFilename() + DefaultStr(".tmp");; //delete old tmp file, if necessary -> throws if deletion fails! removeFile(fileNameLeftTmp); removeFile(fileNameRightTmp); //load old database files... //read file data: db ID + mapping of partner-ID/DirInfo-stream: may throw! DbStreamData dbEntriesLeft; if (FreeFileSync::fileExists(baseMapping.getDBFilename())) try { dbEntriesLeft = ::loadFile(baseMapping.getDBFilename()); } catch(FileError&) {} //if error occurs: just overwrite old file! User is already informed about issues right after comparing! //else -> dbEntriesLeft has empty mapping, but already a DB-ID! //read file data: db ID + mapping of partner-ID/DirInfo-stream: may throw! DbStreamData dbEntriesRight; if (FreeFileSync::fileExists(baseMapping.getDBFilename())) try { dbEntriesRight = ::loadFile(baseMapping.getDBFilename()); } catch(FileError&) {} //if error occurs: just overwrite old file! User is already informed about issues right after comparing! //create new database entries MemoryStreamPtr dbEntryLeft(new std::vector); { wxMemoryOutputStream buffer; SaveDirInfo(baseMapping, zToWx(baseMapping.getDBFilename()), buffer); dbEntryLeft->resize(buffer.GetSize()); //convert output stream to char-array buffer.CopyTo(&(*dbEntryLeft)[0], buffer.GetSize()); // } MemoryStreamPtr dbEntryRight(new std::vector); { wxMemoryOutputStream buffer; SaveDirInfo(baseMapping, zToWx(baseMapping.getDBFilename()), buffer); dbEntryRight->resize(buffer.GetSize()); //convert output stream to char-array buffer.CopyTo(&(*dbEntryRight)[0], buffer.GetSize()); // } //create/update DirInfo-streams dbEntriesLeft.second[dbEntriesRight.first] = dbEntryLeft; dbEntriesRight.second[dbEntriesLeft.first] = dbEntryRight; struct TryCleanUp //ensure cleanup if working with temporary failed! { static void tryDeleteFile(const Zstring& filename) //throw () { try { removeFile(filename); } catch (...) {} } }; //write (temp-) files... Loki::ScopeGuard guardTempFileLeft = Loki::MakeGuard(&TryCleanUp::tryDeleteFile, fileNameLeftTmp); saveFile(dbEntriesLeft, fileNameLeftTmp); //throw (FileError) Loki::ScopeGuard guardTempFileRight = Loki::MakeGuard(&TryCleanUp::tryDeleteFile, fileNameRightTmp); saveFile(dbEntriesRight, fileNameRightTmp); //throw (FileError) //operation finished: rename temp files -> this should work transactionally: //if there were no write access, creation of temp files would have failed removeFile(baseMapping.getDBFilename()); removeFile(baseMapping.getDBFilename()); renameFile(fileNameLeftTmp, baseMapping.getDBFilename()); //throw (FileError); renameFile(fileNameRightTmp, baseMapping.getDBFilename()); //throw (FileError); guardTempFileLeft.Dismiss(); //no need to delete temp file anymore guardTempFileRight.Dismiss(); // }