bool XmlParser::InternalParseFile( const char* _filename ) { // load file to buffer // check if file exists ex_assert_return( futil::file::exists(path_t(_filename)), false, "%s not Existss.", _filename ); IFile::smart_ptr_t spFile = futil::file::open<PhysicalFile>(_filename); if ( spFile ) { uint32 filesize = uint32(spFile->size()); int bufferSize = sizeof(tchar) * filesize ; // get internal buffer void* pBuffer = GetBuffer(bufferSize); // read file to buffer spFile->read( pBuffer, filesize ); // close file immediately spFile->close(); // record file name help handle error m_ParsingFileName = _filename; // parse file bool bResult = InternalParseBuffer(bufferSize); m_ParsingFileName = NULL; // return result return bResult; } return false; }
STAGE_RC update_operation::deploy() { debug() << "patching file " << basis_path_ << " using delta " << delta_path_ << " out to " << patched_path_; rs_result rc = encoder_.patch(basis_path_.c_str(), delta_path_.c_str(), patched_path_.c_str()); if (rc != RS_DONE) { error() << "Patching file " << basis_path_ << " using patch " << delta_path_ <<" has failed. librsync rc: " << rc; return STAGE_INTERNAL_ERROR; } hasher::digest_rc digest = hasher::instance()->hex_digest(patched_path_); if (digest != patched_checksum) { error() << "Checksum mismatch: " << digest.digest << " vs " << patched_checksum << " in file " << patched_path_; return STAGE_FILE_INTEGRITY_MISMATCH; } if (rmgr_.stat_filesize(patched_path_) != patched_length) { error() << "Length mismatch: " << rmgr_.stat_filesize(patched_path_) << " to " << patched_length << " in file " << patched_path_; return STAGE_FILE_INTEGRITY_MISMATCH; } // swap the files debug() << "Swapping files: " << basis_path_ << " & " << patched_path_; fs::rename(patched_path_, path_t(patched_path_.string() + ".tmp")); fs::rename(basis_path_, patched_path_); fs::rename(path_t(patched_path_.string() + ".tmp"), basis_path_); patched_ = true; return STAGE_OK; }
std::wstring normalize_path(const std::wstring &path){ std::wstring ret; size_t skip = 0; if (starts_with(path, system_path_prefix)){ ret = system_path_prefix; skip = 4; } ret += path_t(path.substr(skip)).normalize().wstring(); std::transform(ret.begin(), ret.end(), ret.begin(), [](wchar_t c){ return c == '/' ? '\\' : c; }); return ret; }
// On Windows and Linux, root is KZH_DISTANCE_FROM_ROOT directories up from // the binary's path_t locate_root_directory(const path_t& bin_path) { #if KZH_PLATFORM == KZH_PLATFORM_APPLE return path_t(bin_path).remove_leaf().make_preferred(); #else path_t root_path(bin_path); for (int i = 0; i < KZH_DISTANCE_FROM_ROOT; ++i) { root_path = root_path.remove_leaf(); } return root_path.make_preferred(); #endif }
path_t locate_bin_directory(const logger* log, bool verbose) { // locate the binary and build its path #if KZH_PLATFORM == KZH_PLATFORM_LINUX // use binreloc and fs to build up our paths int brres = br_init(0); if (brres == 0) { if (verbose) { log->error() << "binreloc could not be initialised"; } throw std::runtime_error("Unable to resolve paths! binreloc could not be initialized"); } char *tmp_bin_path = br_find_exe_dir("."); path_t bin_path = path_t(tmp_bin_path).make_preferred(); free(tmp_bin_path); br_free(); return bin_path; #elif KZH_PLATFORM == KZH_PLATFORM_APPLE // use NSBundlePath() to build up our paths // return path_t(macBundlePath() + "/Contents/MacOS").make_preferred(); return path_t(macBundlePath()).make_preferred(); #else // Windows // use GetModuleFileName() and fs to build up our paths on Windows TCHAR szPath[MAX_PATH]; if (!GetModuleFileName(NULL, szPath, MAX_PATH)) { if (verbose) { log->error() << "Unable to resolve path: " << GetLastError();; } throw std::runtime_error("Unable to resolve paths! GetModuleFileName() failed. See the log for the error."); } return path_t(string_t(szPath)).remove_filename().make_preferred(); #endif }
STAGE_RC update_operation::deploy() { auto file_manager = config_.file_manager; debug() << "patching file " << basis_path_ << " using delta " << delta_path_ << " out to " << patched_path_; if ( !file_manager->is_readable(basis_path_) || !file_manager->is_readable(delta_path_) ) { return STAGE_INVALID_STATE; } rs_result rc = encoder_.patch(basis_path_.c_str(), delta_path_.c_str(), patched_path_.c_str()); if (rc != RS_DONE) { error() << "Patching file " << basis_path_ << " using patch " << delta_path_ <<" has failed. librsync rc: " << rc; return STAGE_ENCODING_ERROR; } hasher::digest_rc digest = config_.hasher->hex_digest(patched_path_); if (digest != patched_checksum) { error() << "Checksum mismatch: " << digest.digest << " vs " << patched_checksum << " in file " << patched_path_; return STAGE_FILE_INTEGRITY_MISMATCH; } const path_t temp_path(path_t(patched_path_.string() + ".tmp").make_preferred()); // move the patched file to a temporary location until we can move it over // to the destination: file_manager->move(patched_path_, temp_path); // free the destination; move the old file to where the patched file was so // that we can roll back if necessary: file_manager->move(basis_path_, patched_path_); // !! repository side effect !! // finally, move over the patched file to where the old file was: file_manager->move(temp_path, basis_path_); // !! repository side effect !! patched_ = true; return STAGE_OK; }
void path_resolver::resolve(path_t root, bool verbose) { if (root.empty()) { root_path_ = locate_root_directory(locate_bin_directory(this, verbose)); } else { root_path_ = root; } // locate the binary and build its path #if KZH_PLATFORM == KZH_PLATFORM_LINUX // Linux: if (verbose) { debug() << "Platform: Linux"; } cache_path_ = path_t(root_path_ / ".kzh/cache").make_preferred(); #elif KZH_PLATFORM == KZH_PLATFORM_APPLE // OS X: if (verbose) { debug() << "Platform: OS X"; } cache_path_ = path_t(root_path_ / ".kzh/cache").make_preferred(); #else // Windows: if (verbose) { debug() << "Platform: Windows"; } cache_path_ = path_t(root_path_ / ".kzh/cache").make_preferred(); #endif if (verbose) { debug() << "Root path: " << root_path_; debug() << "Cache path: " << cache_path_; } }
BackupMode BackupSystem::get_backup_mode_for_object(const FileSystemObject &fso, bool &follow_link_targets){ follow_link_targets = false; bool dir = fso.is_directoryish(); auto it = this->ignored_names.find(fso.get_name()); if (it != this->ignored_names.end()){ auto ignore_type = it->second; if (((unsigned)ignore_type & (unsigned)NameIgnoreType::File) && !dir) return BackupMode::NoBackup; if (((unsigned)ignore_type & (unsigned)NameIgnoreType::Directory) && dir) return BackupMode::NoBackup; } if (this->ignored_extensions.find(path_t(fso.get_name()).extension().wstring()) != this->ignored_extensions.end() && !dir) return BackupMode::NoBackup; if (this->ignored_paths.find(*fso.get_unmapped_base_path()) != this->ignored_paths.end()) return BackupMode::NoBackup; return dir ? BackupMode::Directory : BackupMode::Full; }
config_set::path_t config_set::_pathFromString (string const &strPath) const { return path_t (strPath); }
path_t get_value() { return path_t (field); }
STAGE_RC update_operation::stage() { basis_path_ = rmgr_.root_path() / basis; cache_dir_ = path_t(rmgr_.cache_path() / rm_.checksum / basis).parent_path(); signature_path_ = cache_dir_ / (path_t(basis).filename().string() + ".signature"); delta_path_ = cache_dir_ / (path_t(basis).filename().string() + ".delta"); patched_path_ = cache_dir_ / (path_t(basis).filename().string() + ".patched"); // basis must exist if (!rmgr_.is_readable(basis_path_)) { error() << "basis file does not exist at: " << basis_path_; return STAGE_FILE_MISSING; } // basis checksum check hasher::digest_rc digest = hasher::instance()->hex_digest(basis_path_); if (digest != basis_checksum) { error() << "Basis file checksum mismatch: " << digest.digest << " vs " << basis_checksum << " in file " << basis_path_; return STAGE_FILE_INTEGRITY_MISMATCH; } if (rmgr_.stat_filesize(basis_path_) != basis_length) { error() << "Length mismatch: " << rmgr_.stat_filesize(basis_path_) << " to " << basis_length << " in file " << basis_path_; return STAGE_FILE_INTEGRITY_MISMATCH; } // prepare our cache directory, if necessary if (!fs::is_directory(cache_dir_)) { if (!rmgr_.create_directory(cache_dir_)) { error() << "Unable to create cache directory: " << cache_dir_; return STAGE_UNAUTHORIZED; } } // TODO: free space checks, need at least 2x basis file size + delta size // get the delta patch if (!rmgr_.get_remote(delta, delta_path_, delta_checksum, delta_length)) { throw invalid_resource(delta); } // create the signature debug() << "generating signature for " << basis_path_ << " out to " << signature_path_; rs_result rc = encoder_.signature(basis_path_.c_str(), signature_path_.c_str()); if (rc != RS_DONE) { error() << "Generating of signature for file " << basis_path_ << " has failed. librsync rc: " << rc; return STAGE_INTERNAL_ERROR; } return STAGE_OK; }