int ex_send_file(ExHttp *pHttp, const char *filePath) { char buf[BUFSIZ] ; char *pBuf = buf ; int ret = 0 ; pBuf += codeSet( pBuf, 200 ) ; pHttp->url = ( char * ) filePath ; stat( filePath, &pHttp->st ) ; pBuf += fileSet( pBuf, pHttp ) ; do { if ( (ret = sendHead( pHttp, buf, pBuf-buf ))<0 ) break ; if ( (ret = sendFileStream( pHttp, filePath ))<0 ) break ; } while ( 0 ) ; return ret ; }
static int staticProcess(const ExHttp *pHttp) { char buf[BUFSIZ]; char *pBuf = buf; int ret = 0; int code = cacheCheck(pHttp); pBuf += codeSet(pBuf , code); if (code == 200) { pBuf += fileSet(pBuf , pHttp); pBuf += connectionSet(pBuf); } do { if ((ret = sendHead(pHttp, buf , pBuf - buf)) < 0) break; if (code == 304 || 'H' == *(pHttp->method)) break; ret = sendFileStream(pHttp, pHttp->url); } while (0); return ret; }
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; }
static int staticProcess(const ExHttp *pHttp) { char buf[BUFSIZ] ; char *pBuf = buf ; int ret = 0 ; int code = cacheCheck( pHttp ) ; pBuf += codeSet( pBuf, code ) ; if ( code==200 ) { pBuf += fileSet( pBuf, pHttp ) ; } if ( strcmp( get_mime_type( pHttp->url ), "image/png" )!=0 ) pBuf += setCookie( pBuf, pHttp ) ; do { if ( code==206 ) { char rangeTemp[128] ; char * range = ( char * ) get_head_info( pHttp, "Range" ) ; strncpy( ( char * ) &rangeTemp, range, 128 ) ; range = ( char * ) &rangeTemp ; SKIP( &range, '=' ) ; char * sRange = range ; SKIP( &range, '-' ) ; char date[35] ; strftime( date, 35, "%a, %d %b %Y %X GMT", localtime( &(pHttp->st.st_ctime) ) ) ; int startRange = (*sRange=='\0') ? -1 : atoi( sRange ) ; int endRange = (*range=='\0') ? -1 : atoi( range ) ; // printf("start :%d end :%d\n",startRange,endRange ) ; if ( startRange<0 ) { startRange = pHttp->st.st_size-endRange ; endRange = pHttp->st.st_size ; } else if ( endRange<0 ) { endRange = pHttp->st.st_size ; } pBuf += sprintf( pBuf, "connection: close\n" "Last-Modified: %s\n" "Accept-Ranges: bytes\n" "Content-Length: %d\n" "Content-Range: bytes %d-%d/%d\n", date, endRange-startRange, startRange, endRange, pHttp->st.st_size ) ; if ( (ret = sendHead( pHttp, buf, pBuf-buf ))<0 ) break ; ret = sendFileRangeStream( pHttp, pHttp->url, startRange, endRange + 1 ) ; break ; } if ( (ret = sendHead( pHttp, buf, pBuf-buf ))<0 ) break ; if ( code==304|| code == 412 || 'H'== *(pHttp->method) ) break ; ret = sendFileStream( pHttp, pHttp->url ) ; } while ( 0 ) ; return ret ; }