void CFriendList::LoadList() { CPath metfile = CPath(theApp->ConfigDir + wxT("emfriends.met")); if (!metfile.FileExists()) { return; } CFile file; try { if ( file.Open(metfile) ) { if ( file.ReadUInt8() /*header*/ == MET_HEADER ) { uint32 nRecordsNumber = file.ReadUInt32(); for (uint32 i = 0; i < nRecordsNumber; i++) { CFriend* Record = new CFriend(); Record->LoadFromFile(&file); m_FriendList.push_back(Record); Notify_ChatUpdateFriend(Record); } } } else { AddLogLineN(_("Failed to open friend list file 'emfriends.met' for reading!")); } } catch (const CInvalidPacket& e) { AddDebugLogLineC(logGeneral, wxT("Invalid entry in friend list, file may be corrupt: ") + e.what()); } catch (const CSafeIOException& e) { AddDebugLogLineC(logGeneral, wxT("IO error while reading 'emfriends.met': ") + e.what()); } }
bool BackupTaskState(void) throw() { CPath path; bool bRet = false; if (GetIniFile(path)) { CString temp; bRet = true; // get storage name if (GetConfigString(temp, path, _T("storage"), STORAGE_NAME)) { path.RemoveFileSpec(); path.Append(temp); if (path.FileExists()) { temp = (LPCTSTR)path; // store existing path.RenameExtension(_T(".bak")); bRet = (::MoveFileEx(temp, path, MOVEFILE_REPLACE_EXISTING) != 0); } } } return bRet; }
bool CDownloadQueue::IsFileExisting( const CMD4Hash& fileid ) const { if (CKnownFile* file = theApp->sharedfiles->GetFileByID(fileid)) { if (file->IsPartFile()) { AddLogLineC(CFormat( _("You are already trying to download the file '%s'") ) % file->GetFileName()); } else { // Check if the file exists, since otherwise the user is forced to // manually reload the shares to download a file again. CPath fullpath = file->GetFilePath().JoinPaths(file->GetFileName()); if (!fullpath.FileExists()) { // The file is no longer available, unshare it theApp->sharedfiles->RemoveFile(file); return false; } AddLogLineC(CFormat( _("You already have the file '%s'") ) % file->GetFileName()); } return true; } else if ((file = GetFileByID(fileid))) { AddLogLineC(CFormat( _("You are already trying to download the file %s") ) % file->GetFileName()); return true; } return false; }
bool CFile::Create(const CPath& path, bool overwrite, int accessMode) { if (!overwrite && path.FileExists()) { return false; } return Open(path, write, accessMode); }
virtual void setUp() { const CPath path = CPath(wxT("testfile.txt")); if (path.FileExists()) { ASSERT_TRUE(CPath::RemoveFile(path)); } }
TEST(CPath, DefaultConstructor) { CPath tmp; ASSERT_FALSE(tmp.IsOk()); ASSERT_EQUALS(tmp, CPath()); ASSERT_FALSE(tmp.FileExists()); ASSERT_FALSE(tmp.DirExists()); ASSERT_EQUALS(wxEmptyString, tmp.GetRaw()); ASSERT_EQUALS(wxEmptyString, tmp.GetPrintable()); ASSERT_EQUALS(CPath(), tmp.GetPath()); ASSERT_EQUALS(CPath(), tmp.GetFullName()); }
bool CKnownFileList::Init() { CFile file; CPath fullpath = CPath(theApp->ConfigDir + m_filename); if (!fullpath.FileExists()) { // This is perfectly normal. The file was probably either // deleted, or this is the first time running aMule. return false; } if (!file.Open(fullpath)) { AddLogLineC(CFormat(_("WARNING: %s cannot be opened.")) % m_filename); return false; } try { uint8 version = file.ReadUInt8(); if ((version != MET_HEADER) && (version != MET_HEADER_WITH_LARGEFILES)) { AddLogLineC(_("WARNING: Known file list corrupted, contains invalid header.")); return false; } wxMutexLocker sLock(list_mut); uint32 RecordsNumber = file.ReadUInt32(); AddDebugLogLineN(logKnownFiles, CFormat(wxT("Reading %i known files from file format 0x%2.2x.")) % RecordsNumber % version); for (uint32 i = 0; i < RecordsNumber; i++) { CScopedPtr<CKnownFile> record; if (record->LoadFromFile(&file)) { AddDebugLogLineN(logKnownFiles, CFormat(wxT("Known file read: %s")) % record->GetFileName()); Append(record.release()); } else { AddLogLineC(_("Failed to load entry in known file list, file may be corrupt")); } } AddDebugLogLineN(logKnownFiles, wxT("Finished reading known files")); return true; } catch (const CInvalidPacket& e) { AddLogLineC(_("Invalid entry in known file list, file may be corrupt: ") + e.what()); } catch (const CSafeIOException& e) { AddLogLineC(CFormat(_("IO error while reading %s file: %s")) % m_filename % e.what()); } return false; }
void CPartFileConvert::ConvertToeMule(const CPath& file, bool deletesource) { if (!file.FileExists()) { return; } ConvertJob* newjob = new ConvertJob(file, deletesource, CONV_QUEUE); wxMutexLocker lock(s_mutex); s_jobs.push_back(newjob); Notify_ConvertUpdateJobInfo(newjob); StartThread(); }
bool CCanceledFileList::Init() { CFile file; CPath fullpath = CPath(theApp->ConfigDir + m_filename); if (!fullpath.FileExists()) { // This is perfectly normal. The file was probably either // deleted, or this is the first time running aMule. return false; } if (!file.Open(fullpath)) { AddLogLineM(true, CFormat(_("WARNING: %s cannot be opened.")) % m_filename); return false; } try { uint8 version = file.ReadUInt8(); if (version != CANCELEDFILE_VERSION) { AddLogLineM(true, _("WARNING: Canceled file list corrupted, contains invalid header.")); return false; } uint32 RecordsNumber = file.ReadUInt32(); AddDebugLogLineM(false, logKnownFiles, CFormat(wxT("Reading %i canceled files from file format 0x%02x.")) % RecordsNumber % version); for (uint32 i = 0; i < RecordsNumber; i++) { CMD4Hash hash; file.Read(hash.GetHash(), 16); AddDebugLogLineM(false, logKnownFiles, CFormat(wxT("Canceled file read: %s")) % hash.Encode()); if (!hash.IsEmpty()) { m_canceledFileList.insert(hash); } } AddDebugLogLineM(false, logKnownFiles, wxT("Finished reading canceled files")); return true; } catch (const CSafeIOException& e) { AddLogLineM(true, CFormat(_("IO error while reading %s file: %s")) % m_filename % e.what()); } return false; }
bool CTextFile::Open(const CPath& path, EOpenMode mode) { // wxFFile doesn't call close itself, but asserts instead. Close(); m_mode = mode; if (mode == read) { if (path.FileExists()) { m_file.Open(path.GetRaw(), wxT("r")); } } else if (mode == write) { m_file.Open(path.GetRaw(), wxT("w")); } else { wxFAIL; } return IsOpened(); }
void CPrefs::ReadFile() { const CPath path = CPath(m_filename); try { CFile file; if (path.FileExists() && file.Open(path, CFile::read)) { m_ip = file.ReadUInt32(); file.ReadUInt16(); m_clientID = file.ReadUInt128(); // get rid of invalid kad IDs which may have been stored by older versions if (m_clientID == 0) m_clientID = GetRandomUint128(); file.Close(); } } catch (const CSafeIOException& e) { AddDebugLogLineC(logKadPrefs, wxT("IO error while reading prefs: ") + e.what()); } }
void CPlayerPlaylistBar::LoadPlaylist(LPCTSTR filename) { CString base; if (AfxGetMyApp()->GetAppSavePath(base)) { CPath p; p.Combine(base, _T("default.mpcpl")); if (p.FileExists()) { if (AfxGetAppSettings().bRememberPlaylistItems) { ParseMPCPlayList(p); Refresh(); SelectFileInPlaylist(filename); } else { ::DeleteFile(p); } } } }
bool CWebServer::ToLocalPath(CString& path, CString& redir) { if(!path.IsEmpty() && m_webroot.IsDirectory()) { CString str = path; str.Replace('/', '\\'); str.TrimLeft('\\'); CPath p; p.Combine(m_webroot, str); p.Canonicalize(); if(p.IsDirectory()) { CAtlList<CString> sl; Explode(AfxGetAppSettings().WebDefIndex, sl, ';'); POSITION pos = sl.GetHeadPosition(); while(pos) { str = sl.GetNext(pos); CPath p2 = p; p2.Append(str); if(p2.FileExists()) { p = p2; redir = path; if(redir.GetAt(redir.GetLength()-1) != '/') redir += '/'; redir += str; break; } } } if(_tcslen(p) > _tcslen(m_webroot) && p.FileExists()) { path = (LPCTSTR)p; return true; } } return false; }
void CPlayerPlaylistBar::SavePlaylist() { CString base; if (AfxGetMyApp()->GetAppSavePath(base)) { CPath p; p.Combine(base, _T("default.mpcpl")); if (AfxGetAppSettings().bRememberPlaylistItems) { // Only create this folder when needed if (!::PathFileExists(base)) { ::CreateDirectory(base, NULL); } SaveMPCPlayList(p, CTextFile::UTF8, false); } else if (p.FileExists()) { ::DeleteFile(p); } } }
bool CFile::Open(const CPath& fileName, OpenMode mode, int accessMode) { MULE_VALIDATE_PARAMS(fileName.IsOk(), wxT("CFile: Cannot open, empty path.")); if (IsOpened()) { Close(); } m_safeWrite = false; m_filePath = fileName; #ifdef __linux__ int flags = O_BINARY | O_LARGEFILE; #else int flags = O_BINARY; #endif switch ( mode ) { case read: flags |= O_RDONLY; break; case write_append: if (fileName.FileExists()) { flags |= O_WRONLY | O_APPEND; break; } //else: fall through as write_append is the same as write if the // file doesn't exist case write: flags |= O_WRONLY | O_CREAT | O_TRUNC; break; case write_safe: flags |= O_WRONLY | O_CREAT | O_TRUNC; m_filePath = m_filePath.AppendExt(wxT(".new")); m_safeWrite = true; break; case write_excl: flags |= O_WRONLY | O_CREAT | O_EXCL; break; case read_write: flags |= O_RDWR; break; } // Windows needs wide character file names #ifdef __WINDOWS__ m_fd = _wopen(m_filePath.GetRaw().c_str(), flags, accessMode); #else Unicode2CharBuf tmpFileName = filename2char(m_filePath.GetRaw()); wxASSERT_MSG(tmpFileName, wxT("Convertion failed in CFile::Open")); m_fd = open(tmpFileName, flags, accessMode); #endif syscall_check(m_fd != fd_invalid, m_filePath, wxT("opening file")); return IsOpened(); }
/** * \brief */ bool Settings::Load() { SetDefaults(); CPath cfgFile; INpp::Get().GetPluginsConfDir(cfgFile); cfgFile += cPluginCfgFileName; if (!cfgFile.FileExists()) return false; FILE* fp; _tfopen_s(&fp, cfgFile.C_str(), _T("rt")); if (fp == NULL) return false; bool success = true; TCHAR line[8192]; while (_fgetts(line, _countof(line), fp)) { // Comment or empty line if (line[0] == _T('#') || line[0] == _T('\n')) continue; // Strip newline from the end of the line line[_tcslen(line) - 1] = 0; if (!_tcsncmp(line, cUseDefDbKey, _countof(cUseDefDbKey) - 1)) { const unsigned pos = _countof(cUseDefDbKey) - 1; if (!_tcsncmp(&line[pos], _T("yes"), _countof(_T("yes")) - 1)) _useDefDb = true; else _useDefDb = false; } else if (!_tcsncmp(line, cDefDbPathKey, _countof(cDefDbPathKey) - 1)) { const unsigned pos = _countof(cDefDbPathKey) - 1; _defDbPath = &line[pos]; _defDbPath.AsFolder(); if (!_defDbPath.Exists()) _defDbPath.Clear(); } else if (!_tcsncmp(line, cREOptionKey, _countof(cREOptionKey) - 1)) { const unsigned pos = _countof(cREOptionKey) - 1; if (!_tcsncmp(&line[pos], _T("yes"), _countof(_T("yes")) - 1)) _re = true; else _re = false; } else if (!_tcsncmp(line, cICOptionKey, _countof(cICOptionKey) - 1)) { const unsigned pos = _countof(cICOptionKey) - 1; if (!_tcsncmp(&line[pos], _T("yes"), _countof(_T("yes")) - 1)) _ic = true; else _ic = false; } else if (!_genericDbCfg.ReadOption(line)) { success = false; SetDefaults(); break; } } fclose(fp); return success; }
int RunConverter( int argc, _TCHAR* * argv ) { #ifdef _DEBUG // sleep a bit so we can have time to attach a debugger Tell(_T("Sleeping for %d seconds in debug mode."), startupTimeout / 1000); Sleep(startupTimeout); #endif int ret = 0; wstring name; wstring title; HANDLE conversionHandle = NULL; po::options_description desc("Converts an MPEG-2 Program Stream to a DVR-MS, WMV, or WTV file."); po::positional_options_description pos; string input; string output; LONGLONG length; bool disableFileLogging; bool disableConsoleLogging; bool disableAllLogging; string interruptName; string interruptDirectory; string outputDirectory; string contentTitle; __int64 contentDuration = -1i64; desc.add_options() ("help,?", "Display help message.") ("input,i", po::value<string>(&input), "an MPEG2 input path. Can be a url.") ("output,o", po::value<string>(&output), "output path.<type>. Where <type> can be one of \"dvr-ms\", \"wmv\", or \"wtv\"") ("length,l", po::value<LONGLONG>(&length)->default_value(-1), "the length of the input content in bytes. Only required for a network path such as http." ) ("interrupt-name", po::value<string>(&interruptName), "the file name (without path or extension) of a file that will be created when conversion is to be interrupted.") ("interrupt-directory", po::value<string>(&interruptDirectory), "the path for this app to look for an interrupt file. An interrupt file is the interrupt_file name with a .interrupt extension. The file itself can be empty.") ("disable-file-logging", po::value<bool>(&disableFileLogging)->zero_tokens()->default_value(false), "indicates that logging to a file will be disabled.") ("disable-console-logging", po::value<bool>(&disableConsoleLogging)->zero_tokens()->default_value(false), "indicates that logging to the console will be disabled.") ("disable-all-logging", po::value<bool>(&disableAllLogging)->zero_tokens()->default_value(false), "indicates that all logging will be disabled.") ("output-directory,d", po::value<string>(&outputDirectory), "the directory for this app to place conversion output. Only valid if output_path is omitted.") ("content-title,t", po::value<string>(&contentTitle), "the Title that will be assigned to the output path.<type>.") ("version,v", po::value<string>()->zero_tokens(), "prints the version of this app.") //("content-duration,d", po::value<__int64>(&contentDuration)->default_value(-1i64), "the duration of the input content in seconds." ) ; pos.add("input", 1); pos.add("output", 1); pos.add("length", 1); vector<string> args; for (int i = 1; i < argc; i++) args.push_back(WStringToString(argv[i])); po::variables_map variables; try { po::basic_parsed_options<char> oo = po::command_line_parser(args). options(desc).positional(pos).run(); po::store(oo, variables); po::notify(variables); } catch (std::exception e) { Tell(_T("Invalid command line. Use --help to see options.")); return -1; } if (!variables.count("input")) { bool display = false; wstring message; if (variables.count("version")) { message = _T("Version: "); message += MPEG2DVRMS_VERSION; display = true; } if (variables.count("help")) { message = _T("eh... help message not available yet. Hope you have the source!"); display = true; } if (!display) message = _T("No input file was specified."); ret = 100; Tell(message); } else { try { ////////////////////////////////////////////////////////////////////////// // command-line option handling LONGLONG contentLength = -1; if (variables.count("length")) contentLength = length; if (variables.count("interrupt-name")) name = StringToWString(interruptName); else { name = NewGuid(); Tell(_T("Generated interrupt name is %s"), name.c_str()); } if (variables.count("interrupt-directory")) _conversionFileStoragePath = StringToWString(interruptDirectory); if (variables.count("content-title")) title = StringToWString(contentTitle); else title = _T(""); #pragma region input output file handling wstring defaultExtension; if (IsVista()) defaultExtension = _T(".dvr-ms"); else defaultExtension = _T(".wtv"); ATL_URL_SCHEME urlScheme; CUrl inputUrl; if (!inputUrl.CrackUrl(StringToWString(input).c_str())) urlScheme = ATL_URL_SCHEME_FILE; else urlScheme = inputUrl.GetScheme(); if (urlScheme == -1) urlScheme = ATL_URL_SCHEME_FILE; wstring inputPath = StringToWString(input); CPath outputPath; if (urlScheme == ATL_URL_SCHEME_FILE) { CPath input = inputPath.c_str(); if (input.IsFileSpec()) { TCHAR szCurrentDirectory[MAX_PATH]; if (!GetCurrentDirectory(MAX_PATH, szCurrentDirectory)) throw CarverLab::Exception(GetLastError()); wstring currentDirectory = (LPCTSTR)szCurrentDirectory; inputPath = currentDirectory + _T("\\") + inputPath.c_str(); input = inputPath.c_str(); } if (!input.FileExists()) throw CarverLab::Exception(_T("MPEG2 input path does not exist.")); if (!variables.count("output")) outputPath = inputPath.c_str(); else outputPath = StringToWString(output).c_str(); } else if (urlScheme == ATL_URL_SCHEME_HTTP || urlScheme == ATL_URL_SCHEME_HTTPS) { if (!variables.count("output")) { wstring thefullpath; CString envString; envString.GetEnvironmentVariable(_T("PUBLIC")); thefullpath = envString; thefullpath += _T("\\Videos\\mpeg2dvrms-output"); thefullpath += defaultExtension; outputPath = thefullpath.c_str(); } else outputPath = StringToWString(output).c_str(); } else throw CarverLab::Exception(_T("Only http or https URL schemes are supported.")); bool isUrl = urlScheme != ATL_URL_SCHEME_FILE; CPath inPath = inputPath.c_str(); if (outputPath.GetExtension().MakeLower() == inPath.GetExtension().MakeLower()) outputPath.RenameExtension(defaultExtension.c_str()); if (outputPath.GetExtension().MakeLower() == _T(".dvrms")) { outputPath.RemoveExtension(); outputPath.AddExtension(_T(".dvr-ms")); } #pragma endregion input output file handling ////////////////////////////////////////////////////////////////////////// conversionHandle = CreateConversion(false, CComBSTR(name.c_str())); if (!conversionHandle) throw CarverLab::Exception(); SetConsoleTitle(outputPath); Tell(_T("Press ENTER to interrupt and exit.")); _done = false; HANDLE stdinput = GetStdHandle(STD_INPUT_HANDLE); std::auto_ptr<InternalThreadData> threadData(new InternalThreadData); threadData->activityCallback = ActivityCallback; threadData->contentLength = contentLength; threadData->conversionHandle = conversionHandle; threadData->inputPath = inPath; threadData->isUrl = isUrl; threadData->outputPath = outputPath; threadData->threadData = NULL; threadData->userData = NULL; threadData->contentTitle = StringToWString(contentTitle); threadData->contentDuration = contentDuration; _lastConvertedFilePath = outputPath; HANDLE thread = CreateThread(NULL, 0, BeginConversion, threadData.get(), 0, NULL); if (thread == NULL) throw CarverLab::Exception(); bool shuttingDown = false; bool interruptSuccessful = false; // will be true if the conversion is inactive after InterruptConversion is called while (!_done) { if (!shuttingDown && ((_kbhit() && _getch() == 13) || InterruptNow(name.c_str()))) { shuttingDown = true; interruptSuccessful = InterruptConversion(conversionHandle, 30000); // will wait 30 seconds for the conversion to die } Sleep(10); } if (!interruptSuccessful) { // TODO: will need to kill this puppy in an unnice way... awwww Tell(_T("InterruptConversion was unsusccessful.")); } // TODO: INFINITE? um... nope. this will need an intervention WaitForSingleObject(thread, INFINITE); CloseHandle(thread); } catch (CarverLab::Exception exception) { Tell(_T("*** Error: %s"), exception.GetErrorString()); Tell(_T("Exiting...")); ret = exception.GetHRESULT(); } catch (...) { DWORD errorCode = GetLastError(); wstring error = Exception::GetLastErrorString(errorCode); Tell(_T("*** Unhandled Exception: %s"), error.c_str()); Tell(_T("Exiting...")); ret = errorCode; } if (conversionHandle != NULL) CloseConversion(conversionHandle); } #ifdef _DEBUG // sleep a bit so we can see any errors Tell(_T("Sleeping for %d seconds in debug mode."), sleepTimeout / 1000); Sleep(sleepTimeout); #endif return ret; }
ConvStatus CPartFileConvert::performConvertToeMule(const CPath& fileName) { wxString filepartindex; CPath folder = fileName.GetPath(); CPath partfile = fileName.GetFullName(); CPath newfilename; CDirIterator finder(folder); Notify_ConvertUpdateProgressFull(0, _("Reading temp folder"), s_pfconverting->folder.GetPrintable()); filepartindex = partfile.RemoveAllExt().GetRaw(); Notify_ConvertUpdateProgress(4, _("Retrieving basic information from download info file")); CPartFile* file = new CPartFile(); s_pfconverting->partmettype = file->LoadPartFile(folder, partfile, false, true); switch (s_pfconverting->partmettype) { case PMT_UNKNOWN: case PMT_BADFORMAT: delete file; return CONV_BADFORMAT; } CPath oldfile = folder.JoinPaths(partfile.RemoveExt()); { wxMutexLocker lock(s_mutex); s_pfconverting->size = file->GetFileSize(); s_pfconverting->filename = file->GetFileName(); s_pfconverting->filehash = file->GetFileHash().Encode(); } Notify_ConvertUpdateJobInfo(s_pfconverting); if (theApp->downloadqueue->GetFileByID(file->GetFileHash())) { delete file; return CONV_ALREADYEXISTS; } if (s_pfconverting->partmettype == PMT_SPLITTED) { unsigned fileindex; char *ba = new char [PARTSIZE]; try { CFile inputfile; // just count unsigned maxindex = 0; unsigned partfilecount = 0; CPath filePath = finder.GetFirstFile(CDirIterator::File, filepartindex + wxT(".*.part")); while (filePath.IsOk()) { long l; ++partfilecount; filePath.GetFullName().RemoveExt().GetExt().ToLong(&l); fileindex = (unsigned)l; filePath = finder.GetNextFile(); if (fileindex > maxindex) maxindex = fileindex; } float stepperpart; { wxMutexLocker lock(s_mutex); if (partfilecount > 0) { stepperpart = (80.0f / partfilecount); if (maxindex * PARTSIZE <= s_pfconverting->size) { s_pfconverting->spaceneeded = maxindex * PARTSIZE; } else { s_pfconverting->spaceneeded = s_pfconverting->size; } } else { stepperpart = 80.0f; s_pfconverting->spaceneeded = 0; } } Notify_ConvertUpdateJobInfo(s_pfconverting); sint64 freespace = CPath::GetFreeSpaceAt(thePrefs::GetTempDir()); if (freespace != wxInvalidOffset) { if (static_cast<uint64>(freespace) < maxindex * PARTSIZE) { delete file; delete [] ba; return CONV_OUTOFDISKSPACE; } } // create new partmetfile, and remember the new name file->CreatePartFile(); newfilename = file->GetFullName(); Notify_ConvertUpdateProgress(8, _("Creating destination file")); file->m_hpartfile.SetLength( s_pfconverting->spaceneeded ); unsigned curindex = 0; CPath filename = finder.GetFirstFile(CDirIterator::File, filepartindex + wxT(".*.part")); while (filename.IsOk()) { // stats ++curindex; Notify_ConvertUpdateProgress(10 + (curindex * stepperpart), CFormat(_("Loading data from old download file (%u of %u)")) % curindex % partfilecount); long l; filename.GetFullName().RemoveExt().GetExt().ToLong(&l); fileindex = (unsigned)l; if (fileindex == 0) { filename = finder.GetNextFile(); continue; } uint32 chunkstart = (fileindex - 1) * PARTSIZE; // open, read data of the part-part-file into buffer, close file inputfile.Open(filename, CFile::read); uint64 toReadWrite = std::min<uint64>(PARTSIZE, inputfile.GetLength()); inputfile.Read(ba, toReadWrite); inputfile.Close(); Notify_ConvertUpdateProgress(10 + (curindex * stepperpart), CFormat(_("Saving data block into new single download file (%u of %u)")) % curindex % partfilecount); // write the buffered data file->m_hpartfile.WriteAt(ba, chunkstart, toReadWrite); filename = finder.GetNextFile(); } delete[] ba; } catch (const CSafeIOException& e) { AddDebugLogLineC(logPfConvert, wxT("IO error while converting partfiles: ") + e.what()); delete[] ba; file->Delete(); return CONV_IOERROR; } file->m_hpartfile.Close(); } // import an external common format partdownload else //if (pfconverting->partmettype==PMT_DEFAULTOLD || pfconverting->partmettype==PMT_NEWOLD || Shareaza ) { if (!s_pfconverting->removeSource) { wxMutexLocker lock(s_mutex); s_pfconverting->spaceneeded = oldfile.GetFileSize(); } Notify_ConvertUpdateJobInfo(s_pfconverting); sint64 freespace = CPath::GetFreeSpaceAt(thePrefs::GetTempDir()); if (freespace == wxInvalidOffset) { delete file; return CONV_IOERROR; } else if (freespace < s_pfconverting->spaceneeded) { delete file; return CONV_OUTOFDISKSPACE; } file->CreatePartFile(); newfilename = file->GetFullName(); file->m_hpartfile.Close(); bool ret = false; Notify_ConvertUpdateProgress(92, _("Copy")); CPath::RemoveFile(newfilename.RemoveExt()); if (!oldfile.FileExists()) { // data file does not exist. well, then create a 0 byte big one CFile datafile; ret = datafile.Create(newfilename.RemoveExt()); } else if (s_pfconverting->removeSource) { ret = CPath::RenameFile(oldfile, newfilename.RemoveExt()); } else { ret = CPath::CloneFile(oldfile, newfilename.RemoveExt(), false); } if (!ret) { file->Delete(); //delete file; return CONV_FAILED; } } Notify_ConvertUpdateProgress(94, _("Retrieving source downloadfile information")); CPath::RemoveFile(newfilename); if (s_pfconverting->removeSource) { CPath::RenameFile(folder.JoinPaths(partfile), newfilename); } else { CPath::CloneFile(folder.JoinPaths(partfile), newfilename, false); } file->m_hashlist.clear(); if (!file->LoadPartFile(thePrefs::GetTempDir(), file->GetPartMetFileName(), false)) { //delete file; file->Delete(); return CONV_BADFORMAT; } if (s_pfconverting->partmettype == PMT_NEWOLD || s_pfconverting->partmettype == PMT_SPLITTED) { file->SetCompletedSize(file->transferred); file->m_iGainDueToCompression = 0; file->m_iLostDueToCorruption = 0; } Notify_ConvertUpdateProgress(100, _("Adding download and saving new partfile")); theApp->downloadqueue->AddDownload(file, thePrefs::AddNewFilesPaused(), 0); file->SavePartFile(); if (file->GetStatus(true) == PS_READY) { theApp->sharedfiles->SafeAddKFile(file); // part files are always shared files } if (s_pfconverting->removeSource) { CPath oldFile = finder.GetFirstFile(CDirIterator::File, filepartindex + wxT(".*")); while (oldFile.IsOk()) { CPath::RemoveFile(folder.JoinPaths(oldFile)); oldFile = finder.GetNextFile(); } if (s_pfconverting->partmettype == PMT_SPLITTED) { CPath::RemoveDir(folder); } } return CONV_OK; }
bool CServerList::LoadServerMet(const CPath& path) { AddLogLineN(CFormat(_("Loading server.met file: %s")) % path); bool merge = !m_servers.empty(); if (!path.FileExists()) { AddLogLineN(_("Server.met file not found!")); return false; } // Try to unpack the file, might be an archive const wxChar* mets[] = { wxT("server.met"), NULL }; // Try to unpack the file, might be an archive if (UnpackArchive(path, mets).second != EFT_Met) { AddLogLineC(CFormat(_("Failed to load server.met file '%s', unknown format encountered.")) % path); return false; } CFile servermet(path, CFile::read); if ( !servermet.IsOpened() ){ AddLogLineN(_("Failed to open server.met!") ); return false; } try { Notify_ServerFreeze(); byte version = servermet.ReadUInt8(); if (version != 0xE0 && version != MET_HEADER) { AddLogLineC(CFormat(_("Server.met file corrupt, found invalid versiontag: 0x%x, size %i")) % version % sizeof(version)); Notify_ServerThaw(); return false; } uint32 fservercount = servermet.ReadUInt32(); ServerMet_Struct sbuffer; uint32 iAddCount = 0; for ( uint32 j = 0; j < fservercount; ++j ) { sbuffer.ip = servermet.ReadUInt32(); sbuffer.port = servermet.ReadUInt16(); sbuffer.tagcount = servermet.ReadUInt32(); CServer* newserver = new CServer(&sbuffer); // Load tags for ( uint32 i = 0; i < sbuffer.tagcount; ++i ) { newserver->AddTagFromFile(&servermet); } // Server priorities are not in sorted order // High = 1, Low = 2, Normal = 0, so we have to check // in a less logical fashion. int priority = newserver->GetPreferences(); if (priority < SRV_PR_MIN || priority > SRV_PR_MAX) { newserver->SetPreference(SRV_PR_NORMAL); } // set listname for server if ( newserver->GetListName().IsEmpty() ) { newserver->SetListName(wxT("Server ") +newserver->GetAddress()); } if ( !theApp->AddServer(newserver) ) { CServer* update = GetServerByAddress(newserver->GetAddress(), newserver->GetPort()); if(update) { update->SetListName( newserver->GetListName()); if(!newserver->GetDescription().IsEmpty()) { update->SetDescription( newserver->GetDescription()); } Notify_ServerRefresh(update); } delete newserver; } else { ++iAddCount; } } Notify_ServerThaw(); if (!merge) { AddLogLineC(CFormat(wxPLURAL("%i server in server.met found", "%i servers in server.met found", fservercount)) % fservercount); } else { AddLogLineC(CFormat(wxPLURAL("%d server added", "%d servers added", iAddCount)) % iAddCount); } } catch (const CInvalidPacket& err) { AddLogLineC(_("Error: the file 'server.met' is corrupted: ") + err.what()); Notify_ServerThaw(); return false; } catch (const CSafeIOException& err) { AddLogLineC(_("IO error while reading 'server.met': ") + err.what()); Notify_ServerThaw(); return false; } return true; }
bool CServerList::SaveServerMet() { CPath curservermet = CPath(theApp->ConfigDir + wxT("server.met")); CFile servermet(curservermet, CFile::write_safe); if (!servermet.IsOpened()) { AddLogLineN(_("Failed to save server.met!")); return false; } try { servermet.WriteUInt8(0xE0); servermet.WriteUInt32( m_servers.size() ); for ( CInternalList::const_iterator it = m_servers.begin(); it != m_servers.end(); ++it) { const CServer* const server = *it; uint16 tagcount = 12; if (!server->GetListName().IsEmpty()) { ++tagcount; } if (!server->GetDynIP().IsEmpty()) { ++tagcount; } if (!server->GetDescription().IsEmpty()) { ++tagcount; } if (server->GetConnPort() != server->GetPort()) { ++tagcount; } // For unicoded name, description, and dynip if ( !server->GetListName().IsEmpty() ) { ++tagcount; } if ( !server->GetDynIP().IsEmpty() ) { ++tagcount; } if ( !server->GetDescription().IsEmpty() ) { ++tagcount; } if (!server->GetVersion().IsEmpty()) { ++tagcount; } if (server->GetServerKeyUDP(true)) { ++tagcount; } if (server->GetServerKeyUDPIP()) { ++tagcount; } if (server->GetObfuscationPortTCP()) { ++tagcount; } if (server->GetObfuscationPortUDP()) { ++tagcount; } servermet.WriteUInt32(server->GetIP()); servermet.WriteUInt16(server->GetPort()); servermet.WriteUInt32(tagcount); if ( !server->GetListName().IsEmpty() ) { // This is BOM to keep eMule compatibility CTagString( ST_SERVERNAME, server->GetListName()).WriteTagToFile( &servermet, utf8strOptBOM); CTagString( ST_SERVERNAME, server->GetListName()).WriteTagToFile( &servermet ); } if ( !server->GetDynIP().IsEmpty() ) { // This is BOM to keep eMule compatibility CTagString( ST_DYNIP, server->GetDynIP()).WriteTagToFile( &servermet, utf8strOptBOM ); CTagString( ST_DYNIP, server->GetDynIP()).WriteTagToFile( &servermet ); } if ( !server->GetDescription().IsEmpty() ) { // This is BOM to keep eMule compatibility CTagString( ST_DESCRIPTION, server->GetDescription()).WriteTagToFile( &servermet, utf8strOptBOM ); CTagString( ST_DESCRIPTION, server->GetDescription()).WriteTagToFile( &servermet ); } if ( server->GetConnPort() != server->GetPort() ) { CTagString( ST_AUXPORTSLIST, server->GetAuxPortsList() ).WriteTagToFile( &servermet ); } CTagInt32( ST_FAIL, server->GetFailedCount() ).WriteTagToFile( &servermet ); CTagInt32( ST_PREFERENCE, server->GetPreferences() ).WriteTagToFile( &servermet ); CTagInt32( wxT("users"), server->GetUsers() ).WriteTagToFile( &servermet ); CTagInt32( wxT("files"), server->GetFiles() ).WriteTagToFile( &servermet ); CTagInt32( ST_PING, server->GetPing() ).WriteTagToFile( &servermet ); CTagInt32( ST_LASTPING, server->GetLastPingedTime()).WriteTagToFile( &servermet ); CTagInt32( ST_MAXUSERS, server->GetMaxUsers() ).WriteTagToFile( &servermet ); CTagInt32( ST_SOFTFILES, server->GetSoftFiles() ).WriteTagToFile( &servermet ); CTagInt32( ST_HARDFILES, server->GetHardFiles() ).WriteTagToFile( &servermet ); if (!server->GetVersion().IsEmpty()){ CTagString( ST_VERSION, server->GetVersion() ).WriteTagToFile( &servermet, utf8strOptBOM ); CTagString( ST_VERSION, server->GetVersion() ).WriteTagToFile( &servermet ); } CTagInt32( ST_UDPFLAGS, server->GetUDPFlags() ).WriteTagToFile( &servermet ); CTagInt32( ST_LOWIDUSERS, server->GetLowIDUsers() ).WriteTagToFile( &servermet ); if (server->GetServerKeyUDP(true)) { CTagInt32(ST_UDPKEY, server->GetServerKeyUDP(true)).WriteTagToFile( &servermet ); } if (server->GetServerKeyUDPIP()) { CTagInt32(ST_UDPKEYIP, server->GetServerKeyUDPIP()).WriteTagToFile( &servermet ); } if (server->GetObfuscationPortTCP()) { CTagInt16(ST_TCPPORTOBFUSCATION, server->GetObfuscationPortTCP()).WriteTagToFile( &servermet ); } if (server->GetObfuscationPortUDP()) { CTagInt16(ST_UDPPORTOBFUSCATION, server->GetObfuscationPortUDP()).WriteTagToFile( &servermet ); } } // Now server.met.new is ready to be closed and renamed to server.met. // But first rename existing server.met to server.met.bak (replacing old .bak file). const CPath oldservermet = CPath(theApp->ConfigDir + wxT("server.met.bak")); if (curservermet.FileExists()) { CPath::RenameFile(curservermet, oldservermet, true); } servermet.Close(); } catch (const CIOFailureException& e) { AddLogLineC(wxT("IO failure while writing 'server.met': ") + e.what()); return false; } return true; }