static void menu_init(void) {
display_clear();
fileNumb = 0;
fileGet(fileNumb);
dispHead(header);
pageList();
}
size_t cResources::fileLoadTo( const std::string& pFilename, uint8* pTarget ) {
size_t Size = 0;
uint8* File = fileGet( pFilename, Size );
memcpy( pTarget, File, Size );
delete[] File;
return Size;
}
static void fileReturn(void) {
//во первых, удалим текущую информацию о местоположении:
brCrumbs[level][0] = 0;
brCrumbs[level][1] = 0;
brCrumbs[level][2] = 0;
//вернемся на уровень назад, только если он еще больше нуля. А то уйдем нахер в минуса.
if (level > 0)
level--; //находясь на уровне выше, уже можно прочесть инфу о родителе:
fileNumb = brCrumbs[level][0]; //при этом положение курсора не сбрасывается! мы вернемся туда, откуда пришли.
fileGet(fileNumb); //Читаем инфу о файле.
pageList();
}
void doit()
{
const auto& vm=mapGet();
auto& files=fileGet();
files.init(vm);
void (CmdUnicode::* fileOne)(const FileUnit& )=nullptr;
if(modeOnly_.oneGet()=="bomAdd")
fileOne=&CmdUnicode::bomAdd;
else if (modeOnly_.oneGet()=="bomRemove")
fileOne=&CmdUnicode::bomRemove;
else if (modeOnly_.oneGet()=="valid")
fileOne=&CmdUnicode::valid;
assert(fileOne);
files.loop([this, fileOne](FileUnit&& fu)
{
(this->*fileOne)(fu);
return errorBreak()==false;
}
);
}
void doit()
{
const auto& vm=mapGet();
auto& files=fileGet();
files.init(vm);
files.loop([this](FileUnit&& fu)
{
if(fu.isExist()==false || fu.isDir())
return false;
bf::ifstream in(fu.total.path(), std::ios::in | std::ios::binary);
if(!in)
return false;
core::MD5Compute md5;
std::vector<char> buf(4*1024);
size_t totalSize = 0;
for(;;)
{
in.read(buf.data(), buf.size());
auto const count=static_cast<int>(in.gcount());
if (count <= 0)
break;
totalSize += count;
md5.append(reinterpret_cast<const uint8_t*>(buf.data()), count);
}
md5.finish();
const auto& md5sum=md5.sumGet();
stdOut() << fu.self << " " << md5sum.toString() << std::endl;
return errorBreak()==false;
}
);
}
never_inline s32 savedata_op(
PPUThread& CPU,
u32 operation,
u32 version,
vm::cptr<char> dirName,
u32 errDialog,
vm::ptr<CellSaveDataSetList> setList,
vm::ptr<CellSaveDataSetBuf> setBuf,
vm::ptr<CellSaveDataListCallback> funcList,
vm::ptr<CellSaveDataFixedCallback> funcFixed,
vm::ptr<CellSaveDataStatCallback> funcStat,
vm::ptr<CellSaveDataFileCallback> funcFile,
u32 container,
u32 unknown, // 0, 2, 6
vm::ptr<void> userdata,
u32 userId,
vm::ptr<CellSaveDataDoneCallback> funcDone)
{
// TODO: check arguments
// try to lock the mutex (not sure how it originally works; std::try_to_lock makes it non-blocking)
std::unique_lock<std::mutex> lock(g_savedata_dialog->mutex, std::try_to_lock);
if (!lock)
{
return CELL_SAVEDATA_ERROR_BUSY;
}
// path of the specified user (00000001 by default)
const std::string base_dir = fmt::format("/dev_hdd0/home/%08d/savedata/", userId ? userId : 1u);
vm::stackvar<CellSaveDataCBResult> result(CPU);
result->userdata = userdata; // probably should be assigned only once (allows the callback to change it)
SaveDataEntry save_entry;
if (setList)
{
std::vector<SaveDataEntry> save_entries;
vm::stackvar<CellSaveDataListGet> listGet(CPU);
listGet->dirNum = 0;
listGet->dirListNum = 0;
listGet->dirList.set(setBuf->buf.addr());
memset(listGet->reserved, 0, sizeof(listGet->reserved));
const auto prefix_list = fmt::split(setList->dirNamePrefix.get_ptr(), { "|" });
for (const auto entry : vfsDir(base_dir))
{
if (entry->flags & DirEntry_TypeFile)
{
continue;
}
for (const auto& prefix : prefix_list)
{
if (entry->name.substr(0, prefix.size()) == prefix)
{
// Count the amount of matches and the amount of listed directories
if (listGet->dirListNum++ < setBuf->dirListMax)
{
listGet->dirNum++;
// PSF parameters
vfsFile f(base_dir + entry->name + "/PARAM.SFO");
const PSFLoader psf(f);
if (!psf)
{
break;
}
SaveDataEntry save_entry2;
save_entry2.dirName = psf.GetString("SAVEDATA_DIRECTORY");
save_entry2.listParam = psf.GetString("SAVEDATA_LIST_PARAM");
save_entry2.title = psf.GetString("TITLE");
save_entry2.subtitle = psf.GetString("SUB_TITLE");
save_entry2.details = psf.GetString("DETAIL");
save_entry2.size = 0;
for (const auto entry2 : vfsDir(base_dir + entry->name))
{
save_entry2.size += entry2->size;
}
save_entry2.atime = entry->access_time;
save_entry2.mtime = entry->modify_time;
save_entry2.ctime = entry->create_time;
//save_entry2.iconBuf = NULL; // TODO: Here should be the PNG buffer
//save_entry2.iconBufSize = 0; // TODO: Size of the PNG file
save_entry2.isNew = false;
save_entries.push_back(save_entry2);
}
break;
}
}
}
// Sort the entries
{
const u32 order = setList->sortOrder;
const u32 type = setList->sortType;
if (order > CELL_SAVEDATA_SORTORDER_ASCENT || type > CELL_SAVEDATA_SORTTYPE_SUBTITLE)
{
// error
}
std::sort(save_entries.begin(), save_entries.end(), [=](const SaveDataEntry& entry1, const SaveDataEntry& entry2)
{
if (order == CELL_SAVEDATA_SORTORDER_DESCENT && type == CELL_SAVEDATA_SORTTYPE_MODIFIEDTIME)
{
return entry1.mtime >= entry2.mtime;
}
if (order == CELL_SAVEDATA_SORTORDER_DESCENT && type == CELL_SAVEDATA_SORTTYPE_SUBTITLE)
{
return entry1.subtitle >= entry2.subtitle;
}
if (order == CELL_SAVEDATA_SORTORDER_ASCENT && type == CELL_SAVEDATA_SORTTYPE_MODIFIEDTIME)
{
return entry1.mtime < entry2.mtime;
}
if (order == CELL_SAVEDATA_SORTORDER_ASCENT && type == CELL_SAVEDATA_SORTTYPE_SUBTITLE)
{
return entry1.subtitle < entry2.subtitle;
}
return true;
});
}
// Fill the listGet->dirList array
auto dir_list = listGet->dirList.get_ptr();
for (const auto& entry : save_entries)
{
auto& dir = *dir_list++;
strcpy_trunc(dir.dirName, entry.dirName);
strcpy_trunc(dir.listParam, entry.listParam);
memset(dir.reserved, 0, sizeof(dir.reserved));
}
s32 selected = -1;
if (funcList)
{
vm::stackvar<CellSaveDataListSet> listSet(CPU);
// List Callback
funcList(CPU, result, listGet, listSet);
if (result->result < 0)
{
return CELL_SAVEDATA_ERROR_CBRESULT;
}
// Clean save data list
save_entries.erase(std::remove_if(save_entries.begin(), save_entries.end(), [&listSet](const SaveDataEntry& entry) -> bool
{
for (u32 i = 0; i < listSet->fixedListNum; i++)
{
if (entry.dirName == listSet->fixedList[i].dirName)
{
return false;
}
}
return true;
}), save_entries.end());
// Focus save data
s32 focused = -1;
switch (const u32 pos_type = listSet->focusPosition)
{
case CELL_SAVEDATA_FOCUSPOS_DIRNAME:
{
for (s32 i = 0; i < save_entries.size(); i++)
{
if (save_entries[i].dirName == listSet->focusDirName.get_ptr())
{
focused = i;
break;
}
}
break;
}
case CELL_SAVEDATA_FOCUSPOS_LISTHEAD:
{
focused = save_entries.empty() ? -1 : 0;
break;
}
case CELL_SAVEDATA_FOCUSPOS_LISTTAIL:
{
focused = save_entries.size() - 1;
break;
}
case CELL_SAVEDATA_FOCUSPOS_LATEST:
{
s64 max = INT64_MIN;
for (s32 i = 0; i < save_entries.size(); i++)
{
if (save_entries[i].mtime > max)
{
focused = i;
max = save_entries[i].mtime;
}
}
break;
}
case CELL_SAVEDATA_FOCUSPOS_OLDEST:
{
s64 min = INT64_MAX;
for (s32 i = 0; i < save_entries.size(); i++)
{
if (save_entries[i].mtime < min)
{
focused = i;
min = save_entries[i].mtime;
}
}
break;
}
case CELL_SAVEDATA_FOCUSPOS_NEWDATA:
{
break;
}
default:
{
cellSysutil.Error("savedata_op(): unknown listSet->focusPosition (0x%x)", pos_type);
return CELL_SAVEDATA_ERROR_PARAM;
}
}
// Display Save Data List
selected = g_savedata_dialog->ShowSaveDataList(save_entries, focused, listSet);
if (selected == -1)
{
if (listSet->newData)
{
save_entry.dirName = listSet->newData->dirName.get_ptr();
}
else
{
return CELL_OK; // ???
}
}
}
if (funcFixed)
{
vm::stackvar<CellSaveDataFixedSet> fixedSet(CPU);
// Fixed Callback
funcFixed(CPU, result, listGet, fixedSet);
if (result->result < 0)
{
return CELL_SAVEDATA_ERROR_CBRESULT;
}
for (s32 i = 0; i < save_entries.size(); i++)
{
if (save_entries[i].dirName == fixedSet->dirName.get_ptr())
{
selected = i;
break;
}
}
if (selected == -1)
{
save_entry.dirName = fixedSet->dirName.get_ptr();
}
}
if (selected >= 0)
{
if (selected < save_entries.size())
{
save_entry.dirName = std::move(save_entries[selected].dirName);
}
else
{
throw EXCEPTION("Invalid savedata selected");
}
}
}
if (dirName)
{
save_entry.dirName = dirName.get_ptr();
}
std::string dir_path = base_dir + save_entry.dirName + "/";
std::string sfo_path = dir_path + "PARAM.SFO";
PSFLoader psf;
// Load PARAM.SFO
{
vfsFile f(sfo_path);
psf.Load(f);
}
// Get save stats
{
vm::stackvar<CellSaveDataStatGet> statGet(CPU);
vm::stackvar<CellSaveDataStatSet> statSet(CPU);
std::string dir_local_path;
Emu.GetVFS().GetDevice(dir_path, dir_local_path);
fs::stat_t dir_info;
if (!fs::stat(dir_local_path, dir_info))
{
// error
}
statGet->hddFreeSizeKB = 40 * 1024 * 1024; // 40 GB
statGet->isNewData = save_entry.isNew = !psf;
statGet->dir.atime = save_entry.atime = dir_info.atime;
statGet->dir.mtime = save_entry.mtime = dir_info.mtime;
statGet->dir.ctime = save_entry.ctime = dir_info.ctime;
strcpy_trunc(statGet->dir.dirName, save_entry.dirName);
statGet->getParam.attribute = psf.GetInteger("ATTRIBUTE"); // ???
strcpy_trunc(statGet->getParam.title, save_entry.title = psf.GetString("TITLE"));
strcpy_trunc(statGet->getParam.subTitle, save_entry.subtitle = psf.GetString("SUB_TITLE"));
strcpy_trunc(statGet->getParam.detail, save_entry.details = psf.GetString("DETAIL"));
strcpy_trunc(statGet->getParam.listParam, save_entry.listParam = psf.GetString("SAVEDATA_LIST_PARAM"));
statGet->bind = 0;
statGet->sizeKB = save_entry.size / 1024;
statGet->sysSizeKB = 0; // This is the size of system files, but PARAM.SFO is very small and PARAM.PDF is not used
statGet->fileNum = 0;
statGet->fileList.set(setBuf->buf.addr());
statGet->fileListNum = 0;
memset(statGet->reserved, 0, sizeof(statGet->reserved));
auto file_list = statGet->fileList.get_ptr();
for (const auto entry : vfsDir(dir_path))
{
// only files, system files ignored, fileNum is limited by setBuf->fileListMax
if (entry->flags & DirEntry_TypeFile && entry->name != "PARAM.SFO" && statGet->fileListNum++ < setBuf->fileListMax)
{
statGet->fileNum++;
auto& file = *file_list++;
if (entry->name == "ICON0.PNG")
{
file.fileType = CELL_SAVEDATA_FILETYPE_CONTENT_ICON0;
}
else if (entry->name == "ICON1.PAM")
{
file.fileType = CELL_SAVEDATA_FILETYPE_CONTENT_ICON1;
}
else if (entry->name == "PIC1.PNG")
{
file.fileType = CELL_SAVEDATA_FILETYPE_CONTENT_PIC1;
}
else if (entry->name == "SND0.AT3")
{
file.fileType = CELL_SAVEDATA_FILETYPE_CONTENT_SND0;
}
else if (psf.GetInteger("*" + entry->name)) // let's put the list of protected files in PARAM.SFO (int param = 1 if protected)
{
file.fileType = CELL_SAVEDATA_FILETYPE_SECUREFILE;
}
else
{
file.fileType = CELL_SAVEDATA_FILETYPE_NORMALFILE;
}
file.size = entry->size;
file.atime = entry->access_time;
file.mtime = entry->modify_time;
file.ctime = entry->create_time;
strcpy_trunc(file.fileName, entry->name);
}
}
// Stat Callback
funcStat(CPU, result, statGet, statSet);
if (result->result < 0)
{
return CELL_SAVEDATA_ERROR_CBRESULT;
}
// Update PARAM.SFO
if (statSet->setParam)
{
psf.Clear();
psf.SetString("ACCOUNT_ID", ""); // ???
psf.SetInteger("ATTRIBUTE", statSet->setParam->attribute);
psf.SetString("CATEGORY", "SD"); // ???
psf.SetString("PARAMS", ""); // ???
psf.SetString("PARAMS2", ""); // ???
psf.SetInteger("PARENTAL_LEVEL", 0); // ???
psf.SetString("DETAIL", statSet->setParam->detail);
psf.SetString("SAVEDATA_DIRECTORY", save_entry.dirName);
psf.SetString("SAVEDATA_LIST_PARAM", statSet->setParam->listParam);
psf.SetString("SUB_TITLE", statSet->setParam->subTitle);
psf.SetString("TITLE", statSet->setParam->title);
}
switch (const u32 mode = statSet->reCreateMode & 0xffff)
{
case CELL_SAVEDATA_RECREATE_NO:
case CELL_SAVEDATA_RECREATE_NO_NOBROKEN:
{
break;
}
case CELL_SAVEDATA_RECREATE_YES:
case CELL_SAVEDATA_RECREATE_YES_RESET_OWNER:
{
// kill it with fire
for (const auto entry : vfsDir(dir_path))
{
if (entry->flags & DirEntry_TypeFile)
{
Emu.GetVFS().RemoveFile(dir_path + entry->name);
}
}
break;
}
default:
{
cellSysutil.Error("savedata_op(): unknown statSet->reCreateMode (0x%x)", statSet->reCreateMode);
return CELL_SAVEDATA_ERROR_PARAM;
}
}
}
// Create save directory if necessary
if (psf && save_entry.isNew && !Emu.GetVFS().CreateDir(dir_path))
{
// Let's ignore this error for now
}
// Enter the loop where the save files are read/created/deleted
vm::stackvar<CellSaveDataFileGet> fileGet(CPU);
vm::stackvar<CellSaveDataFileSet> fileSet(CPU);
fileGet->excSize = 0;
memset(fileGet->reserved, 0, sizeof(fileGet->reserved));
while (funcFile)
{
funcFile(CPU, result, fileGet, fileSet);
if (result->result < 0)
{
return CELL_SAVEDATA_ERROR_CBRESULT;
}
if (result->result == CELL_SAVEDATA_CBRESULT_OK_LAST || result->result == CELL_SAVEDATA_CBRESULT_OK_LAST_NOCONFIRM)
{
break;
}
std::string file_path;
switch (const u32 type = fileSet->fileType)
{
case CELL_SAVEDATA_FILETYPE_SECUREFILE:
case CELL_SAVEDATA_FILETYPE_NORMALFILE:
{
file_path = fileSet->fileName.get_ptr();
break;
}
case CELL_SAVEDATA_FILETYPE_CONTENT_ICON0:
{
file_path = "ICON0.PNG";
break;
}
case CELL_SAVEDATA_FILETYPE_CONTENT_ICON1:
{
file_path = "ICON1.PAM";
break;
}
case CELL_SAVEDATA_FILETYPE_CONTENT_PIC1:
{
file_path = "PIC1.PNG";
break;
}
case CELL_SAVEDATA_FILETYPE_CONTENT_SND0:
{
file_path = "SND0.AT3";
break;
}
default:
{
cellSysutil.Error("savedata_op(): unknown fileSet->fileType (0x%x)", type);
return CELL_SAVEDATA_ERROR_PARAM;
}
}
psf.SetInteger("*" + file_path, fileSet->fileType == CELL_SAVEDATA_FILETYPE_SECUREFILE);
std::string local_path;
Emu.GetVFS().GetDevice(dir_path + file_path, local_path);
switch (const u32 op = fileSet->fileOperation)
{
case CELL_SAVEDATA_FILEOP_READ:
{
fs::file file(local_path, o_read);
file.seek(fileSet->fileOffset);
fileGet->excSize = static_cast<u32>(file.read(fileSet->fileBuf.get_ptr(), std::min<u32>(fileSet->fileSize, fileSet->fileBufSize)));
break;
}
case CELL_SAVEDATA_FILEOP_WRITE:
{
fs::file file(local_path, o_write | o_create);
file.seek(fileSet->fileOffset);
fileGet->excSize = static_cast<u32>(file.write(fileSet->fileBuf.get_ptr(), std::min<u32>(fileSet->fileSize, fileSet->fileBufSize)));
file.trunc(file.seek(0, from_cur)); // truncate
break;
}
case CELL_SAVEDATA_FILEOP_DELETE:
{
fs::remove_file(local_path);
fileGet->excSize = 0;
break;
}
case CELL_SAVEDATA_FILEOP_WRITE_NOTRUNC:
{
fs::file file(local_path, o_write | o_create);
file.seek(fileSet->fileOffset);
fileGet->excSize = static_cast<u32>(file.write(fileSet->fileBuf.get_ptr(), std::min<u32>(fileSet->fileSize, fileSet->fileBufSize)));
break;
}
default:
{
cellSysutil.Error("savedata_op(): unknown fileSet->fileOperation (0x%x)", op);
return CELL_SAVEDATA_ERROR_PARAM;
}
}
}
// Write PARAM.SFO
if (psf)
{
vfsFile f(sfo_path, vfsWriteNew);
psf.Save(f);
}
return CELL_OK;
}
