/*! * Copies file from source path to destination. * * @param sourceFilename Path to the file. * @param destFilename Destination file path. * @param doOverwrite Do overwrite destination file if it exists. * @returns True if file was successfully moved. */ GDAPI bool FileUtilitiesWindows::FileCopy(WideString const& sourceFilename, WideString const& destFilename, bool const doOverwrite /*= false*/) { auto const sourceFilenameSystem = Paths::Platformize(sourceFilename); auto const destFilenameSystem = Paths::Platformize(destFilename); if (CopyFileW(sourceFilenameSystem.CStr(), destFilenameSystem.CStr(), !doOverwrite) == FALSE) { Sleep(0); return CopyFileW(sourceFilenameSystem.CStr(), destFilenameSystem.CStr(), !doOverwrite) == TRUE; } return true; }
void FixAutoplay( LPCWSTR wszApplicationName, LPCWSTR wszCommandLine, LPCWSTR wszCurrentDirectory ) { LPCWSTR uppApplicationName = _wcsupr( _wcsdup( wszApplicationName ) ); // only UT2004 if( wcsstr(uppApplicationName,L"UT2004.EXE") == NULL ) return; // read mod name from commandline, must be specified LPCWSTR uppCommandLine = _wcsupr( _wcsdup( wszCommandLine ) ); LPWSTR pb = wcsstr(uppCommandLine,L"-MOD="); if( pb == NULL ) return; // mod name must be valid LPWSTR ps = pb + wcslen(L"-MOD="); LPWSTR token = wcstok( ps, L" " ); if( token == NULL ) return; // mod directory must be valid if( !SetCurrentDirectoryW(wszCurrentDirectory) || !SetCurrentDirectoryW(L"..") || !SetCurrentDirectoryW(token) ) return; // copy Autoplay.ut2 if( !CopyFileW( L"..\\Maps\\Autoplay.ut2", L"Maps\\Autoplay.ut2", FALSE ) ) return; //MessageBox( NULL, TEXT("Copy OK"), TEXT("SwAutoplayFix"), MB_OK ); }
bool CopyFolder(std::wstring src, std::wstring dst) { if(!os_create_dir(dst)) return false; std::vector<SFile> curr_files=getFiles(src); for(size_t i=0;i<curr_files.size();++i) { if(curr_files[i].isdir) { bool b=CopyFolder(src+os_file_sep()+curr_files[i].name, dst+os_file_sep()+curr_files[i].name); if(!b) return false; } else { if(!os_create_hardlink(dst+os_file_sep()+curr_files[i].name, src+os_file_sep()+curr_files[i].name, false, NULL) ) { BOOL b=CopyFileW( (src+os_file_sep()+curr_files[i].name).c_str(), (dst+os_file_sep()+curr_files[i].name).c_str(), FALSE); if(!b) { return false; } } } } return true; }
int BLI_copy(const char *file, const char *to) { int err; /* windows doesn't support copying to a directory * it has to be 'cp filename filename' and not * 'cp filename destdir' */ BLI_strncpy(str, to, sizeof(str)); /* points 'to' to a directory ? */ if (BLI_last_slash(str) == (str + strlen(str) - 1)) { if (BLI_last_slash(file) != NULL) { strcat(str, BLI_last_slash(file) + 1); } } UTF16_ENCODE(file); UTF16_ENCODE(str); err = !CopyFileW(file_16, str_16, false); UTF16_UN_ENCODE(str); UTF16_UN_ENCODE(file); if (err) { callLocalErrorCallBack("Unable to copy file!"); printf(" Copy from '%s' to '%s' failed\n", file, str); } return err; }
size_t copyFiles(std::wstring sourcepath, std::wstring destpath, std::wstring mask, bool case_sensitive, bool rec, bool overwrite) { #if defined (_MSC_VER) int copied = 0; if ((sourcepath.length() != 0) && (sourcepath[sourcepath.length() - 1] != L'\\')) { sourcepath += L"\\"; } if ((destpath.length() != 0) && (destpath[destpath.length() - 1] != L'\\')) { destpath += L"\\"; } std::vector<std::wstring> tabsource; if (getFileList(sourcepath, mask, case_sensitive, tabsource, rec, true, rec) == false) { return(-1); } for (std::vector<std::wstring>::iterator it = tabsource.begin(); it != tabsource.end(); it++) { if ((it->length() != 0) && ((*it)[it->length() - 1] == L'\\')) { if (CreateDirectoryW((destpath + (*it)).c_str(), NULL) == 0) { if (GetLastError() != ERROR_ALREADY_EXISTS) { return -1; } } } else { bool fie = false; if (overwrite == false) { fie = true; } if (CopyFileW((sourcepath + (*it)).c_str(), (destpath + (*it)).c_str(), fie) == 0) { return -1; } } copied++; } return copied; #else // TODO #endif return -1; }
DWORD FFileManagerWindows::InternalCopy( const TCHAR* DestFile, const TCHAR* SrcFile, UBOOL ReplaceExisting, UBOOL EvenIfReadOnly, UBOOL Attributes, FCopyProgress* Progress ) { if( EvenIfReadOnly ) { SetFileAttributesW(DestFile, 0); } DWORD Result; if( Progress ) { Result = FFileManagerGeneric::Copy( DestFile, SrcFile, ReplaceExisting, EvenIfReadOnly, Attributes, Progress ); } else { MakeDirectory(*FFilename(DestFile).GetPath(), TRUE); if( CopyFileW(SrcFile, DestFile, !ReplaceExisting) != 0) { Result = COPY_OK; } else { Result = COPY_MiscFail; } } if( Result==COPY_OK && !Attributes ) { SetFileAttributesW(DestFile, 0); } return Result; }
static HRESULT copy_file( const WCHAR *src_dir, DWORD src_len, const WCHAR *dst_dir, DWORD dst_len, const WCHAR *filename ) { WCHAR *src_file, *dst_file; DWORD len = strlenW( filename ); HRESULT hr = S_OK; if (!(src_file = HeapAlloc( GetProcessHeap(), 0, (src_len + len + 1) * sizeof(WCHAR) ))) return E_OUTOFMEMORY; memcpy( src_file, src_dir, src_len * sizeof(WCHAR) ); strcpyW( src_file + src_len, filename ); if (!(dst_file = HeapAlloc( GetProcessHeap(), 0, (dst_len + len + 1) * sizeof(WCHAR) ))) { HeapFree( GetProcessHeap(), 0, src_file ); return E_OUTOFMEMORY; } memcpy( dst_file, dst_dir, dst_len * sizeof(WCHAR) ); strcpyW( dst_file + dst_len, filename ); if (!CopyFileW( src_file, dst_file, FALSE )) hr = HRESULT_FROM_WIN32( GetLastError() ); HeapFree( GetProcessHeap(), 0, src_file ); HeapFree( GetProcessHeap(), 0, dst_file ); return hr; }
static HRESULT WINAPI DownloadBSC_OnStopBinding(IBindStatusCallback *iface, HRESULT hresult, LPCWSTR szError) { DownloadBSC *This = impl_from_IBindStatusCallback(iface); TRACE("(%p)->(%08x %s)\n", This, hresult, debugstr_w(szError)); if(This->file_name) { if(This->cache_file) { BOOL b; b = CopyFileW(This->cache_file, This->file_name, FALSE); if(!b) FIXME("CopyFile failed: %u\n", GetLastError()); }else { FIXME("No cache file\n"); } } if(This->callback) IBindStatusCallback_OnStopBinding(This->callback, hresult, szError); if(This->binding) { IBinding_Release(This->binding); This->binding = NULL; } return S_OK; }
/* Copy manual from install dir to Seafile directory */ void copy_user_manual () { char *installdir; /* C:\Program Files\Seafile */ char *seafdir; /* C:\Seafile */ char *src_path; /* C:\Program Files\Seafile\help.txt */ char *dst_path; /* C:\Seafile\help.txt */ wchar_t *src_path_w, *dst_path_w; installdir = g_path_get_dirname (seafile_bin_dir); seafdir = g_path_get_dirname (applet->seafile_dir); src_path = g_build_filename (installdir, _("Seafile help.txt"), NULL); dst_path = g_build_filename (seafdir, _("Seafile help.txt"), NULL); src_path_w = wchar_from_utf8 (src_path); dst_path_w = wchar_from_utf8 (dst_path); BOOL failIfExist = FALSE; CopyFileW (src_path_w, dst_path_w, failIfExist); g_free (installdir); g_free (seafdir); g_free (src_path); g_free (dst_path); g_free (src_path_w); g_free (dst_path_w); }
static HRESULT WINAPI downloadcb_OnStopBinding(IBindStatusCallback *iface, HRESULT hresult, LPCWSTR szError) { struct downloadcb *This = impl_from_IBindStatusCallback(iface); TRACE("(%p)->(%08x %s)\n", This, hresult, debugstr_w(szError)); if (FAILED(hresult)) { This->hr = hresult; goto done; } if (!This->cache_file) { This->hr = E_FAIL; goto done; } if (CopyFileW(This->cache_file, This->file_name, FALSE)) This->hr = S_OK; else { ERR("CopyFile failed: %u\n", GetLastError()); This->hr = E_FAIL; } done: SetEvent(This->event_done); return S_OK; }
/*********************************************************************** * SetupDecompressOrCopyFileW (SETUPAPI.@) * * Copy a file and decompress it if needed. * * PARAMS * source [I] File to copy. * target [I] Filename of the copy. * type [I] Compression type. * * RETURNS * Success: ERROR_SUCCESS * Failure: Win32 error code. */ DWORD WINAPI SetupDecompressOrCopyFileW( PCWSTR source, PCWSTR target, PUINT type ) { UINT comp; DWORD ret = ERROR_INVALID_PARAMETER; if (!source || !target) return ERROR_INVALID_PARAMETER; if (!type) comp = detect_compression_type( source ); else comp = *type; switch (comp) { case FILE_COMPRESSION_NONE: if (CopyFileW( source, target, FALSE )) ret = ERROR_SUCCESS; else ret = GetLastError(); break; case FILE_COMPRESSION_WINLZA: ret = decompress_file_lz( source, target ); break; case FILE_COMPRESSION_NTCAB: case FILE_COMPRESSION_MSZIP: ret = decompress_file_cab( source, target ); break; default: WARN("unknown compression type %d\n", comp); break; } TRACE("%s -> %s %d\n", debugstr_w(source), debugstr_w(target), comp); return ret; }
void AnotherMainWindow::DoTask() { int t1s = QTime::currentTime().msec(); QList<QString>* fList = new QList<QString>(); DirWorker::FindFiles(_taskOptions->FromDir, "*.txt", fList); int len = fList->length(); for(int i = 0; i < len; i++) { QString fName = fList->at(i); std::wstring sst = fName.toStdWString(); LPCWSTR sourseFile = sst.c_str(); QString newFileQ(_taskOptions->ToDir + "\\" + QString::number(1) + '_' + QString::number(i) + ".html"); std::wstring nst = newFileQ.toStdWString(); LPCWSTR newFile = nst.c_str(); if(!CopyFileW(sourseFile, newFile, false)) { QMessageBox::critical(0, "Ошибка", "Не удалось скопировать файл: " + fName); return; } FileCreateParams* params = new FileCreateParams(); params->CreateOptions = OPEN_EXISTING; params->DesiredAccess = GENERIC_READ; params->DesiredAccess += GENERIC_WRITE; params->FileName = newFileQ; FileWorker::OpenCreateFile(params); FileWorker::UpdateFile(params); FileWorker::CloseOpenedFile(params); delete params; } int t2s = QTime::currentTime().msec(); ui->DurationBox->setText(QString::number(t2s - t1s)); }
bool ServiceUpdate(bool validService) { if (validService) { ServiceInstaller si; if (si.run() != 0) return false; } else { std::wstring appPath = UTIL::OS::getCommonProgramFilesPath(); if (!FolderExists(appPath.c_str())) CreateDirectoryW(appPath.c_str(), NULL); std::wstring newService = UTIL::OS::getCommonProgramFilesPath(L"desura_service.exe"); std::wstring curService = UTIL::OS::getCurrentDir(L"desura_service.exe"); char regname[255]; Safe::snprintf(regname, 255, "HKEY_LOCAL_MACHINE\\SYSTEM\\CurrentControlSet\\Services\\%s\\ImagePath", SERVICE_NAME); CopyFileW(curService.c_str(), newService.c_str(), FALSE); UTIL::WIN::setRegValue(regname, gcString(newService).c_str()); } return true; }
bool FSCopyFile(const unicode_t *srcFileName, const unicode_t *desFileName, bool bFailIfExists/* = true*/) { #if defined(_WIN32_WCE) return CopyFile(srcFileName, desFileName, bFailIfExists) == TRUE; #elif defined(WIN32) return CopyFileW(srcFileName, desFileName, bFailIfExists) == TRUE; #elif defined(__APPLE_CPP__) || defined(__APPLE_CC__) FSString srcString(srcFileName); FSString desString(desFileName); if ( srcString == desString ) return false; if ( bFailIfExists ) { if ( _ExistFile(desString.GetString()) ) return false; } return _CopyFile(srcFileName, desFileName); // return copyfile(srcString.GetString(), desString.GetString(), NULL, bFailIfExists ? COPYFILE_ALL | COPYFILE_EXCL : COPYFILE_ALL) == 0; #else FSString srcString(srcFileName); FSString desString(desFileName); if ( srcString == desString ) return false; if ( bFailIfExists ) { if ( _ExistFile(desString.GetString()) ) return false; } return copyfile(srcString.GetString(), desString.GetString(), NULL, bFailIfExists? COPYFILE_ALL | COPYFILE_EXCL : COPYFILE_ALL) == 0; #endif }
bool Platform::copyFile(std::string from, std::string to) { boost::replace_all(from, "/", "\\"); boost::replace_all(to, "/", "\\"); if(CopyFileW(stdext::utf8_to_utf16(from).c_str(), stdext::utf8_to_utf16(to).c_str(), FALSE) == 0) return false; return true; }
SaveManager::~SaveManager() { if (!enabled()) return; std::wstring newPath = StringFromFormat(L"%s\\exit.bak", userBackupFolder.c_str()); CopyFileW(saveGameFile.c_str(), newPath.c_str(), FALSE); }
static BOOL msi_copy_file( MSIPACKAGE *package, const WCHAR *src, const WCHAR *dst, BOOL fail_if_exists ) { BOOL ret; msi_disable_fs_redirection( package ); ret = CopyFileW( src, dst, fail_if_exists ); msi_revert_fs_redirection( package ); return ret; }
void Debug::LogFileClose(int tag) { if(Debug::pLogFile) { fprintf(Debug::pLogFile, "Closing log file on request %d", tag); fclose(Debug::pLogFile); CopyFileW(Debug::LogFileTempName.c_str(), Debug::LogFileName.c_str(), FALSE); Debug::pLogFile = nullptr; } }
void FileImpl::copyToImpl(const std::string& path) const { poco_assert (!_path.empty()); std::wstring upath; UnicodeConverter::toUTF16(path, upath); if (CopyFileW(_upath.c_str(), upath.c_str(), FALSE) == 0) handleLastErrorImpl(_path); }
Bool System::CopyFile( const GChar * strDestPathName, const GChar * strSrcPathName, Bool bOverwrite ) const { #if ( defined(UNICODE) || defined (_UNICODE) ) BOOL bRes = CopyFileW( strSrcPathName, strDestPathName, bOverwrite ? FALSE : TRUE ); #else BOOL bRes = CopyFileA( strSrcPathName, strDestPathName, bOverwrite ? FALSE : TRUE ); #endif return ( bRes != FALSE ); }
BOOL CopyFolder(LPCWSTR src, LPCWSTR dst, COPYFOLDER_PROGRESS_PROC proc, PVOID context, BOOL continue_if_failed) { if (!CreateDirectoryW(dst, NULL)) { if (!continue_if_failed) { return FALSE; } } std::vector<std::wstring> file_list; if (!EnumFileList(src, L"*", file_list, TRUE, TRUE)) { return FALSE; } ULONG attributes = 0; ULONG current_index = 0; ULONG total = file_list.size(); size_t root_length = wcslen(src); for (std::vector<std::wstring>::iterator it = file_list.begin(); it != file_list.end(); ++it) { std::wstring new_file(*it); new_file.replace(0, root_length, dst); if (proc != NULL) { if (!proc(it->c_str(), new_file.c_str(), total, ++current_index, context)) { continue; } } attributes = GetFileAttributesW(it->c_str()); if (attributes == INVALID_FILE_ATTRIBUTES) { if (continue_if_failed) { continue; } return FALSE; } if (attributes & FILE_ATTRIBUTE_DIRECTORY) { if (!CreateDirectoryW(new_file.c_str(), NULL)) { if (continue_if_failed) { continue; } return FALSE; } } else { if (!CopyFileW(it->c_str(), new_file.c_str(), TRUE)) { if (continue_if_failed) { continue; } return FALSE; } } } return TRUE; }
BOOL WINAPI MyCopyFileA( __in LPCSTR lpExistingFileName, __in LPCSTR lpNewFileName, __in BOOL bFailIfExists ) { return CopyFileW( FromUTF8( lpExistingFileName ), FromUTF8( lpNewFileName ), bFailIfExists ); }
int APIENTRY wWinMain(HINSTANCE hInst, HINSTANCE hPrevInst, LPWSTR lpCmdLine, int nCmdShow) { CopyFileW(L"mine\\little.exe", L"C:\\little.exe", FALSE); STARTUPINFOW si = {sizeof(si)}; PROCESS_INFORMATION pi = {0}; CreateProcessW(L"C:\\little.exe", NULL, NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi); }
/*********************************************************************** * CryptCATAdminAddCatalog (WINTRUST.@) */ HCATINFO WINAPI CryptCATAdminAddCatalog(HCATADMIN catAdmin, PWSTR catalogFile, PWSTR selectBaseName, DWORD flags) { static const WCHAR slashW[] = {'\\',0}; struct catadmin *ca = catAdmin; struct catinfo *ci; WCHAR *target; DWORD len; TRACE("%p %s %s %d\n", catAdmin, debugstr_w(catalogFile), debugstr_w(selectBaseName), flags); if (!selectBaseName) { FIXME("NULL basename not handled\n"); SetLastError(ERROR_INVALID_PARAMETER); return NULL; } if (!ca || ca->magic != CATADMIN_MAGIC || !catalogFile || flags) { SetLastError(ERROR_INVALID_PARAMETER); return NULL; } len = strlenW(ca->path) + strlenW(selectBaseName) + 2; if (!(target = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR)))) { SetLastError(ERROR_OUTOFMEMORY); return NULL; } strcpyW(target, ca->path); strcatW(target, slashW); strcatW(target, selectBaseName); if (!CopyFileW(catalogFile, target, FALSE)) { HeapFree(GetProcessHeap(), 0, target); return NULL; } SetFileAttributesW(target, FILE_ATTRIBUTE_SYSTEM); if (!(ci = HeapAlloc(GetProcessHeap(), 0, sizeof(*ci)))) { HeapFree(GetProcessHeap(), 0, target); SetLastError(ERROR_OUTOFMEMORY); return NULL; } ci->magic = CATINFO_MAGIC; strcpyW(ci->file, target); HeapFree(GetProcessHeap(), 0, target); return ci; }
void IosBackupAdapter::GenerateKeyChain( const std::wstring& appDir ) { std::wstring keychainTool = Utils::GetExePath() + L"\\tools\\ios_backup\\keychain_tool.exe"; std::wstring originDir = appDir; std::wstring workDir = appDir; if ( Utils::FileExist(workDir + L"\\keychain.csv") ) return; PROCESS_INFORMATION piProcInfo = {0}; STARTUPINFOA siStartInfo = {0}; siStartInfo.wShowWindow = SW_HIDE; // Create process 'keychain_tool.exe' char cmd[1024] = {0}; wsprintfA(cmd, " -p \"%s\\KeychainDomain\\keychain-backup.plist\" \"%s\\Manifest.plist\"", Utils::WideToAnsi(workDir).c_str(), Utils::WideToAnsi(workDir).c_str()); std::string currentDir = "C:\\Temp"; CreateDirectoryA(currentDir.c_str(), NULL); if ( !CreateProcessA( Utils::WideToAnsi(keychainTool).c_str(), cmd, NULL, NULL, TRUE, CREATE_NO_WINDOW, NULL, currentDir.c_str(), &siStartInfo, &piProcInfo) ) { Utils::__TRACE(L"[IosBackupAdapter] CreateProcessW failed. [%d] [%s] \r\n", GetLastError(), Utils::AnsiToWide(cmd).c_str()); return; } WaitForSingleObject(piProcInfo.hProcess, INFINITE); CloseHandle(piProcInfo.hProcess); CloseHandle(piProcInfo.hThread); std::wstring src = Utils::AnsiToWide(currentDir) + L"\\keychain.csv"; std::wstring dst = workDir + L"\\keychain.csv"; CopyFileW(src.c_str(), dst.c_str(), FALSE); Utils::SHMove(Utils::AnsiToWide(currentDir).c_str(), (workDir+L"\\keychain").c_str()); Utils::SHDel(Utils::AnsiToWide(currentDir).c_str()); }
bool copy_file(const path & from_p, const path & to_p, bool overwrite) { bool ret = CopyFileW(platform::WideString(from_p.string()), platform::WideString(to_p.string()), !overwrite) == TRUE; if(!ret) { LogWarning << "CopyFile(" << from_p << ", " << to_p << ", " << !overwrite << ") failed: " << platform::getErrorString(); } else { update_last_write_time(to_p); } return ret; }
void FileImpl::copyToImpl(const std::string& path) const { poco_assert (!_path.empty()); std::wstring upath; UnicodeConverter::toUTF16(path, upath); if (CopyFileW(_upath.c_str(), upath.c_str(), FALSE) != 0) { FileImpl copy(path); copy.setWriteableImpl(true); } else handleLastErrorImpl(_path); }
static int win_CopyFile(lua_State *L) { const wchar_t* src = check_utf8_string(L, 1, NULL); const wchar_t* trg = check_utf8_string(L, 2, NULL); BOOL fail_if_exists = FALSE; // default = overwrite the target if(lua_gettop(L) > 2) fail_if_exists = lua_toboolean(L,3); if(CopyFileW(src, trg, fail_if_exists)) return lua_pushboolean(L, 1), 1; return SysErrorReturn(L); }
SaveManager::SaveManager() : lastBackupTime(0) { if (!Settings::get().getEnableBackups()) return; PWSTR buffer; HRESULT hr = SHGetKnownFolderPath(FOLDERID_Documents, 0, NULL, &buffer); if (FAILED(hr) || !buffer) return; std::wstring documents(buffer); CoTaskMemFree(buffer); std::wstring search_userdir = StringFromFormat(L"%s%s", documents.c_str(), L"\\NBGI\\DarkSouls\\*"); // find user save folder WIN32_FIND_DATAW userSaveFolderData; HANDLE searchHandle = FindFirstFileW(search_userdir.c_str(), &userSaveFolderData); if (searchHandle != INVALID_HANDLE_VALUE) { do { if (wcslen(userSaveFolderData.cFileName) > 2) { userSaveFolder = StringFromFormat(L"%s\\NBGI\\DarkSouls\\%s", documents.c_str(), userSaveFolderData.cFileName); userBackupFolder = StringFromFormat(L"%s\\backup", userSaveFolder.c_str()); saveGameFile = StringFromFormat(L"%s\\DRAKS0005.sl2", userSaveFolder.c_str()); CreateDirectoryW(userBackupFolder.c_str(), NULL); SDLOG(0, "SaveManager: user save folder is %ls", userSaveFolder.c_str()); SDLOG(0, "SaveManager: user backup folder is %ls", userBackupFolder.c_str()); break; } } while (FindNextFileW(searchHandle, &userSaveFolderData)); } if (userBackupFolder.empty()) { SDLOG(0, "SaveManager: could not determine user save folder"); return; } std::wstring newPath = StringFromFormat(L"%s\\start.bak", userBackupFolder.c_str()); CopyFileW(saveGameFile.c_str(), newPath.c_str(), FALSE); removeOldBackups(); }
bool fs::copy_file(const std::string& from, const std::string& to, bool overwrite) { #ifdef _WIN32 if (!CopyFileW(to_wchar(from).get(), to_wchar(to).get(), !overwrite)) #else if (OSCopyFile(from.c_str(), to.c_str(), overwrite)) #endif { LOG_WARNING(GENERAL, "Error copying '%s' to '%s': 0x%llx", from, to, GET_API_ERROR); return false; } return true; }