// Delete all of the partly reconstructed files bool Par1Repairer::DeleteIncompleteTargetFiles(void) { list<Par1RepairerSourceFile*>::iterator sf = verifylist.begin(); // Iterate through each file in the verification list while (sf != verifylist.end()) { Par1RepairerSourceFile *sourcefile = *sf; if (sourcefile->GetTargetExists()) { DiskFile *targetfile = sourcefile->GetTargetFile(); // Close and delete the file if (targetfile->IsOpen()) targetfile->Close(); targetfile->Delete(); // Forget the file diskfilemap.Remove(targetfile); delete targetfile; // There is no target file sourcefile->SetTargetExists(false); sourcefile->SetTargetFile(0); } ++sf; } return true; }
bool Copy(File& srcFile, const char* destFilename) { // Operate in 16k buffers. const DWORD BUFFER_SIZE = 16 * 1024; DWORD fileSize = (DWORD)srcFile.GetLength(); // See if the destination file exists. DiskFile destFile; if (!destFile.Open(destFilename, File::MODE_CREATE | File::MODE_WRITEONLY)) return false; // Allocate the buffer space. BYTE* buffer = (BYTE*)_alloca(BUFFER_SIZE); // Keep copying until there is no more file left to copy. while (fileSize > 0) { // Copy the minimum of BUFFER_SIZE or the fileSize. DWORD readSize = min(BUFFER_SIZE, fileSize); srcFile.Read(buffer, readSize); destFile.Write(buffer, readSize); fileSize -= readSize; } // Close the destination virtual file. destFile.Close(); return true; }
Image::Image(const char* filename) : format(RGBA32) { printf("Image %s\n", filename); DiskFile file; file.open(filename, DiskFile::ReadMode); uint size = file.getSize(); int comp; data = stbi_load_from_memory((u8*)file.readAll(), size, &width, &height, &comp, 4); }
bool Copy(File& srcFile, const char* destFilename) { // Operate in 16k buffers. const uint32_t BUFFER_SIZE = 16 * 1024; uint32_t fileSize = (uint32_t)srcFile.GetLength(); if (!Misc::PathCreate(destFilename)) return false; // See if the destination file exists. DiskFile destFile; if (!destFile.Open(destFilename, File::MODE_CREATE | File::MODE_WRITEONLY)) return false; // Allocate the buffer space. BYTE* buffer = (BYTE*)alloca(BUFFER_SIZE); // Keep copying until there is no more file left to copy. while (fileSize > 0) { // Copy the minimum of BUFFER_SIZE or the fileSize. uint32_t readSize = BUFFER_SIZE < fileSize ? BUFFER_SIZE : fileSize; if (srcFile.Read(buffer, readSize) != readSize) return false; destFile.Write(buffer, readSize); fileSize -= readSize; } // Close the destination virtual file. destFile.Close(); return true; }
bool RarVolume::Read() { debug("Checking file %s", *m_filename); DiskFile file; if (!file.Open(m_filename, DiskFile::omRead)) { return false; } m_version = DetectRarVersion(file); file.Seek(0); bool ok = false; switch (m_version) { case 3: ok = ReadRar3Volume(file); break; case 5: ok = ReadRar5Volume(file); break; } file.Close(); DecryptFree(); LogDebugInfo(); return ok; }
result WavStream::load(const char *aFilename) { delete[] mFilename; delete mMemFile; mMemFile = 0; mFilename = 0; mSampleCount = 0; DiskFile fp; int res = fp.open(aFilename); if (res != SO_NO_ERROR) return res; int len = (int)strlen(aFilename); mFilename = new char[len+1]; memcpy(mFilename, aFilename, len); mFilename[len] = 0; res = parse(&fp); if (res != SO_NO_ERROR) { delete[] mFilename; mFilename = 0; return res; } return 0; }
bool Par1Repairer::RemoveParFiles(void) { if (noiselevel > CommandLine::nlSilent && parlist.size() > 0) { cout << endl << "Purge par files." << endl; } for (list<string>::const_iterator s=parlist.begin(); s!=parlist.end(); ++s) { DiskFile *diskfile = new DiskFile; if (diskfile->Open(*s)) { if (noiselevel > CommandLine::nlSilent) { string name; string path; DiskFile::SplitFilename((*s), path, name); cout << "Remove \"" << name << "\"." << endl; } if (diskfile->IsOpen()) diskfile->Close(); diskfile->Delete(); } delete diskfile; } return true; }
File* DiskFileDevice::open(const ansichar *path, FileModeFlags flags){ DiskFile* file = eng_new(DiskFile)(this, path, flags); if (!file || !file->valid()) { eng_delete(file); return nullptr; } return file; }
result Sfxr::loadParams(const char *aFilename) { DiskFile df; int res = df.open(aFilename); if (res != SO_NO_ERROR) return res; return loadParamsFile(&df); }
// Scan any extra files specified on the command line bool Par1Repairer::VerifyExtraFiles(const list<CommandLine::ExtraFile> &extrafiles) { for (ExtraFileIterator i=extrafiles.begin(); i!=extrafiles.end() && completefilecount<sourcefiles.size(); ++i) { string filename = i->FileName(); bool skip = false; // Find the file extension string::size_type where = filename.find_last_of('.'); if (where != string::npos) { string tail = filename.substr(where+1); // Check the the file extension is the correct form if ((tail[0] == 'P' || tail[0] == 'p') && ( ((tail[1] == 'A' || tail[1] == 'a') && (tail[2] == 'R' || tail[2] == 'r')) || (isdigit(tail[1]) && isdigit(tail[2])) )) { skip = true; } } if (!skip) { filename = DiskFile::GetCanonicalPathname(filename); // Has this file already been dealt with if (diskfilemap.Find(filename) == 0) { DiskFile *diskfile = new DiskFile; // Does the file exist if (!diskfile->Open(filename)) { delete diskfile; continue; } // Remember that we have processed this file bool success = diskfilemap.Insert(diskfile); assert(success); // Do the actual verification VerifyDataFile(diskfile, 0); // Ignore errors // We have finished with the file for now diskfile->Close(); // Find out how much data we have found UpdateVerificationResults(); } } } return true; }
result Wav::load(const char *aFilename) { DiskFile dr; int res = dr.open(aFilename); if (res != SO_NO_ERROR) { return res; } return testAndLoadFile(&dr); }
result WavStream::loadToMem(const char *aFilename) { DiskFile df; int res = df.open(aFilename); if (res == SO_NO_ERROR) { res = loadFileToMem(&df); } return res; }
WavStreamInstance::WavStreamInstance(WavStream *aParent) { mParent = aParent; mOffset = 0; mOgg = 0; mFile = 0; if (aParent->mMemFile) { MemoryFile *mf = new MemoryFile(); mFile = mf; mf->openMem(aParent->mMemFile->getMemPtr(), aParent->mMemFile->length(), false, false); } else if (aParent->mFilename) { DiskFile *df = new DiskFile; mFile = df; df->open(aParent->mFilename); } else if (aParent->mStreamFile) { mFile = aParent->mStreamFile; mFile->seek(0); // stb_vorbis assumes file offset to be at start of ogg } else { return; } if (mFile) { if (mParent->mOgg) { int e; mOgg = stb_vorbis_open_file((Soloud_Filehack *)mFile, 0, &e, 0); if (!mOgg) { if (mFile != mParent->mStreamFile) delete mFile; mFile = 0; } mOggFrameSize = 0; mOggFrameOffset = 0; mOggOutputs = 0; } else { mFile->seek(aParent->mDataOffset); } } }
result Wav::load(const char *aFilename) { if (aFilename == 0) return INVALID_PARAMETER; stop(); DiskFile dr; int res = dr.open(aFilename); if (res == SO_NO_ERROR) return loadFile(&dr); return res; }
bool FileSystem::SaveBufferIntoFile(const char* filename, const char* buffer, int bufLen) { DiskFile file; if (!file.Open(filename, DiskFile::omWrite)) { return false; } int writtenBytes = (int)file.Write(buffer, bufLen); file.Close(); return writtenBytes == bufLen; }
bool FileSystem::CopyFile(const char* srcFilename, const char* dstFilename) { DiskFile infile; if (!infile.Open(srcFilename, DiskFile::omRead)) { return false; } DiskFile outfile; if (!outfile.Open(dstFilename, DiskFile::omWrite)) { return false; } CharBuffer buffer(1024 * 50); int cnt = buffer.Size(); while (cnt == buffer.Size()) { cnt = (int)infile.Read(buffer, buffer.Size()); outfile.Write(buffer, cnt); } infile.Close(); outfile.Close(); return true; }
void Log::Filelog(const char* msg, ...) { if (m_logFilename.Empty()) { return; } char tmp2[1024]; va_list ap; va_start(ap, msg); vsnprintf(tmp2, 1024, msg, ap); tmp2[1024-1] = '\0'; va_end(ap); time_t rawtime = Util::CurrentTime() + g_Options->GetTimeCorrection(); char time[50]; Util::FormatTime(rawtime, time, 50); if ((int)rawtime/86400 != (int)m_lastWritten/86400 && g_Options->GetWriteLog() == Options::wlRotate) { RotateLog(); } m_lastWritten = rawtime; DiskFile file; if (file.Open(m_logFilename, DiskFile::omAppend)) { #ifdef WIN32 uint64 processId = GetCurrentProcessId(); uint64 threadId = GetCurrentThreadId(); #else uint64 processId = (uint64)getpid(); uint64 threadId = (uint64)pthread_self(); #endif #ifdef DEBUG file.Print("%s\t%llu\t%llu\t%s%s", time, processId, threadId, tmp2, LINE_ENDING); #else file.Print("%s\t%s%s", time, tmp2, LINE_ENDING); #endif file.Close(); } else { perror(m_logFilename); } }
void ParRenamer::CheckRegularFile(const char* destDir, const char* filename) { debug("Computing hash for %s", filename); DiskFile file; if (!file.Open(filename, DiskFile::omRead)) { PrintMessage(Message::mkError, "Could not open file %s", filename); return; } // load first 16K of the file into buffer static const int blockSize = 16*1024; CharBuffer buffer(blockSize); int readBytes = (int)file.Read(buffer, buffer.Size()); if (readBytes != buffer.Size() && file.Error()) { PrintMessage(Message::mkError, "Could not read file %s", filename); return; } file.Close(); Par2::MD5Hash hash16k; Par2::MD5Context context; context.Update(buffer, readBytes); context.Final(hash16k); debug("file: %s; hash16k: %s", FileSystem::BaseFileName(filename), hash16k.print().c_str()); for (FileHash& fileHash : m_fileHashList) { if (!strcmp(fileHash.GetHash(), hash16k.print().c_str())) { debug("Found correct filename: %s", fileHash.GetFilename()); fileHash.SetFileExists(true); BString<1024> dstFilename("%s%c%s", destDir, PATH_SEPARATOR, fileHash.GetFilename()); if (!FileSystem::FileExists(dstFilename) && !IsSplittedFragment(filename, fileHash.GetFilename())) { RenameFile(filename, dstFilename); } break; } } }
TEXLoader::IoStatus TEXLoader::Save(const str& file_name, const Texture& texture, bool compressed) { IoStatus io_status = kStatusSuccess; DiskFile file; save_file_ = &file; if (file.Open(file_name, DiskFile::kModeWrite) == false) { io_status = kStatusOpenError; } if (io_status == kStatusSuccess) { io_status = Save(texture, compressed); } return io_status; }
void ArticleWriter::SetWriteBuffer(DiskFile& outFile, int recSize) { if (g_Options->GetWriteBuffer() > 0) { outFile.SetWriteBuffer(recSize > 0 && recSize < g_Options->GetWriteBuffer() * 1024 ? recSize : g_Options->GetWriteBuffer() * 1024); } }
bool FileSystem::LoadFileIntoBuffer(const char* filename, CharBuffer& buffer, bool addTrailingNull) { DiskFile file; if (!file.Open(filename, DiskFile::omRead)) { return false; } // obtain file size. file.Seek(0, DiskFile::soEnd); int size = (int)file.Position(); file.Seek(0); // allocate memory to contain the whole file. buffer.Reserve(size + (addTrailingNull ? 1 : 0)); // copy the file into the buffer. file.Read(buffer, size); file.Close(); if (addTrailingNull) { buffer[size] = 0; } return true; }
int lziparchive_fileinsert(lua_State* L) { ZipArchive* archive = lziparchive_check(L, 1); const char* srcFileName = luaL_checkstring(L, 2); const char* destFileName = luaL_checkstring(L, 3); int compressionMethod = (int)luaL_optnumber(L, 4, ZipArchive::DEFLATED); int compressionLevel = (int)luaL_optnumber(L, 5, Z_DEFAULT_COMPRESSION); DiskFile file; if (!file.Open(srcFileName, File::MODE_READONLY)) { lua_pushboolean(L, false); return 1; } time_t fileTime = (UINT)luaL_optnumber(L, 5, (lua_Number)file.GetLastWriteTime()); lua_pushboolean(L, archive->FileCopy(file, destFileName, compressionMethod, compressionLevel, &fileTime) != 0); return 1; }
int LS_VirtualDrive_FileInsert(LuaState* state, LuaStackObject* args) { VirtualDrive* drive = VirtualDriveFromLua(state, args[1]); const char* srcFileName = luaL_checkstring(*state, 2); const char* destFileName = luaL_checkstring(*state, 3); int compressionMethod = (UINT)luaL_optnumber(*state, 4, VirtualDrive::COMPRESSED); DiskFile file; if (!file.Open(srcFileName, File::MODE_READONLY)) { state->PushBoolean(false); return 1; } time_t fileTime = (UINT)luaL_optnumber(*state, 5, (lua_Number)file.GetLastWriteTime()); state->PushBoolean(drive->FileCopy(file, destFileName, compressionMethod, &fileTime) != 0); return 1; }
//----------------------------------------------------------------------------- void* TextResource::load(Allocator& allocator, Bundle& bundle, ResourceId id) { DiskFile* stream = bundle.open(id); CE_ASSERT(stream != NULL, "Resource does not exist: %.8X%.8X", id.name, id.type); TextResource* resource = (TextResource*)allocator.allocate(sizeof(TextResource)); stream->read(&resource->length, sizeof(uint32_t)); resource->data = (char*)allocator.allocate(sizeof(char) * (resource->length + 1)); stream->read(resource->data, (size_t)resource->length); resource->data[resource->length] = '\0'; bundle.close(stream); return resource; }
//----------------------------------------------------------------------------- DiskFile* FileBundle::open(ResourceId name) { // Convert name/type into strings char resource_name[512]; snprintf(resource_name, 512, "%.8X%.8X", name.name, name.type); // Search the resource in the filesystem bool exists = m_filesystem.exists(resource_name); CE_ASSERT(exists == true, "Resource does not exist: %s", resource_name); // Open the resource and check magic number/version DiskFile* file = (DiskFile*)m_filesystem.open(resource_name, FOM_READ); ResourceHeader header; file->read(&header, sizeof(ResourceHeader)); CE_ASSERT(header.magic == RESOURCE_MAGIC_NUMBER, "Resource is not valid: %s", resource_name); CE_ASSERT(header.version == RESOURCE_VERSION, "Resource version mismatch: %s", resource_name); return file; }
void ParRenamer::CheckParFile(const char* destDir, const char* filename) { debug("Checking par2-header for %s", filename); DiskFile file; if (!file.Open(filename, DiskFile::omRead)) { PrintMessage(Message::mkError, "Could not open file %s", filename); return; } // load par2-header Par2::PACKET_HEADER header; int readBytes = (int)file.Read(&header, sizeof(header)); if (readBytes != sizeof(header) && file.Error()) { PrintMessage(Message::mkError, "Could not read file %s", filename); return; } file.Close(); // Check the packet header if (Par2::packet_magic != header.magic || // not par2-file sizeof(Par2::PACKET_HEADER) > header.length || // packet length is too small 0 != (header.length & 3) || // packet length is not a multiple of 4 FileSystem::FileSize(filename) < (int)header.length) // packet would extend beyond the end of the file { // not par2-file or damaged header, ignoring the file return; } BString<100> setId = header.setid.print().c_str(); for (char* p = setId; *p; p++) *p = tolower(*p); // convert string to lowercase debug("Storing: %s; setid: %s", FileSystem::BaseFileName(filename), *setId); m_parInfoList.emplace_back(filename, setId); }
// Work out which files are being repaired, create them, and allocate // target DataBlocks to them, and remember them for later verification. bool Par1Repairer::CreateTargetFiles(void) { vector<Par1RepairerSourceFile*>::iterator sf = sourcefiles.begin(); // Create any missing target files while (sf != sourcefiles.end()) { Par1RepairerSourceFile *sourcefile = *sf; // If the file does not exist if (!sourcefile->GetTargetExists()) { DiskFile *targetfile = new DiskFile; string filename = sourcefile->FileName(); u64 filesize = sourcefile->FileSize(); // Create the target file if (!targetfile->Create(filename, filesize)) { delete targetfile; return false; } // This file is now the target file sourcefile->SetTargetExists(true); sourcefile->SetTargetFile(targetfile); // Remember this file bool success = diskfilemap.Insert(targetfile); assert(success); sourcefile->SetTargetBlock(targetfile); // Add the file to the list of those that will need to be verified // once the repair has completed. verifylist.push_back(sourcefile); } ++sf; } return true; }
// Verify that all of the reconstructed target files are now correct bool Par1Repairer::VerifyTargetFiles(void) { bool finalresult = true; // Verify the target files in alphabetical order // sort(verifylist.begin(), verifylist.end(), SortSourceFilesByFileName); // Iterate through each file in the verification list for (list<Par1RepairerSourceFile*>::iterator sf = verifylist.begin(); sf != verifylist.end(); ++sf) { Par1RepairerSourceFile *sourcefile = *sf; DiskFile *targetfile = sourcefile->GetTargetFile(); // Close the file if (targetfile->IsOpen()) targetfile->Close(); // Say we don't have a complete version of the file sourcefile->SetCompleteFile(0); // Re-open the target file if (!targetfile->Open()) { finalresult = false; continue; } // Verify the file again if (!VerifyDataFile(targetfile, sourcefile)) finalresult = false; // Close the file again targetfile->Close(); // Find out how much data we have found UpdateVerificationResults(); } return finalresult; }
void DiskDir::load() { _files.clear(); _subdirs.clear(); // TODO: cache existing files and keep them unless they do no longer exist StringList li; GetFileList(fullname(), li); for(StringList::iterator it = li.begin(); it != li.end(); ++it) { DiskFile *f = new DiskFile(joinPath(fullname(), it->c_str()).c_str()); _files[f->name()] = f; } li.clear(); GetDirList(fullname(), li, 0); for(StringList::iterator it = li.begin(); it != li.end(); ++it) { // GetDirList() returns relative paths, so need to join Dir *d = createNew(joinPath(fullname(), it->c_str()).c_str()); _subdirs[d->name()] = d; } }
int RarVolume::DetectRarVersion(DiskFile& file) { static char RAR3_SIGNATURE[] = { 0x52, 0x61, 0x72, 0x21, 0x1A, 0x07, 0x00 }; static char RAR5_SIGNATURE[] = { 0x52, 0x61, 0x72, 0x21, 0x1A, 0x07, 0x01, 0x00 }; char fileSignature[8]; int cnt = 0; cnt = (int)file.Read(fileSignature, sizeof(fileSignature)); bool rar5 = cnt == sizeof(fileSignature) && !strcmp(RAR5_SIGNATURE, fileSignature); bool rar3 = !rar5 && cnt == sizeof(fileSignature) && !strcmp(RAR3_SIGNATURE, fileSignature); return rar3 ? 3 : rar5 ? 5 : 0; }