diff --git a/Core/FileSystems/DirectoryFileSystem.cpp b/Core/FileSystems/DirectoryFileSystem.cpp index d692012e5b..7379f8d925 100644 --- a/Core/FileSystems/DirectoryFileSystem.cpp +++ b/Core/FileSystems/DirectoryFileSystem.cpp @@ -32,8 +32,12 @@ #include #endif - #if HOST_IS_CASE_SENSITIVE +typedef enum { + FPC_FILE_MUST_EXIST, // all path components must exist (rmdir, move from) + FPC_PATH_MUST_EXIST, // all except the last one must exist - still tries to fix last one (fopen, move to) + FPC_PARTIAL_ALLOWED, // don't care how many exist (mkdir recursive) +} FixPathCaseBehavior; static bool FixFilenameCase(const std::string &path, std::string &filename) { @@ -83,7 +87,7 @@ static bool FixFilenameCase(const std::string &path, std::string &filename) return retValue; } -bool DirectoryFileSystem::FixPathCase(std::string &path, FixPathCaseBehavior behavior) +bool FixPathCase(std::string &path, FixPathCaseBehavior behavior) { size_t len = path.size(); @@ -99,8 +103,7 @@ bool DirectoryFileSystem::FixPathCase(std::string &path, FixPathCaseBehavior beh } std::string fullPath; - fullPath.reserve(basePath.size() + len + 1); - fullPath.append(basePath); + fullPath.reserve(len + 1); size_t start = 0; while (start < len) @@ -134,28 +137,161 @@ bool DirectoryFileSystem::FixPathCase(std::string &path, FixPathCaseBehavior beh #endif -DirectoryFileSystem::DirectoryFileSystem(IHandleAllocator *_hAlloc, std::string _basePath, bool _virtualDisc) - : basePath(_basePath),virtualDisc(_virtualDisc),currentBlockIndex(0) { - -#ifdef _WIN32 - if (basePath.size() > 0 && basePath[basePath.size()-1] != '\\') - basePath = basePath + "\\"; -#else - if (basePath.size() > 0 && basePath[basePath.size()-1] != '/') - basePath = basePath + "/"; +bool DirectoryFileHandle::Open(std::string& fileName, FileAccess access) +{ +#if HOST_IS_CASE_SENSITIVE + if (access & (FILEACCESS_APPEND|FILEACCESS_CREATE|FILEACCESS_WRITE)) + { + DEBUG_LOG(HLE, "Checking case for path %s", fileName.c_str()); + if ( ! FixPathCase(fileName, FPC_PATH_MUST_EXIST) ) + return false; // or go on and attempt (for a better error code than just 0?) + } + // else we try fopen first (in case we're lucky) before simulating case insensitivity #endif - if (!virtualDisc) File::CreateFullPath(basePath); + INFO_LOG(HLE,"Actually opening %s", fileName.c_str()); + + //TODO: tests, should append seek to end of file? seeking in a file opened for append? +#ifdef _WIN32 + // Convert parameters to Windows permissions and access + DWORD desired = 0; + DWORD sharemode = 0; + DWORD openmode = 0; + if (access & FILEACCESS_READ) { + desired |= GENERIC_READ; + sharemode |= FILE_SHARE_READ; + } + if (access & FILEACCESS_WRITE) { + desired |= GENERIC_WRITE; + sharemode |= FILE_SHARE_WRITE; + } + if (access & FILEACCESS_CREATE) { + openmode = OPEN_ALWAYS; + } else { + openmode = OPEN_EXISTING; + } + //Let's do it! + hFile = CreateFile(fileName.c_str(), desired, sharemode, 0, openmode, 0, 0); + bool success = hFile != INVALID_HANDLE_VALUE; +#else + // Convert flags in access parameter to fopen access mode + const char *mode = NULL; + if (access & FILEACCESS_APPEND) { + if (access & FILEACCESS_READ) + mode = "ab+"; // append+read, create if needed + else + mode = "ab"; // append only, create if needed + } else if (access & FILEACCESS_WRITE) { + if (access & FILEACCESS_READ) { + // FILEACCESS_CREATE is ignored for read only, write only, and append + // because C++ standard fopen's nonexistant file creation can only be + // customized for files opened read+write + if (access & FILEACCESS_CREATE) + mode = "wb+"; // read+write, create if needed + else + mode = "rb+"; // read+write, but don't create + } else { + mode = "wb"; // write only, create if needed + } + } else { // neither write nor append, so default to read only + mode = "rb"; // read only, don't create + } + + hFile = fopen(fileName.c_str(), mode); + bool success = hFile != 0; +#endif + +#if HOST_IS_CASE_SENSITIVE + if (!success && + !(access & FILEACCESS_APPEND) && + !(access & FILEACCESS_CREATE) && + !(access & FILEACCESS_WRITE)) + { + if ( ! FixPathCase(fileName, FPC_PATH_MUST_EXIST) ) + return 0; // or go on and attempt (for a better error code than just 0?) + const char* fullNameC = fileName.c_str(); + + DEBUG_LOG(HLE, "Case may have been incorrect, second try opening %s (%s)", fullNameC, fileName.c_str()); + + // And try again with the correct case this time +#ifdef _WIN32 + hFile = CreateFile(fullNameC, desired, sharemode, 0, openmode, 0, 0); + success = hFile != INVALID_HANDLE_VALUE; +#else + hFile = fopen(fullNameC, mode); + success = hFile != 0; +#endif + } +#endif + + return success; +} + +size_t DirectoryFileHandle::Read(u8* pointer, s64 size) +{ + size_t bytesRead; +#ifdef _WIN32 + ::ReadFile(hFile, (LPVOID)pointer, (DWORD)size, (LPDWORD)&bytesRead, 0); +#else + bytesRead = fread(pointer, 1, size, hFile); +#endif + return bytesRead; +} + +size_t DirectoryFileHandle::Write(const u8* pointer, s64 size) +{ + size_t bytesWritten; +#ifdef _WIN32 + ::WriteFile(hFile, (LPVOID)pointer, (DWORD)size, (LPDWORD)&bytesWritten, 0); +#else + bytesWritten = fwrite(pointer, 1, size, hFile); +#endif + return bytesWritten; +} + +size_t DirectoryFileHandle::Seek(s32 position, FileMove type) +{ +#ifdef _WIN32 + DWORD moveMethod = 0; + switch (type) { + case FILEMOVE_BEGIN: moveMethod = FILE_BEGIN; break; + case FILEMOVE_CURRENT: moveMethod = FILE_CURRENT; break; + case FILEMOVE_END: moveMethod = FILE_END; break; + } + DWORD newPos = SetFilePointer(hFile, (LONG)position, 0, moveMethod); + return newPos; +#else + int moveMethod = 0; + switch (type) { + case FILEMOVE_BEGIN: moveMethod = SEEK_SET; break; + case FILEMOVE_CURRENT: moveMethod = SEEK_CUR; break; + case FILEMOVE_END: moveMethod = SEEK_END; break; + } + fseek(hFile, position, moveMethod); + return ftell(hFile); +#endif +} + +void DirectoryFileHandle::Close() +{ +#ifdef _WIN32 + if (hFile != (HANDLE)-1) + CloseHandle(hFile); +#else + if (hFile != 0) + fclose(hFile); +#endif +} + + +DirectoryFileSystem::DirectoryFileSystem(IHandleAllocator *_hAlloc, std::string _basePath) : basePath(_basePath) { + File::CreateFullPath(basePath); hAlloc = _hAlloc; } DirectoryFileSystem::~DirectoryFileSystem() { for (auto iter = entries.begin(); iter != entries.end(); ++iter) { -#ifdef _WIN32 - CloseHandle((*iter).second.hFile); -#else - fclose((*iter).second.hFile); -#endif + iter->second.hFile.Close(); } } @@ -176,12 +312,6 @@ std::string DirectoryFileSystem::GetLocalPath(std::string localpath) { } bool DirectoryFileSystem::MkDir(const std::string &dirname) { - if (virtualDisc) - { - ERROR_LOG(HLE,"Cannot create directory on virtual disc"); - return false; - } - #if HOST_IS_CASE_SENSITIVE // Must fix case BEFORE attempting, because MkDir would create // duplicate (different case) directories @@ -197,12 +327,6 @@ bool DirectoryFileSystem::MkDir(const std::string &dirname) { } bool DirectoryFileSystem::RmDir(const std::string &dirname) { - if (virtualDisc) - { - ERROR_LOG(HLE,"Cannot remove directory on virtual disc"); - return false; - } - std::string fullName = GetLocalPath(dirname); #if HOST_IS_CASE_SENSITIVE @@ -227,12 +351,6 @@ bool DirectoryFileSystem::RmDir(const std::string &dirname) { } int DirectoryFileSystem::RenameFile(const std::string &from, const std::string &to) { - if (virtualDisc) - { - ERROR_LOG(HLE,"Cannot rename file on virtual disc"); - return false; - } - std::string fullTo = to; // Rename ignores the path (even if specified) on to. @@ -288,12 +406,6 @@ int DirectoryFileSystem::RenameFile(const std::string &from, const std::string & } bool DirectoryFileSystem::RemoveFile(const std::string &filename) { - if (virtualDisc) - { - ERROR_LOG(HLE,"Cannot remove file on virtual disc"); - return false; - } - std::string fullName = GetLocalPath(filename); #ifdef _WIN32 bool retValue = (::DeleteFileA(fullName.c_str()) == TRUE); @@ -321,205 +433,13 @@ bool DirectoryFileSystem::RemoveFile(const std::string &filename) { return retValue; } -bool DirectoryFileSystem::findVirtualFileData(u32 accessBlock, u32 accessSize, std::string& fileName, u32& firstBlock) -{ - for (int i = 0; i < fileBlocks.size(); i++) - { - if (fileBlocks[i].firstBlock <= accessBlock) - { - u32 sectorOffset = (accessBlock-fileBlocks[i].firstBlock)*2048; - u32 endOffset = sectorOffset+accessSize; - if (endOffset <= fileBlocks[i].totalSize) - { - firstBlock = fileBlocks[i].firstBlock; - fileName = fileBlocks[i].fileName; - return true; - } - } - } - - return false; -} - u32 DirectoryFileSystem::OpenFile(std::string filename, FileAccess access, const char *devicename) { - if (virtualDisc && filename == "") - { - OpenFileEntry entry; - entry.lbnFile = false; - entry.wholeIso = true; - - u32 newHandle = hAlloc->GetNewHandle(); - entries[newHandle] = entry; - - return newHandle; - } - - if (virtualDisc && filename.compare(0,8,"/sce_lbn") == 0) - { - u32 sectorStart = 0xFFFFFFFF, readSize = 0xFFFFFFFF; - parseLBN(filename, §orStart, &readSize); - - OpenFileEntry entry; - entry.lbnFile = true; - entry.wholeIso = false; - entry.size = readSize; - entry.curOffset = 0; - - std::string actualFileName = ""; - for (int i = 0; i < fileBlocks.size(); i++) - { - if (fileBlocks[i].firstBlock <= sectorStart) - { - u32 sectorOffset = (sectorStart-fileBlocks[i].firstBlock)*2048; - u32 endOffset = sectorOffset+readSize; - if (endOffset <= fileBlocks[i].totalSize) - { - entry.startOffset = sectorOffset; - actualFileName = fileBlocks[i].fileName; - break; - } - } - } - - // no file info has been gathered? shouldn't happen - if (actualFileName == "") - { - ERROR_LOG(FILESYS, "DiscDirectoryFileSystem: sce_lbn used without calling fileinfo."); - return 0; - } - -#if HOST_IS_CASE_SENSITIVE - if (access & (FILEACCESS_APPEND|FILEACCESS_CREATE|FILEACCESS_WRITE)) - { - DEBUG_LOG(HLE, "Checking case for path %s", filename.c_str()); - if ( ! FixPathCase(actualFileName, FPC_PATH_MUST_EXIST) ) - return 0; // or go on and attempt (for a better error code than just 0?) - } - // else we try fopen first (in case we're lucky) before simulating case insensitivity -#endif - - // now we just need an actual file handle - std::string fullName = GetLocalPath(actualFileName); - -#ifdef _WIN32 - entry.hFile = CreateFile(fullName.c_str(), GENERIC_READ, FILE_SHARE_READ, 0, OPEN_EXISTING, 0, 0); - bool success = entry.hFile != INVALID_HANDLE_VALUE; -#else - entry.hFile = fopen(fullName.c_str(), "rb"); - bool success = entry.hFile != 0; -#endif - - if (!success) - { - ERROR_LOG(HLE, "DiscDirectoryFileSystem::OpenFile: FAILED, %i", GetLastError()); - return 0; - } - - // seek to start -#ifdef _WIN32 - DWORD newPos = SetFilePointer(entry.hFile, (LONG)entry.startOffset, 0, FILE_BEGIN); -#else - fseek(entry.hFile, entry.startOffset, SEEK_SET); -#endif - - u32 newHandle = hAlloc->GetNewHandle(); - entries[newHandle] = entry; - - return newHandle; - } - -#if HOST_IS_CASE_SENSITIVE - if (access & (FILEACCESS_APPEND|FILEACCESS_CREATE|FILEACCESS_WRITE)) - { - DEBUG_LOG(HLE, "Checking case for path %s", filename.c_str()); - if ( ! FixPathCase(filename, FPC_PATH_MUST_EXIST) ) - return 0; // or go on and attempt (for a better error code than just 0?) - } - // else we try fopen first (in case we're lucky) before simulating case insensitivity -#endif - std::string fullName = GetLocalPath(filename); const char *fullNameC = fullName.c_str(); - INFO_LOG(HLE,"Actually opening %s (%s)", fullNameC, filename.c_str()); OpenFileEntry entry; - entry.lbnFile = false; - entry.wholeIso = false; - - //TODO: tests, should append seek to end of file? seeking in a file opened for append? -#ifdef _WIN32 - // Convert parameters to Windows permissions and access - DWORD desired = 0; - DWORD sharemode = 0; - DWORD openmode = 0; - if (access & FILEACCESS_READ) { - desired |= GENERIC_READ; - sharemode |= FILE_SHARE_READ; - } - if (access & FILEACCESS_WRITE) { - desired |= GENERIC_WRITE; - sharemode |= FILE_SHARE_WRITE; - } - if (access & FILEACCESS_CREATE) { - openmode = OPEN_ALWAYS; - } else { - openmode = OPEN_EXISTING; - } - //Let's do it! - entry.hFile = CreateFile(fullNameC, desired, sharemode, 0, openmode, 0, 0); - bool success = entry.hFile != INVALID_HANDLE_VALUE; -#else - // Convert flags in access parameter to fopen access mode - const char *mode = NULL; - if (access & FILEACCESS_APPEND) { - if (access & FILEACCESS_READ) - mode = "ab+"; // append+read, create if needed - else - mode = "ab"; // append only, create if needed - } else if (access & FILEACCESS_WRITE) { - if (access & FILEACCESS_READ) { - // FILEACCESS_CREATE is ignored for read only, write only, and append - // because C++ standard fopen's nonexistant file creation can only be - // customized for files opened read+write - if (access & FILEACCESS_CREATE) - mode = "wb+"; // read+write, create if needed - else - mode = "rb+"; // read+write, but don't create - } else { - mode = "wb"; // write only, create if needed - } - } else { // neither write nor append, so default to read only - mode = "rb"; // read only, don't create - } - - entry.hFile = fopen(fullNameC, mode); - bool success = entry.hFile != 0; -#endif - -#if HOST_IS_CASE_SENSITIVE - if (!success && - !(access & FILEACCESS_APPEND) && - !(access & FILEACCESS_CREATE) && - !(access & FILEACCESS_WRITE)) - { - if ( ! FixPathCase(filename, FPC_PATH_MUST_EXIST) ) - return 0; // or go on and attempt (for a better error code than just 0?) - fullName = GetLocalPath(filename); - fullNameC = fullName.c_str(); - - DEBUG_LOG(HLE, "Case may have been incorrect, second try opening %s (%s)", fullNameC, filename.c_str()); - - // And try again with the correct case this time -#ifdef _WIN32 - entry.hFile = CreateFile(fullNameC, desired, sharemode, 0, openmode, 0, 0); - success = entry.hFile != INVALID_HANDLE_VALUE; -#else - entry.hFile = fopen(fullNameC, mode); - success = entry.hFile != 0; -#endif - } -#endif + bool success = entry.hFile.Open(fullName,access); if (!success) { #ifdef _WIN32 @@ -532,7 +452,7 @@ u32 DirectoryFileSystem::OpenFile(std::string filename, FileAccess access, const } else { #ifdef _WIN32 if (access & FILEACCESS_APPEND) - SetFilePointer(entry.hFile, 0, NULL, FILE_END); + entry.hFile.Seek(0,FILEMOVE_END); #endif u32 newHandle = hAlloc->GetNewHandle(); @@ -546,11 +466,7 @@ void DirectoryFileSystem::CloseFile(u32 handle) { EntryMap::iterator iter = entries.find(handle); if (iter != entries.end()) { hAlloc->FreeHandle(handle); -#ifdef _WIN32 - CloseHandle((*iter).second.hFile); -#else - fclose((*iter).second.hFile); -#endif + iter->second.hFile.Close(); entries.erase(iter); } else { //This shouldn't happen... @@ -567,62 +483,7 @@ size_t DirectoryFileSystem::ReadFile(u32 handle, u8 *pointer, s64 size) { EntryMap::iterator iter = entries.find(handle); if (iter != entries.end()) { - // it's the whole iso... it could reference any of the files on the disc. - // For now let's just open and close the files on demand. Can certainly be done - // better though - if (iter->second.wholeIso) - { - std::string fileName; - u32 firstBlock; - - if (findVirtualFileData(iter->second.curOffset,size*2048,fileName,firstBlock) == false) - { - ERROR_LOG(HLE,"DiscDirectoryFileSystem: Reading from unknown address", handle); - return 0; - } - - std::string fullName = GetLocalPath(fileName); - -#ifdef _WIN32 - HANDLE hFile = CreateFile(fullName.c_str(), GENERIC_READ, FILE_SHARE_READ, 0, OPEN_EXISTING, 0, 0); - bool success = hFile != INVALID_HANDLE_VALUE; -#else - FILE* hFile = fopen(fullName.c_str(), "rb"); - bool success = hFile != 0; -#endif - - if (!success) - { - ERROR_LOG(HLE,"DiscDirectoryFileSystem: Error opening file %s", fileName.c_str()); - return 0; - } - - u32 startOffset = (iter->second.curOffset-firstBlock)*2048; - size_t bytesRead; -#ifdef _WIN32 - SetFilePointer(hFile, (LONG)startOffset, 0, FILE_BEGIN); - ::ReadFile(hFile, (LPVOID)pointer, (DWORD)size*2048, (LPDWORD)&bytesRead, 0); - CloseHandle(hFile); -#else - fseek(hFile, startOffset, SEEK_SET); - bytesRead = fread(pointer, 1, size*2048, hFile); - fclose(hFile); -#endif - - return bytesRead; - } - - size_t bytesRead; -#ifdef _WIN32 - ::ReadFile(iter->second.hFile, (LPVOID)pointer, (DWORD)size, (LPDWORD)&bytesRead, 0); -#else - bytesRead = fread(pointer, 1, size, iter->second.hFile); -#endif - if (iter->second.lbnFile) - { - iter->second.curOffset += bytesRead; - } - + size_t bytesRead = iter->second.hFile.Read(pointer,size); return bytesRead; } else { //This shouldn't happen... @@ -632,21 +493,10 @@ size_t DirectoryFileSystem::ReadFile(u32 handle, u8 *pointer, s64 size) { } size_t DirectoryFileSystem::WriteFile(u32 handle, const u8 *pointer, s64 size) { - if (virtualDisc) - { - ERROR_LOG(HLE,"Cannot write to file on virtual disc"); - return 0; - } - EntryMap::iterator iter = entries.find(handle); if (iter != entries.end()) { - size_t bytesWritten; -#ifdef _WIN32 - ::WriteFile(iter->second.hFile, (LPVOID)pointer, (DWORD)size, (LPDWORD)&bytesWritten, 0); -#else - bytesWritten = fwrite(pointer, 1, size, iter->second.hFile); -#endif + size_t bytesWritten = iter->second.hFile.Write(pointer,size); return bytesWritten; } else { //This shouldn't happen... @@ -658,53 +508,7 @@ size_t DirectoryFileSystem::WriteFile(u32 handle, const u8 *pointer, s64 size) { size_t DirectoryFileSystem::SeekFile(u32 handle, s32 position, FileMove type) { EntryMap::iterator iter = entries.find(handle); if (iter != entries.end()) { - if (iter->second.wholeIso) - { - switch (type) { - case FILEMOVE_BEGIN: iter->second.curOffset = position; break; - case FILEMOVE_CURRENT: iter->second.curOffset += position; break; - case FILEMOVE_END: return -1; // unsupported - } - - return iter->second.curOffset; - } - - if (iter->second.lbnFile) - { - switch (type) { - case FILEMOVE_BEGIN: iter->second.curOffset = position; break; - case FILEMOVE_CURRENT: iter->second.curOffset += position; break; - case FILEMOVE_END: iter->second.curOffset = iter->second.size-position; break; - } - -#ifdef _WIN32 - u32 off = iter->second.startOffset+iter->second.curOffset; - DWORD newPos = SetFilePointer((*iter).second.hFile, (LONG)off, 0, FILE_BEGIN); -#else - fseek(iter->second.hFile, iter->second.curOffset+iter->second.startOffset, SEEK_SET); -#endif - return iter->second.curOffset; - } - -#ifdef _WIN32 - DWORD moveMethod = 0; - switch (type) { - case FILEMOVE_BEGIN: moveMethod = FILE_BEGIN; break; - case FILEMOVE_CURRENT: moveMethod = FILE_CURRENT; break; - case FILEMOVE_END: moveMethod = FILE_END; break; - } - DWORD newPos = SetFilePointer((*iter).second.hFile, (LONG)position, 0, moveMethod); - return newPos; -#else - int moveMethod = 0; - switch (type) { - case FILEMOVE_BEGIN: moveMethod = SEEK_SET; break; - case FILEMOVE_CURRENT: moveMethod = SEEK_CUR; break; - case FILEMOVE_END: moveMethod = SEEK_END; break; - } - fseek(iter->second.hFile, position, moveMethod); - return ftell(iter->second.hFile); -#endif + return iter->second.hFile.Seek(position,type); } else { //This shouldn't happen... ERROR_LOG(HLE,"Cannot seek in file that hasn't been opened: %08x", handle); @@ -712,19 +516,6 @@ size_t DirectoryFileSystem::SeekFile(u32 handle, s32 position, FileMove type) { } } -u32 DirectoryFileSystem::GetFileLbn(std::string& fileName) -{ - if (!virtualDisc) return -1; - - for (int i = 0; i < fileBlocks.size(); i++) - { - if (fileBlocks[i].fileName == fileName) - return fileBlocks[i].firstBlock; - } - - return -1; -} - PSPFileInfo DirectoryFileSystem::GetFileInfo(std::string filename) { PSPFileInfo x; x.name = filename; @@ -757,22 +548,7 @@ PSPFileInfo DirectoryFileSystem::GetFileInfo(std::string filename) { #else x.size = s.st_size; #endif - if (virtualDisc) - { - x.startSector = GetFileLbn(filename); - x.numSectors = (x.size+2047)/2048; - if (x.startSector == -1) - { - x.startSector = currentBlockIndex; - currentBlockIndex += x.numSectors; - LbnMapEntry entry; - entry.fileName = filename; - entry.firstBlock = x.startSector; - entry.totalSize = x.size; - fileBlocks.push_back(entry); - } - } x.access = s.st_mode & 0x1FF; localtime_r((time_t*)&s.st_atime,&x.atime); localtime_r((time_t*)&s.st_ctime,&x.ctime); @@ -887,6 +663,464 @@ void DirectoryFileSystem::DoState(PointerWrap &p) { } + +VirtualDiscFileSystem::VirtualDiscFileSystem(IHandleAllocator *_hAlloc, std::string _basePath) + : basePath(_basePath),currentBlockIndex(0) { + +#ifdef _WIN32 + if (basePath.size() > 0 && basePath[basePath.size()-1] != '\\') + basePath = basePath + "\\"; +#else + if (basePath.size() > 0 && basePath[basePath.size()-1] != '/') + basePath = basePath + "/"; +#endif + + hAlloc = _hAlloc; +} + +VirtualDiscFileSystem::~VirtualDiscFileSystem() { + for (auto iter = entries.begin(); iter != entries.end(); ++iter) { + if (!iter->second.type != VFILETYPE_ISO) + iter->second.hFile.Close(); + } +} + +void VirtualDiscFileSystem::DoState(PointerWrap &p) +{ + int fileListSize = fileList.size(); + int entryCount = entries.size(); + + p.Do(fileListSize); + p.Do(entryCount); + p.Do(currentBlockIndex); + + if (p.mode == p.MODE_READ) + { + fileList.clear(); + entries.clear(); + + for (int i = 0; i < fileListSize; i++) + { + FileListEntry entry; + p.Do(entry.fileName); + p.Do(entry.firstBlock); + p.Do(entry.totalSize); + fileList.push_back(entry); + } + + for (int i = 0; i < entryCount; i++) + { + u32 fd; + OpenFileEntry of; + + p.Do(fd); + p.Do(of.fileIndex); + p.Do(of.type); + p.Do(of.curOffset); + p.Do(of.startOffset); + p.Do(of.size); + + // open file + if (of.type != VFILETYPE_ISO) + { + std::string fullName = GetLocalPath(fileList[of.fileIndex].fileName); + bool success = of.hFile.Open(fullName,FILEACCESS_READ); + if (!success) + { + ERROR_LOG(FILESYS, "Failed to create file handle for %s.",fullName); + } else { + if (of.type == VFILETYPE_LBN) + { + of.hFile.Seek(of.curOffset+of.startOffset,FILEMOVE_BEGIN); + } else { + of.hFile.Seek(of.curOffset,FILEMOVE_BEGIN); + } + } + } + + entries[fd] = of; + } + } else { + for (int i = 0; i < fileListSize; i++) + { + p.Do(fileList[i].fileName); + p.Do(fileList[i].firstBlock); + p.Do(fileList[i].totalSize); + } + + for (EntryMap::iterator it = entries.begin(), end = entries.end(); it != end; ++it) + { + OpenFileEntry &of = it->second; + + p.Do(it->first); + p.Do(of.fileIndex); + p.Do(of.type); + p.Do(of.curOffset); + p.Do(of.startOffset); + p.Do(of.size); + } + } + + p.DoMarker("VirtualDiscFileSystem"); +} + +std::string VirtualDiscFileSystem::GetLocalPath(std::string localpath) { + if (localpath.empty()) + return basePath; + + if (localpath[0] == '/') + localpath.erase(0,1); + //Convert slashes +#ifdef _WIN32 + for (size_t i = 0; i < localpath.size(); i++) { + if (localpath[i] == '/') + localpath[i] = '\\'; + } +#endif + return basePath + localpath; +} + + +int VirtualDiscFileSystem::getFileListIndex(std::string& fileName) +{ + for (int i = 0; i < fileList.size(); i++) + { + if (fileList[i].fileName == fileName) + return i; + } + + // unknown file - add it + std::string fullName = GetLocalPath(fileName); + if (! File::Exists(fullName)) { +#if HOST_IS_CASE_SENSITIVE + if (! FixPathCase(fileName, FPC_FILE_MUST_EXIST)) + return -1; + fullName = GetLocalPath(fileName); + + if (! File::Exists(fullName)) + return -1; +#else + return -1; +#endif + } + + FileType type = File::IsDirectory(fullName) ? FILETYPE_DIRECTORY : FILETYPE_NORMAL; + if (type == FILETYPE_DIRECTORY) + return -1; + + FileListEntry entry; + entry.fileName = fileName; + + struct stat s; + + stat(fullName.c_str(), &s); +#ifdef _WIN32 + WIN32_FILE_ATTRIBUTE_DATA data; + GetFileAttributesEx(fullName.c_str(), GetFileExInfoStandard, &data); + + entry.totalSize = data.nFileSizeLow | ((u64)data.nFileSizeHigh<<32); +#else + entry.totalSize = s.st_size; +#endif + + entry.firstBlock = currentBlockIndex; + currentBlockIndex += (entry.totalSize+2047)/2048; + + fileList.push_back(entry); + + return fileList.size()-1; +} + +int VirtualDiscFileSystem::getFileListIndex(u32 accessBlock, u32 accessSize) +{ + for (int i = 0; i < fileList.size(); i++) + { + if (fileList[i].firstBlock <= accessBlock) + { + u32 sectorOffset = (accessBlock-fileList[i].firstBlock)*2048; + u32 endOffset = sectorOffset+accessSize; + if (endOffset <= fileList[i].totalSize) + { + return i; + } + } + } + + return -1; +} + +u32 VirtualDiscFileSystem::OpenFile(std::string filename, FileAccess access, const char *devicename) +{ + if (filename == "") + { + OpenFileEntry entry; + entry.type = VFILETYPE_ISO; + + u32 newHandle = hAlloc->GetNewHandle(); + entries[newHandle] = entry; + + return newHandle; + } + + if (filename.compare(0,8,"/sce_lbn") == 0) + { + u32 sectorStart = 0xFFFFFFFF, readSize = 0xFFFFFFFF; + parseLBN(filename, §orStart, &readSize); + + OpenFileEntry entry; + entry.type = VFILETYPE_LBN; + entry.size = readSize; + entry.curOffset = 0; + + entry.fileIndex= getFileListIndex(sectorStart,readSize); + if (entry.fileIndex == -1) + { + ERROR_LOG(FILESYS, "DiscDirectoryFileSystem: sce_lbn used without calling fileinfo."); + return 0; + } + + entry.startOffset = (sectorStart-fileList[entry.fileIndex].firstBlock)*2048; + + // now we just need an actual file handle + std::string fullName = GetLocalPath(fileList[entry.fileIndex].fileName); + bool success = entry.hFile.Open(fullName,FILEACCESS_READ); + + if (!success) + { + ERROR_LOG(HLE, "DiscDirectoryFileSystem::OpenFile: FAILED, %i", GetLastError()); + return 0; + } + + // seek to start + entry.hFile.Seek(entry.startOffset,FILEMOVE_BEGIN); + + u32 newHandle = hAlloc->GetNewHandle(); + entries[newHandle] = entry; + + return newHandle; + } + + std::string fullName = GetLocalPath(filename); + const char *fullNameC = fullName.c_str(); + + OpenFileEntry entry; + entry.type = VFILETYPE_NORMAL; + bool success = entry.hFile.Open(fullName,access); + + if (!success) { +#ifdef _WIN32 + ERROR_LOG(HLE, "VirtualDiscFileSystem::OpenFile: FAILED, %i - access = %i", GetLastError(), (int)access); +#else + ERROR_LOG(HLE, "VirtualDiscFileSystem::OpenFile: FAILED, access = %i", (int)access); +#endif + //wwwwaaaaahh!! + return 0; + } else { + entry.fileIndex = getFileListIndex(filename); + + u32 newHandle = hAlloc->GetNewHandle(); + entries[newHandle] = entry; + + return newHandle; + } +} + +size_t VirtualDiscFileSystem::SeekFile(u32 handle, s32 position, FileMove type) { + EntryMap::iterator iter = entries.find(handle); + if (iter != entries.end()) { + switch (iter->second.type) + { + case VFILETYPE_NORMAL: + { + return iter->second.hFile.Seek(position,type); + } + case VFILETYPE_LBN: + { + switch (type) + { + case FILEMOVE_BEGIN: iter->second.curOffset = position; break; + case FILEMOVE_CURRENT: iter->second.curOffset += position; break; + case FILEMOVE_END: iter->second.curOffset = iter->second.size-position; break; + } + + u32 off = iter->second.startOffset+iter->second.curOffset; + iter->second.hFile.Seek(off,FILEMOVE_BEGIN); + return iter->second.curOffset; + } + case VFILETYPE_ISO: + { + switch (type) + { + case FILEMOVE_BEGIN: iter->second.curOffset = position; break; + case FILEMOVE_CURRENT: iter->second.curOffset += position; break; + case FILEMOVE_END: return -1; // unsupported + } + + return iter->second.curOffset; + } + } + } else { + //This shouldn't happen... + ERROR_LOG(HLE,"Cannot seek in file that hasn't been opened: %08x", handle); + return 0; + } +} + +size_t VirtualDiscFileSystem::ReadFile(u32 handle, u8 *pointer, s64 size) { + EntryMap::iterator iter = entries.find(handle); + if (iter != entries.end()) + { + // it's the whole iso... it could reference any of the files on the disc. + // For now let's just open and close the files on demand. Can certainly be done + // better though + if (iter->second.type == VFILETYPE_ISO) + { + int fileIndex = getFileListIndex(iter->second.curOffset,size*2048); + if (fileIndex == -1) + { + ERROR_LOG(HLE,"VirtualDiscFileSystem: Reading from unknown address", handle); + return 0; + } + + std::string fullName = GetLocalPath(fileList[fileIndex].fileName); + DirectoryFileHandle hFile; + bool success = hFile.Open(fullName,FILEACCESS_READ); + + if (!success) + { + ERROR_LOG(HLE,"VirtualDiscFileSystem: Error opening file %s", fileList[fileIndex].fileName.c_str()); + return 0; + } + + u32 startOffset = (iter->second.curOffset-fileList[fileIndex].firstBlock)*2048; + size_t bytesRead; + + hFile.Seek(startOffset,FILEMOVE_BEGIN); + bytesRead = hFile.Read(pointer,size*2048); + hFile.Close(); + + return bytesRead; + } + + size_t bytesRead = iter->second.hFile.Read(pointer,size); + iter->second.curOffset += bytesRead; + return bytesRead; + } else { + //This shouldn't happen... + ERROR_LOG(HLE,"Cannot read file that hasn't been opened: %08x", handle); + return 0; + } +} + +void VirtualDiscFileSystem::CloseFile(u32 handle) { + EntryMap::iterator iter = entries.find(handle); + if (iter != entries.end()) { + hAlloc->FreeHandle(handle); + iter->second.hFile.Close(); + entries.erase(iter); + } else { + //This shouldn't happen... + ERROR_LOG(HLE,"Cannot close file that hasn't been opened: %08x", handle); + } +} + +bool VirtualDiscFileSystem::OwnsHandle(u32 handle) { + EntryMap::iterator iter = entries.find(handle); + return (iter != entries.end()); +} + +PSPFileInfo VirtualDiscFileSystem::GetFileInfo(std::string filename) { + PSPFileInfo x; + x.name = filename; + + std::string fullName = GetLocalPath(filename); + if (! File::Exists(fullName)) { +#if HOST_IS_CASE_SENSITIVE + if (! FixPathCase(filename, FPC_FILE_MUST_EXIST)) + return x; + fullName = GetLocalPath(filename); + + if (! File::Exists(fullName)) + return x; +#else + return x; +#endif + } + + x.type = File::IsDirectory(fullName) ? FILETYPE_DIRECTORY : FILETYPE_NORMAL; + x.exists = true; + + if (x.type != FILETYPE_DIRECTORY) + { + struct stat s; + stat(fullName.c_str(), &s); +#ifdef _WIN32 + WIN32_FILE_ATTRIBUTE_DATA data; + GetFileAttributesEx(fullName.c_str(), GetFileExInfoStandard, &data); + + x.size = data.nFileSizeLow | ((u64)data.nFileSizeHigh<<32); +#else + x.size = s.st_size; +#endif + + int fileIndex = getFileListIndex(filename); + x.startSector = fileList[fileIndex].firstBlock; + x.numSectors = (x.size+2047)/2048; + + x.access = s.st_mode & 0x1FF; + localtime_r((time_t*)&s.st_atime,&x.atime); + localtime_r((time_t*)&s.st_ctime,&x.ctime); + localtime_r((time_t*)&s.st_mtime,&x.mtime); + } + + return x; +} + +bool VirtualDiscFileSystem::GetHostPath(const std::string &inpath, std::string &outpath) +{ + outpath = GetLocalPath(inpath); + return true; +} + +std::vector VirtualDiscFileSystem::GetDirListing(std::string path) +{ + // todo + std::vector result; + return result; +} + +size_t VirtualDiscFileSystem::WriteFile(u32 handle, const u8 *pointer, s64 size) +{ + ERROR_LOG(HLE,"Cannot write to file on virtual disc"); + return 0; +} + +bool VirtualDiscFileSystem::MkDir(const std::string &dirname) +{ + ERROR_LOG(HLE,"Cannot create directory on virtual disc"); + return false; +} + +bool VirtualDiscFileSystem::RmDir(const std::string &dirname) +{ + ERROR_LOG(HLE,"Cannot remove directory on virtual disc"); + return false; +} + +int VirtualDiscFileSystem::RenameFile(const std::string &from, const std::string &to) +{ + ERROR_LOG(HLE,"Cannot rename file on virtual disc"); + return -1; +} + +bool VirtualDiscFileSystem::RemoveFile(const std::string &filename) +{ + ERROR_LOG(HLE,"Cannot remove file on virtual disc"); + return false; +} + + + VFSFileSystem::VFSFileSystem(IHandleAllocator *_hAlloc, std::string _basePath) : basePath(_basePath) { INFO_LOG(HLE, "Creating VFS file system"); hAlloc = _hAlloc; diff --git a/Core/FileSystems/DirectoryFileSystem.h b/Core/FileSystems/DirectoryFileSystem.h index ae5035f57d..8784151c22 100644 --- a/Core/FileSystems/DirectoryFileSystem.h +++ b/Core/FileSystems/DirectoryFileSystem.h @@ -47,9 +47,32 @@ typedef void * HANDLE; #endif +typedef struct sDirectoryFileHandle +{ +#ifdef _WIN32 + HANDLE hFile; +#else + FILE* hFile; +#endif + sDirectoryFileHandle() + { +#ifdef _WIN32 + hFile = (HANDLE)-1; +#else + hFile = 0; +#endif + } + + bool Open(std::string& fileName, FileAccess access); + size_t Read(u8* pointer, s64 size); + size_t Write(const u8* pointer, s64 size); + size_t Seek(s32 position, FileMove type); + void Close(); +} DirectoryFileHandle; + class DirectoryFileSystem : public IFileSystem { public: - DirectoryFileSystem(IHandleAllocator *_hAlloc, std::string _basePath, bool _virtualDisc = false); + DirectoryFileSystem(IHandleAllocator *_hAlloc, std::string _basePath); ~DirectoryFileSystem(); void DoState(PointerWrap &p); @@ -69,48 +92,71 @@ public: bool GetHostPath(const std::string &inpath, std::string &outpath); private: - u32 GetFileLbn(std::string& fileName); - bool findVirtualFileData(u32 accessBlock, u32 accessSize, std::string& fileName, u32& firstBlock); - struct OpenFileEntry { -#ifdef _WIN32 - HANDLE hFile; -#else - FILE *hFile; -#endif - bool wholeIso; - bool lbnFile; - u32 startOffset; // only used by lbn files - u32 curOffset; // only used by lbn files and whole iso; - u32 size; // only used by lbn files + DirectoryFileHandle hFile; }; typedef std::map EntryMap; EntryMap entries; std::string basePath; IHandleAllocator *hAlloc; - bool virtualDisc; + // In case of Windows: Translate slashes, etc. + std::string GetLocalPath(std::string localpath); +}; + +class VirtualDiscFileSystem: public IFileSystem +{ +public: + VirtualDiscFileSystem(IHandleAllocator *_hAlloc, std::string _basePath); + ~VirtualDiscFileSystem(); + + void DoState(PointerWrap &p); + u32 OpenFile(std::string filename, FileAccess access, const char *devicename=NULL); + size_t SeekFile(u32 handle, s32 position, FileMove type); + size_t ReadFile(u32 handle, u8 *pointer, s64 size); + void CloseFile(u32 handle); + PSPFileInfo GetFileInfo(std::string filename); + bool OwnsHandle(u32 handle); + bool GetHostPath(const std::string &inpath, std::string &outpath); + std::vector GetDirListing(std::string path); + + // unsupported operations + size_t WriteFile(u32 handle, const u8 *pointer, s64 size); + bool MkDir(const std::string &dirname); + bool RmDir(const std::string &dirname); + int RenameFile(const std::string &from, const std::string &to); + bool RemoveFile(const std::string &filename); + +private: + int getFileListIndex(std::string& fileName); + int getFileListIndex(u32 accessBlock, u32 accessSize); + std::string GetLocalPath(std::string localpath); + + typedef enum { VFILETYPE_NORMAL, VFILETYPE_LBN, VFILETYPE_ISO } VirtualFileType; + + struct OpenFileEntry { + DirectoryFileHandle hFile; + VirtualFileType type; + u32 fileIndex; + u32 curOffset; + u32 startOffset; // only used by lbn files + u32 size; // only used by lbn files + }; + + typedef std::map EntryMap; + EntryMap entries; + IHandleAllocator *hAlloc; + std::string basePath; + typedef struct { std::string fileName; u32 firstBlock; u32 totalSize; - } LbnMapEntry; + } FileListEntry; - std::vector fileBlocks; + std::vector fileList; u32 currentBlockIndex; - - // In case of Windows: Translate slashes, etc. - std::string GetLocalPath(std::string localpath); - -#if HOST_IS_CASE_SENSITIVE - typedef enum { - FPC_FILE_MUST_EXIST, // all path components must exist (rmdir, move from) - FPC_PATH_MUST_EXIST, // all except the last one must exist - still tries to fix last one (fopen, move to) - FPC_PARTIAL_ALLOWED, // don't care how many exist (mkdir recursive) - } FixPathCaseBehavior; - bool FixPathCase(std::string &path, FixPathCaseBehavior behavior); -#endif }; // VFSFileSystem: Ability to map in Android APK paths as well! Does not support all features, only meant for fonts. diff --git a/Core/PSPLoaders.cpp b/Core/PSPLoaders.cpp index b010d30b12..d4ec9500a1 100644 --- a/Core/PSPLoaders.cpp +++ b/Core/PSPLoaders.cpp @@ -53,7 +53,7 @@ void InitMemoryForGameISO(std::string fileToStart) { if (info.isDirectory) { - umd2 = new DirectoryFileSystem(&pspFileSystem, fileToStart,true); + umd2 = new VirtualDiscFileSystem(&pspFileSystem, fileToStart); } else { diff --git a/UI/GameInfoCache.cpp b/UI/GameInfoCache.cpp index ca90e9aefd..81ab0ed339 100644 --- a/UI/GameInfoCache.cpp +++ b/UI/GameInfoCache.cpp @@ -229,7 +229,7 @@ public: { info_->fileType = FILETYPE_PSP_ISO; SequentialHandleAllocator handles; - DirectoryFileSystem umd(&handles,gamePath_.c_str(),true); + VirtualDiscFileSystem umd(&handles,gamePath_.c_str()); // Alright, let's fetch the PARAM.SFO. std::string paramSFOcontents;