The-Homebrew-Cloud/wudd
2
0
Fork 0
mirror of https://github.com/wiiu-env/wudd.git synced 2024-11-21 17:39:15 +01:00
Code Issues Packages Projects Releases Wiki Activity

Format the code via clang-format

Browse Source
This commit is contained in:
Maschell 2022-07-26 08:16:27 +02:00
parent 8d0f3825f6
commit 990c67d481
109 changed files with 643 additions and 608 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

67
.clang-format Normal file
View File

@ -0,0 +1,67 @@
# Generated from CLion C/C++ Code Style settings
BasedOnStyle: LLVM
AccessModifierOffset: -4
AlignAfterOpenBracket: Align
AlignConsecutiveAssignments: Consecutive
AlignConsecutiveMacros: AcrossEmptyLinesAndComments
AlignOperands: Align
AllowAllArgumentsOnNextLine: false
AllowAllConstructorInitializersOnNextLine: false
AllowAllParametersOfDeclarationOnNextLine: false
AllowShortBlocksOnASingleLine: Always
AllowShortCaseLabelsOnASingleLine: false
AllowShortFunctionsOnASingleLine: All
AllowShortIfStatementsOnASingleLine: Always
AllowShortLambdasOnASingleLine: All
AllowShortLoopsOnASingleLine: true
AlwaysBreakAfterReturnType: None
AlwaysBreakTemplateDeclarations: Yes
BreakBeforeBraces: Custom
BraceWrapping:
AfterCaseLabel: false
AfterClass: false
AfterControlStatement: Never
AfterEnum: false
AfterFunction: false
AfterNamespace: false
AfterUnion: false
BeforeCatch: false
BeforeElse: false
IndentBraces: false
SplitEmptyFunction: false
SplitEmptyRecord: true
BreakBeforeBinaryOperators: None
BreakBeforeTernaryOperators: true
BreakConstructorInitializers: BeforeColon
BreakInheritanceList: BeforeColon
ColumnLimit: 0
CompactNamespaces: false
ContinuationIndentWidth: 8
IndentCaseLabels: true
IndentPPDirectives: None
IndentWidth: 4
KeepEmptyLinesAtTheStartOfBlocks: true
MaxEmptyLinesToKeep: 2
NamespaceIndentation: All
ObjCSpaceAfterProperty: false
ObjCSpaceBeforeProtocolList: true
PointerAlignment: Right
ReflowComments: false
SpaceAfterCStyleCast: true
SpaceAfterLogicalNot: false
SpaceAfterTemplateKeyword: false
SpaceBeforeAssignmentOperators: true
SpaceBeforeCpp11BracedList: false
SpaceBeforeCtorInitializerColon: true
SpaceBeforeInheritanceColon: true
SpaceBeforeParens: ControlStatements
SpaceBeforeRangeBasedForLoopColon: true
SpaceInEmptyParentheses: false
SpacesBeforeTrailingComments: 1
SpacesInAngles: false
SpacesInCStyleCastParentheses: false
SpacesInContainerLiterals: false
SpacesInParentheses: false
SpacesInSquareBrackets: false
TabWidth: 4
UseTab: Never

9
.github/workflows/ci.yml vendored
View File

@ -6,9 +6,16 @@ on:
- main
jobs:
clang-format:
runs-on: ubuntu-18.04
steps:
- uses: actions/checkout@v2
- name: clang-format
run: |
docker run --rm -v ${PWD}:/src wiiuenv/clang-format:13.0.0-2 -r ./source
build-binary:
runs-on: ubuntu-18.04
needs: clang-format
steps:
- uses: actions/checkout@v2
- name: Checkout submodules using a PAT

8
.github/workflows/pr.yml vendored
View File

@ -3,8 +3,16 @@ name: CI-PR
on: [pull_request]
jobs:
clang-format:
runs-on: ubuntu-18.04
steps:
- uses: actions/checkout@v2
- name: clang-format
run: |
docker run --rm -v ${PWD}:/src wiiuenv/clang-format:13.0.0-2 -r ./source
build-binary:
runs-on: ubuntu-18.04
needs: clang-format
steps:
- uses: actions/checkout@v2
- name: Checkout submodules using a PAT

12
README.md
View File

@ -28,11 +28,15 @@ It's possible to use a docker image for building. This way you don't need anythi
```
# Build docker image (only needed once)
docker build . -t WUDD-builder
docker build . -t wudd-builder
# make
docker run -it --rm -v ${PWD}:/project WUDD-builder make
docker run -it --rm -v ${PWD}:/project wudd-builder make
# make clean
docker run -it --rm -v ${PWD}:/project WUDD-builder make clean
```
docker run -it --rm -v ${PWD}:/project wudd-builder make clean
```
## Format the code via docker
`docker run --rm -v ${PWD}:/src wiiuenv/clang-format:13.0.0-2 -r ./source -i`

7
source/ApplicationState.h
View File

@ -1,8 +1,9 @@
#pragma once
#include <utils/WiiUScreen.h>
#include <utils/ScreenUtils.h>
#include "input/Input.h"
#include "utils/ScreenUtils.h"
#include "utils/WiiUScreen.h"
#include <stdint.h>
class ApplicationState {
public:

38
source/GMPartitionsDumperState.cpp
View File

@ -14,22 +14,22 @@
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
****************************************************************************/
#include "GMPartitionsDumperState.h"
#include <WUD/DiscReaderDiscDrive.h>
#include <WUD/NUSTitle.h>
#include <WUD/content/partitions/WiiUGMPartition.h>
#include <WUD/header/WiiUDiscHeader.h>
#include <common/common.h>
#include <fs/FSUtils.h>
#include <iosuhax.h>
#include <memory>
#include <WUD/DiscReaderDiscDrive.h>
#include <WUD/header/WiiUDiscHeader.h>
#include <fs/FSUtils.h>
#include <WUD/content/partitions/WiiUGMPartition.h>
#include <WUD/NUSTitle.h>
#include "GMPartitionsDumperState.h"
#include <utils/StringTools.h>
#define READ_BUFFER_SIZE (SECTOR_SIZE * 128)
GMPartitionsDumperState::GMPartitionsDumperState(eDumpTarget pTargetDevice) : targetDevice(pTargetDevice) {
this->sectorBufSize = SECTOR_SIZE;
this->state = STATE_OPEN_ODD1;
this->state = STATE_OPEN_ODD1;
}
GMPartitionsDumperState::~GMPartitionsDumperState() {
@ -72,9 +72,9 @@ void GMPartitionsDumperState::render() {
WiiUScreen::drawLine("This disc has no dumpable GM partitions ");
} else {
uint32_t index = 0;
for (auto &partitionPair: gmPartitionPairs) {
for (auto &partitionPair : gmPartitionPairs) {
uint32_t size = 0;
for (auto &content: partitionPair.second->tmd->contentList) {
for (auto &content : partitionPair.second->tmd->contentList) {
size += ROUNDUP(content->encryptedFileSize, 16);
}
WiiUScreen::drawLinef("%s %s (~%0.2f MiB)", index == (uint32_t) selectedOptionY ? ">" : " ", partitionPair.first->getVolumeId().c_str(), (float) size / 1024.0f / 1024.0f);
@ -98,10 +98,10 @@ void GMPartitionsDumperState::render() {
WiiUScreen::drawLine("Dumping Partition");
}
uint64_t partitionSize = 0;
uint64_t partitionSize = 0;
uint64_t partitionOffset = curOffsetInContent;
if (curNUSTitle != nullptr) {
for (auto &content: curNUSTitle->tmd->contentList) {
for (auto &content : curNUSTitle->tmd->contentList) {
partitionSize += ROUNDUP(content->encryptedFileSize, 16);
if (content->index < curContentIndex) {
partitionOffset += ROUNDUP(content->encryptedFileSize, 16);
@ -122,7 +122,7 @@ void GMPartitionsDumperState::render() {
}
auto offset = curOffsetInContent;
auto size = curContent != nullptr ? ROUNDUP(curContent->encryptedFileSize, 16) : 0;
auto size = curContent != nullptr ? ROUNDUP(curContent->encryptedFileSize, 16) : 0;
if (size > 0) {
WiiUScreen::drawLinef("Progress: %.2f MiB / %.2f MiB (%0.2f%%)", offset / 1024.0f / 1024.0f,
@ -205,10 +205,10 @@ ApplicationState::eSubState GMPartitionsDumperState::update(Input *input) {
return SUBSTATE_RUNNING;
}
this->discHeader = std::move(discHeaderOpt.value());
this->state = STATE_PROCESS_GM_PARTITIONS;
this->state = STATE_PROCESS_GM_PARTITIONS;
} else if (this->state == STATE_PROCESS_GM_PARTITIONS) {
this->gmPartitionPairs.clear();
for (auto &partition: discHeader->wiiUContentsInformation->partitions->partitions) {
for (auto &partition : discHeader->wiiUContentsInformation->partitions->partitions) {
auto gmPartition = std::dynamic_pointer_cast<WiiUGMPartition>(partition);
if (gmPartition != nullptr) {
auto nusTitleOpt = NUSTitle::loadTitleFromGMPartition(gmPartition, discReader, cKey);
@ -235,7 +235,7 @@ ApplicationState::eSubState GMPartitionsDumperState::update(Input *input) {
auto gmPartitionPair = gmPartitionPairs[selectedOptionY];
if (gmPartitionPair.first != nullptr) {
this->curPartition = gmPartitionPair.first;
this->curNUSTitle = gmPartitionPair.second;
this->curNUSTitle = gmPartitionPair.second;
this->dataProvider = this->curNUSTitle->dataProcessor->getDataProvider();
} else {
DEBUG_FUNCTION_LINE("Failed to find a GM partition");
@ -290,7 +290,7 @@ ApplicationState::eSubState GMPartitionsDumperState::update(Input *input) {
return SUBSTATE_RUNNING;
}
this->curContentIndex = 0;
this->state = STATE_DUMP_PARTITION_CONTENTS;
this->state = STATE_DUMP_PARTITION_CONTENTS;
} else if (this->state == STATE_DUMP_PARTITION_CONTENTS) {
// Get current content by index.
if (curContent == nullptr) {
@ -386,13 +386,13 @@ ApplicationState::eSubState GMPartitionsDumperState::update(Input *input) {
}
void GMPartitionsDumperState::setError(GMPartitionsDumperState::eErrorState err) {
this->state = STATE_ERROR;
this->state = STATE_ERROR;
this->errorState = err;
//OSEnableHomeButtonMenu(true);
}
std::string GMPartitionsDumperState::getPathForDevice(eDumpTarget target) const {
if (target == TARGET_NTFS){
if (target == TARGET_NTFS) {
return "ntfs0:/";
}
return "fs:/vol/external01/";
@ -504,5 +504,3 @@ std::string GMPartitionsDumperState::ErrorDescription() const {
}
return "UNKNOWN_ERROR";
}

29
source/GMPartitionsDumperState.h
View File

@ -16,17 +16,18 @@
****************************************************************************/
#pragma once
#include "ApplicationState.h"
#include "common/common.h"
#include "fs/WUXFileWriter.h"
#include "fs/WriteOnlyFileWithCache.h"
#include <WUD/NUSTitle.h>
#include <WUD/entities/TMD/Content.h>
#include <WUD/header/WiiUDiscHeader.h>
#include <input/Input.h>
#include <map>
#include <memory>
#include <string>
#include <vector>
#include <memory>
#include <input/Input.h>
#include "ApplicationState.h"
#include "fs/WriteOnlyFileWithCache.h"
#include "fs/WUXFileWriter.h"
#include <WUD/entities/TMD/Content.h>
#include <WUD/NUSTitle.h>
#include <WUD/header/WiiUDiscHeader.h>
class GMPartitionsDumperState : public ApplicationState {
public:
@ -88,22 +89,22 @@ public:
std::array<uint8_t, 11> discId{};
std::array<uint8_t, 0x10> cKey{};
int32_t oddFd = -1;
int32_t oddFd = -1;
void *sectorBuf = nullptr;
uint32_t sectorBufSize;
std::shared_ptr<DiscReaderDiscDrive> discReader = nullptr;
std::unique_ptr<WiiUDiscHeader> discHeader = nullptr;
std::unique_ptr<WiiUDiscHeader> discHeader = nullptr;
std::shared_ptr<WiiUGMPartition> curPartition = nullptr;
std::shared_ptr<NUSDataProvider> dataProvider = nullptr;
std::string targetPath;
std::shared_ptr<NUSTitle> curNUSTitle = nullptr;
uint16_t curContentIndex = 0;
std::unique_ptr<CFile> contentFile = nullptr;
uint16_t curContentIndex = 0;
std::unique_ptr<CFile> contentFile = nullptr;
std::shared_ptr<Content> curContent = nullptr;
uint8_t *readBuffer = nullptr;
uint32_t curOffsetInContent = 0;
uint8_t *readBuffer = nullptr;
uint32_t curOffsetInContent = 0;
[[nodiscard]] std::string ErrorMessage() const;

11
source/MainApplicationState.cpp
View File

@ -15,8 +15,8 @@
* along with this program. If not, see <http://www.gnu.org/licenses/>.
****************************************************************************/
#include "MainApplicationState.h"
#include "WUDDumperState.h"
#include "GMPartitionsDumperState.h"
#include "WUDDumperState.h"
#include <sysapp/launch.h>
MainApplicationState::MainApplicationState() {
@ -24,7 +24,8 @@ MainApplicationState::MainApplicationState() {
this->state = STATE_WELCOME_SCREEN;
}
MainApplicationState::~MainApplicationState() = default;;
MainApplicationState::~MainApplicationState() = default;
;
void MainApplicationState::render() {
if (this->state == STATE_DO_SUBSTATE) {
@ -73,13 +74,13 @@ ApplicationState::eSubState MainApplicationState::update(Input *input) {
}
if (entrySelected(input)) {
if (this->selectedOptionY == 0) {
this->state = STATE_DO_SUBSTATE;
this->state = STATE_DO_SUBSTATE;
this->subState = std::make_unique<WUDDumperState>(WUDDumperState::DUMP_AS_WUX, dumpTarget);
} else if (this->selectedOptionY == 1) {
this->state = STATE_DO_SUBSTATE;
this->state = STATE_DO_SUBSTATE;
this->subState = std::make_unique<WUDDumperState>(WUDDumperState::DUMP_AS_WUD, dumpTarget);
} else if (this->selectedOptionY == 2) {
this->state = STATE_DO_SUBSTATE;
this->state = STATE_DO_SUBSTATE;
this->subState = std::make_unique<GMPartitionsDumperState>(dumpTarget);
} else if (this->selectedOptionY == 3) {
//

12
source/MainApplicationState.h
View File

@ -16,16 +16,16 @@
****************************************************************************/
#pragma once
#include "ApplicationState.h"
#include "fs/CFile.hpp"
#include "input/Input.h"
#include <common/common.h>
#include <ctime>
#include <map>
#include <memory>
#include <string>
#include <optional>
#include <queue>
#include <ctime>
#include <common/common.h>
#include "input/Input.h"
#include "fs/CFile.hpp"
#include "ApplicationState.h"
#include <string>
class MainApplicationState : public ApplicationState {

5
source/WUD/DefaultNUSDataProcessor.cpp
View File

@ -53,7 +53,6 @@ std::shared_ptr<NUSDataProvider> DefaultNUSDataProcessor::getDataProvider() {
DefaultNUSDataProcessor::DefaultNUSDataProcessor(
std::shared_ptr<NUSDataProvider> pDataProvider,
std::shared_ptr<NUSDecryption> pNUSDecryption) :
dataProvider(std::move(pDataProvider)),
nusDecryption(std::move(pNUSDecryption)) {
std::shared_ptr<NUSDecryption> pNUSDecryption) : dataProvider(std::move(pDataProvider)),
nusDecryption(std::move(pNUSDecryption)) {
}

2
source/WUD/DefaultNUSDataProcessor.h
View File

@ -16,8 +16,8 @@
****************************************************************************/
#pragma once
#include <utils/utils.h>
#include "NUSDataProcessor.h"
#include <utils/utils.h>
class DefaultNUSDataProcessor : public NUSDataProcessor {
public:

19
source/WUD/DiscReader.cpp
View File

@ -15,11 +15,11 @@
* along with this program. If not, see <http://www.gnu.org/licenses/>.
****************************************************************************/
#include <WUD/content/WiiUDiscContentsHeader.h>
#include <MainApplicationState.h>
#include <utils/rijndael.h>
#include <coreinit/debug.h>
#include <WUD/content/WiiUDiscContentsHeader.h>
#include <common/common.h>
#include <coreinit/debug.h>
#include <utils/rijndael.h>
bool DiscReader::readDecryptedChunk(uint64_t readOffset, uint8_t *out_buffer, uint8_t *key, uint8_t *IV) const {
int CHUNK_SIZE = 0x10000;
@ -59,9 +59,9 @@ bool DiscReader::readDecrypted(uint8_t *out_buffer, uint64_t clusterOffset, uint
int BLOCK_SIZE = 0x10000;
uint32_t usedSize = size;
uint32_t usedSize = size;
uint64_t usedFileOffset = fileOffset;
auto *buffer = (uint8_t *) malloc(BLOCK_SIZE);
auto *buffer = (uint8_t *) malloc(BLOCK_SIZE);
if (buffer == nullptr) {
return false;
}
@ -92,7 +92,7 @@ bool DiscReader::readDecrypted(uint8_t *out_buffer, uint64_t clusterOffset, uint
break;
}
maxCopySize = BLOCK_SIZE - blockOffset;
copySize = (usedSize > maxCopySize) ? maxCopySize : usedSize;
copySize = (usedSize > maxCopySize) ? maxCopySize : usedSize;
memcpy(out_buffer + totalread, buffer + blockOffset, copySize);
@ -133,9 +133,9 @@ bool DiscReader::readEncrypted(uint8_t *buf, uint64_t offset, uint32_t size) {
return true;
}
uint32_t missingFromPrevSector = offset % SECTOR_SIZE;
auto curOffset = offset;
uint32_t offsetInBuf = 0;
uint32_t totalRead = 0;
auto curOffset = offset;
uint32_t offsetInBuf = 0;
uint32_t totalRead = 0;
if (missingFromPrevSector > 0) {
auto offset_in_sectors = offset / SECTOR_SIZE;
if (!readEncryptedSector(sector_buf, 1, offset_in_sectors)) {
@ -149,7 +149,6 @@ bool DiscReader::readEncrypted(uint8_t *buf, uint64_t offset, uint32_t size) {
totalRead += toCopy;
curOffset += missingFromPrevSector;
offsetInBuf += missingFromPrevSector;
}
if (totalRead >= size) {

1
source/WUD/DiscReader.h
View File

@ -38,6 +38,7 @@ public:
uint8_t discKey[16]{};
bool hasDiscKey = false;
private:
uint8_t *sector_buf;
};

10
source/WUD/DiscReaderDiscDrive.cpp
View File

@ -14,13 +14,13 @@
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
****************************************************************************/
#include "DiscReaderDiscDrive.h"
#include <MainApplicationState.h>
#include <WUD/content/WiiUDiscContentsHeader.h>
#include <common/common.h>
#include <MainApplicationState.h>
#include <iosuhax.h>
#include <utils/rijndael.h>
#include <utils/logger.h>
#include "DiscReaderDiscDrive.h"
#include <utils/rijndael.h>
DiscReaderDiscDrive::DiscReaderDiscDrive() : DiscReader() {
@ -43,7 +43,7 @@ DiscReaderDiscDrive::DiscReaderDiscDrive() : DiscReader() {
auto discKeyRes = IOSUHAX_ODM_GetDiscKey(discKey);
if (discKeyRes >= 0) {
hasDiscKey = true;
hasDiscKey = true;
auto sector_buf_decrypted = (uint8_t *) malloc(READ_SECTOR_SIZE);
if (sector_buf_decrypted != nullptr) {
aes_set_key((uint8_t *) discKey);
@ -87,7 +87,7 @@ bool DiscReaderDiscDrive::readEncrypted(uint8_t *buf, uint64_t offset, uint32_t
if ((offset & 0x7FFF) != 0 || (size & 0x7FFF) != 0) {
return DiscReader::readEncrypted(buf, offset, size);
}
uint32_t block_cnt = size >> 15;
uint32_t block_cnt = size >> 15;
uint32_t offset_in_sectors = offset >> 15;
if (IOSUHAX_FSA_RawRead(gFSAfd, buf, 0x8000, block_cnt, offset_in_sectors, device_handle) < 0) {
DEBUG_FUNCTION_LINE("Failed to read from Disc");

4
source/WUD/DiscReaderDiscDrive.h
View File

@ -16,9 +16,9 @@
****************************************************************************/
#pragma once
#include "DiscReader.h"
#include <cstdint>
#include <optional>
#include "DiscReader.h"
class DiscReaderDiscDrive : public DiscReader {
public:
@ -35,6 +35,6 @@ public:
bool readEncrypted(uint8_t *buf, uint64_t offset, uint32_t size) override;
private:
bool init_done = false;
bool init_done = false;
int32_t device_handle = -1;
};

5
source/WUD/NUSDataProvider.h
View File

@ -16,9 +16,9 @@
****************************************************************************/
#pragma once
#include <cstdint>
#include <WUD/entities/TMD/Content.h>
#include <WUD/entities/FST/FST.h>
#include <WUD/entities/TMD/Content.h>
#include <cstdint>
class NUSDataProvider {
@ -36,6 +36,5 @@ public:
virtual bool getRawCert(std::vector<uint8_t> &out_data) = 0;
virtual void setFST(const std::shared_ptr<FST> &fst) {
}
};

6
source/WUD/NUSDataProviderWUD.cpp
View File

@ -18,7 +18,7 @@
NUSDataProviderWUD::NUSDataProviderWUD(const std::shared_ptr<WiiUGMPartition> &pGamePartition, const std::shared_ptr<DiscReader> &pDiscReader) {
gamePartition = pGamePartition;
discReader = pDiscReader;
discReader = pDiscReader;
}
NUSDataProviderWUD::~NUSDataProviderWUD() = default;
@ -48,9 +48,9 @@ bool NUSDataProviderWUD::getContentH3Hash(const std::shared_ptr<Content> &conten
void NUSDataProviderWUD::setFST(const std::shared_ptr<FST> &pFST) {
// We need to set the correct blocksizes
auto blockSize = gamePartition->getVolumes().begin()->second->blockSize;
for (const auto &e: pFST->sectionEntries->getSections()) {
for (const auto &e : pFST->sectionEntries->getSections()) {
e->address = AddressInVolumeBlocks(blockSize, e->address.value);
e->size = SizeInVolumeBlocks(blockSize, e->size.value);
e->size = SizeInVolumeBlocks(blockSize, e->size.value);
}
fst = pFST;
}

6
source/WUD/NUSDataProviderWUD.h
View File

@ -16,11 +16,11 @@
****************************************************************************/
#pragma once
#include <WUD/content/partitions/WiiUGMPartition.h>
#include "NUSDataProvider.h"
#include "DiscReader.h"
#include <utils/FSTUtils.h>
#include "NUSDataProvider.h"
#include <WUD/content/partitions/WiiUGMPartition.h>
#include <coreinit/debug.h>
#include <utils/FSTUtils.h>
class NUSDataProviderWUD : public NUSDataProvider {

15
source/WUD/NUSTitle.cpp
View File

@ -45,7 +45,7 @@ std::optional<std::shared_ptr<NUSTitle>> NUSTitle::loadTitle(const std::shared_p
dataBuffer.clear();
auto decryption = std::make_shared<NUSDecryption>(std::move(ticketOpt.value()));
auto dpp = std::shared_ptr<NUSDataProcessor>(new DefaultNUSDataProcessor(dataProvider, decryption));
auto dpp = std::shared_ptr<NUSDataProcessor>(new DefaultNUSDataProcessor(dataProvider, decryption));
// If we have more than one content, the index 0 is the FST.
auto fstContentOpt = tmdOpt.value()->getContentByIndex(0);
@ -78,13 +78,12 @@ NUSTitle::NUSTitle(std::shared_ptr<TitleMetaData> pTMD,
std::shared_ptr<Ticket> pTicket,
std::shared_ptr<FST> pFST) :
dataProcessor(std::move(pProcessor)),
tmd(std::move(pTMD)),
ticket(std::move(pTicket)),
fst(std::move(pFST)),
decryption(std::move(pDecryption)),
dataProvider(std::move(pDataProvider)) {
dataProcessor(std::move(pProcessor)),
tmd(std::move(pTMD)),
ticket(std::move(pTicket)),
fst(std::move(pFST)),
decryption(std::move(pDecryption)),
dataProvider(std::move(pDataProvider)) {
}
std::optional<std::shared_ptr<NUSTitle>>

13
source/WUD/NUSTitle.h
View File

@ -16,15 +16,15 @@
****************************************************************************/
#pragma once
#include <WUD/NUSDataProvider.h>
#include <WUD/entities/TMD/TitleMetaData.h>
#include <WUD/content/partitions/WiiUGMPartition.h>
#include "Ticket.h"
#include "NUSDataProcessor.h"
#include "NUSDecryption.h"
#include "DefaultNUSDataProcessor.h"
#include "DiscReaderDiscDrive.h"
#include "NUSDataProcessor.h"
#include "NUSDataProviderWUD.h"
#include "NUSDecryption.h"
#include "Ticket.h"
#include <WUD/NUSDataProvider.h>
#include <WUD/content/partitions/WiiUGMPartition.h>
#include <WUD/entities/TMD/TitleMetaData.h>
class NUSTitle {
@ -52,5 +52,4 @@ private:
std::shared_ptr<NUSDecryption> pDecryption,
std::shared_ptr<Ticket> pTicket,
std::shared_ptr<FST> pFST);
};

7
source/WUD/Ticket.cpp
View File

@ -18,9 +18,8 @@
#include <algorithm>
#include <utils/logger.h>
Ticket::Ticket(const std::array<uint8_t, 16> &pEncryptedKey, const std::array<uint8_t, 16> &pDecryptedKey) :
ticketKeyEnc(pEncryptedKey),
ticketKeyDec(pDecryptedKey) {
Ticket::Ticket(const std::array<uint8_t, 16> &pEncryptedKey, const std::array<uint8_t, 16> &pDecryptedKey) : ticketKeyEnc(pEncryptedKey),
ticketKeyDec(pDecryptedKey) {
}
std::optional<std::shared_ptr<Ticket>> Ticket::make_shared(const std::vector<uint8_t> &data, std::optional<const std::array<uint8_t, 16>> commonKey) {
@ -39,7 +38,7 @@ std::optional<std::shared_ptr<Ticket>> Ticket::make_shared(const std::vector<uin
uint8_t IV[0x10];
for (int i = 0; i < 8; i++) {
IV[i] = title_id[i];
IV[i] = title_id[i];
IV[i + 8] = 0x00;
}

4
source/WUD/Ticket.h
View File

@ -17,10 +17,10 @@
#pragma once
#include <cstdint>
#include <utils/rijndael.h>
#include <cstring>
#include <optional>
#include <memory>
#include <optional>
#include <utils/rijndael.h>
#include <vector>
class Ticket {

14
source/WUD/content/WiiUContentsInformation.cpp
View File

@ -14,13 +14,13 @@
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
****************************************************************************/
#include <coreinit/debug.h>
#include "WiiUContentsInformation.h"
#include <coreinit/debug.h>
uint32_t WiiUContentsInformation::LENGTH = 32768;
uint32_t WiiUContentsInformation::LENGTH = 32768;
std::optional<std::unique_ptr<WiiUContentsInformation>> WiiUContentsInformation::make_unique(const std::shared_ptr<DiscReader> &discReader, uint32_t offset) {
uint32_t curOffset = offset;
uint32_t curOffset = offset;
auto discContentHeaderOpt = WiiUDiscContentsHeader::make_unique(discReader, curOffset);
if (!discContentHeaderOpt.has_value()) {
DEBUG_FUNCTION_LINE("Failed to read WiiUDiscContentsHeader");
@ -47,9 +47,7 @@ std::optional<std::unique_ptr<WiiUContentsInformation>> WiiUContentsInformation:
WiiUContentsInformation::WiiUContentsInformation(std::unique_ptr<WiiUDiscContentsHeader> pDiscContentHeader,
std::unique_ptr<WiiUPartitions> pPartitions) :
discContentHeader(std::move(pDiscContentHeader)),
partitions(std::move(pPartitions)) {
};
std::unique_ptr<WiiUPartitions> pPartitions) : discContentHeader(std::move(pDiscContentHeader)),
partitions(std::move(pPartitions)){
};

4
source/WUD/content/WiiUContentsInformation.h
View File

@ -16,10 +16,10 @@
****************************************************************************/
#pragma once
#include <memory>
#include <WUD/DiscReader.h>
#include "WiiUDiscContentsHeader.h"
#include "partitions/WiiUPartitions.h"
#include <WUD/DiscReader.h>
#include <memory>
class WiiUContentsInformation {

13
source/WUD/content/WiiUDiscContentsHeader.cpp
View File

@ -14,9 +14,9 @@
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
****************************************************************************/
#include <utils/blocksize/DiscBlockSize.h>
#include <coreinit/debug.h>
#include "WiiUDiscContentsHeader.h"
#include <coreinit/debug.h>
#include <utils/blocksize/DiscBlockSize.h>
std::optional<std::unique_ptr<WiiUDiscContentsHeader>> WiiUDiscContentsHeader::make_unique(const std::shared_ptr<DiscReader> &discReader, uint32_t offset) {
auto *buffer = (uint8_t *) malloc(LENGTH);
@ -49,10 +49,7 @@ std::optional<std::unique_ptr<WiiUDiscContentsHeader>> WiiUDiscContentsHeader::m
return std::unique_ptr<WiiUDiscContentsHeader>(new WiiUDiscContentsHeader(blockSize, tocHash, numberOfPartition));
}
WiiUDiscContentsHeader::WiiUDiscContentsHeader(DiscBlockSize pSize, const std::array<uint8_t, 20> &pTocHash, uint32_t pNumberOfPartitions) :
blockSize(pSize),
numberOfPartition(pNumberOfPartitions),
tocHash(pTocHash) {
WiiUDiscContentsHeader::WiiUDiscContentsHeader(DiscBlockSize pSize, const std::array<uint8_t, 20> &pTocHash, uint32_t pNumberOfPartitions) : blockSize(pSize),
numberOfPartition(pNumberOfPartitions),
tocHash(pTocHash) {
}

6
source/WUD/content/WiiUDiscContentsHeader.h
View File

@ -16,11 +16,11 @@
****************************************************************************/
#pragma once
#include <WUD/DiscReader.h>
#include <algorithm>
#include <memory>
#include <WUD/DiscReader.h>
#include <utils/blocksize/DiscBlockSize.h>
#include <optional>
#include <utils/blocksize/DiscBlockSize.h>
class WiiUDiscContentsHeader {
@ -30,7 +30,7 @@ public:
std::array<uint8_t, 20> tocHash;
static constexpr uint32_t LENGTH = 2048;
static constexpr uint32_t MAGIC = 0xCCA6E67B;
static constexpr uint32_t MAGIC = 0xCCA6E67B;
static std::optional<std::unique_ptr<WiiUDiscContentsHeader>> make_unique(const std::shared_ptr<DiscReader> &discReader, uint32_t offset);

10
source/WUD/content/partitions/WiiUDataPartition.cpp
View File

@ -22,17 +22,15 @@ WiiUDataPartition::~WiiUDataPartition() = default;
WiiUDataPartition::WiiUDataPartition(
std::shared_ptr<WiiUPartition> pPartition,
std::shared_ptr<FST> pFST) :
fst(std::move(pFST)),
basePartition(std::move(pPartition)) {
std::shared_ptr<FST> pFST) : fst(std::move(pFST)),
basePartition(std::move(pPartition)) {
}
std::string WiiUDataPartition::getVolumeId() const &{
std::string WiiUDataPartition::getVolumeId() const & {
return basePartition->getVolumeId();
}
std::map<AddressInDiscBlocks, std::shared_ptr<VolumeHeader>> WiiUDataPartition::getVolumes() const &{
std::map<AddressInDiscBlocks, std::shared_ptr<VolumeHeader>> WiiUDataPartition::getVolumes() const & {
return basePartition->getVolumes();
}

5
source/WUD/content/partitions/WiiUDataPartition.h
View File

@ -16,11 +16,11 @@
****************************************************************************/
#pragma once
#include "WiiUPartition.h"
#include <WUD/entities/FST/FST.h>
#include <cstdint>
#include <cstdlib>
#include <WUD/entities/FST/FST.h>
#include <utils/blocksize/AddressInDiscBlocks.h>
#include "WiiUPartition.h"
class WiiUDataPartition : public WiiUPartition {
@ -43,4 +43,3 @@ public:
private:
std::shared_ptr<WiiUPartition> basePartition;
};

14
source/WUD/content/partitions/WiiUGMPartition.cpp
View File

@ -20,18 +20,18 @@ WiiUGMPartition::WiiUGMPartition(std::shared_ptr<WiiUPartition> partition,
std::vector<uint8_t> pRawTicket,
std::vector<uint8_t> pRawTMD,
std::vector<uint8_t> pRawCert)
: WiiUPartition(),
rawTicket(std::move(pRawTicket)),
rawTMD(std::move(pRawTMD)),
rawCert(std::move(pRawCert)),
basePartition(std::move(partition)) {
: WiiUPartition(),
rawTicket(std::move(pRawTicket)),
rawTMD(std::move(pRawTMD)),
rawCert(std::move(pRawCert)),
basePartition(std::move(partition)) {
}
std::string WiiUGMPartition::getVolumeId() const &{
std::string WiiUGMPartition::getVolumeId() const & {
return basePartition->getVolumeId();
}
std::map<AddressInDiscBlocks, std::shared_ptr<VolumeHeader>> WiiUGMPartition::getVolumes() const &{
std::map<AddressInDiscBlocks, std::shared_ptr<VolumeHeader>> WiiUGMPartition::getVolumes() const & {
return basePartition->getVolumes();
}

5
source/WUD/content/partitions/WiiUGMPartition.h
View File

@ -16,10 +16,10 @@
****************************************************************************/
#pragma once
#include <memory>
#include "WiiUPartition.h"
#include <cstdint>
#include <cstdlib>
#include "WiiUPartition.h"
#include <memory>
class WiiUGMPartition : public WiiUPartition {
public:
@ -43,4 +43,3 @@ public:
private:
std::shared_ptr<WiiUPartition> basePartition;
};

18
source/WUD/content/partitions/WiiUPartition.cpp
View File

@ -14,9 +14,9 @@
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
****************************************************************************/
#include <memory>
#include <coreinit/debug.h>
#include "WiiUPartition.h"
#include <coreinit/debug.h>
#include <memory>
uint64_t WiiUPartition::getSectionOffsetOnDefaultPartition() {
if (volumes.size() != 1) {
@ -52,14 +52,14 @@ std::optional<std::shared_ptr<WiiUPartition>> WiiUPartition::make_shared(const s
memset(name, 0, sizeof(name));
memcpy(name, buffer, 31);
auto volumeId = name;
uint8_t num = buffer[31];
uint8_t num = buffer[31];
std::map<AddressInDiscBlocks, std::shared_ptr<VolumeHeader>> volumes;
for (int i = 0; i < num; i++) {
auto address = *((uint32_t *) &buffer[32 + (i * 4)]);
auto address = *((uint32_t *) &buffer[32 + (i * 4)]);
AddressInDiscBlocks discLbaAddress = AddressInDiscBlocks(blockSize, address);
auto vh = VolumeHeader::make_shared(discReader, discLbaAddress.getAddressInBytes());
auto vh = VolumeHeader::make_shared(discReader, discLbaAddress.getAddressInBytes());
if (!vh.has_value()) {
free(buffer);
return {};
@ -77,11 +77,11 @@ std::optional<std::shared_ptr<WiiUPartition>> WiiUPartition::make_shared(const s
fileSystemDescriptor));
}
std::string WiiUPartition::getVolumeId() const &{
std::string WiiUPartition::getVolumeId() const & {
return volumeId;
}
std::map<AddressInDiscBlocks, std::shared_ptr<VolumeHeader>> WiiUPartition::getVolumes() const &{
std::map<AddressInDiscBlocks, std::shared_ptr<VolumeHeader>> WiiUPartition::getVolumes() const & {
return volumes;
}
@ -90,7 +90,3 @@ uint16_t WiiUPartition::getFileSystemDescriptor() const {
}
WiiUPartition::~WiiUPartition() = default;

11
source/WUD/content/partitions/WiiUPartition.h
View File

@ -16,11 +16,12 @@
****************************************************************************/
#pragma once
#include <map>
#include <utility>
#include <utils/blocksize/DiscBlockSize.h>
#include <utils/blocksize/AddressInDiscBlocks.h>
#include "volumes/VolumeHeader.h"
#include <map>
#include <memory>
#include <utility>
#include <utils/blocksize/AddressInDiscBlocks.h>
#include <utils/blocksize/DiscBlockSize.h>
class WiiUPartition {
@ -44,7 +45,7 @@ protected:
private:
WiiUPartition(char *pVolumeId, std::map<AddressInDiscBlocks, std::shared_ptr<VolumeHeader>> pVolumes, uint16_t pFileSystemDescriptor)
: volumeId(pVolumeId), volumes(std::move(pVolumes)), fileSystemDescriptor(pFileSystemDescriptor) {
: volumeId(pVolumeId), volumes(std::move(pVolumes)), fileSystemDescriptor(pFileSystemDescriptor) {
}
std::string volumeId;

28
source/WUD/content/partitions/WiiUPartitions.cpp
View File

@ -14,13 +14,13 @@
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
****************************************************************************/
#include <utils/FSTUtils.h>
#include <coreinit/debug.h>
#include <utils/FSTUtils.h>
#include <utility>
#include "WiiUPartitions.h"
#include "WiiUGMPartition.h"
#include "WiiUDataPartition.h"
#include "WiiUGMPartition.h"
#include "WiiUPartitions.h"
#include <utility>
bool WiiUPartitions::getFSTEntryAsByte(std::string &filePath,
const std::shared_ptr<FST> &fst,
@ -37,7 +37,7 @@ bool WiiUPartitions::getFSTEntryAsByte(std::string &filePath,
return false;
}
auto info = asFileEntry->getSectionEntry();
auto info = asFileEntry->getSectionEntry();
uint64_t sectionOffsetOnDisc = volumeAddress.getAddressInBytes() + info->address.getAddressInBytes();
out_data.resize(asFileEntry->getSize());
@ -70,7 +70,7 @@ WiiUPartitions::make_unique(const std::shared_ptr<DiscReader> &discReader, uint3
tmp.push_back(partitionOpt.value());
}
std::optional<std::shared_ptr<WiiUPartition>> SIPartition;
for (auto &partition: tmp) {
for (auto &partition : tmp) {
if (partition->getVolumeId().starts_with("SI")) {
SIPartition = partition;
break;
@ -78,10 +78,10 @@ WiiUPartitions::make_unique(const std::shared_ptr<DiscReader> &discReader, uint3
}
if (SIPartition.has_value()) {
for (auto const&[key, val]: SIPartition.value()->getVolumes()) {
auto volumeAddress = key;
for (auto const &[key, val] : SIPartition.value()->getVolumes()) {
auto volumeAddress = key;
auto volumeAddressInBytes = volumeAddress.getAddressInBytes();
auto volumeHeader = val;
auto volumeHeader = val;
std::vector<uint8_t> fstData;
fstData.resize(volumeHeader->FSTSize);
@ -106,7 +106,7 @@ WiiUPartitions::make_unique(const std::shared_ptr<DiscReader> &discReader, uint3
return {};
}
for (auto &child: siFST.value()->getRootEntry()->getDirChildren()) {
for (auto &child : siFST.value()->getRootEntry()->getDirChildren()) {
std::vector<uint8_t> bufferTicket;
std::string tikFilePath = std::string(child->getFullPath() + '/' + WUD_TICKET_FILENAME);
if (!getFSTEntryAsByte(tikFilePath, siFST.value(), volumeAddress, discReader, bufferTicket)) {
@ -135,7 +135,7 @@ WiiUPartitions::make_unique(const std::shared_ptr<DiscReader> &discReader, uint3
std::string partitionName = std::string("GM") + partitionNameRaw;
std::optional<std::shared_ptr<WiiUPartition>> curPartition;
for (auto &partition: tmp) {
for (auto &partition : tmp) {
if (partition->getVolumeId().starts_with(partitionName)) {
curPartition = partition;
break;
@ -151,10 +151,9 @@ WiiUPartitions::make_unique(const std::shared_ptr<DiscReader> &discReader, uint3
partitions.push_back(gmPartition);
}
}
}
for (auto &partition: tmp) {
for (auto &partition : tmp) {
if (partition->getVolumeId().starts_with("GM")) {
continue;
}
@ -162,7 +161,7 @@ WiiUPartitions::make_unique(const std::shared_ptr<DiscReader> &discReader, uint3
OSFatal("We can't handle more or less than one partion address yet.");
}
auto volumeAddress = partition->getVolumes().begin()->first;
auto vh = partition->getVolumes().begin()->second;
auto vh = partition->getVolumes().begin()->second;
std::vector<uint8_t> fstData;
fstData.resize(vh->FSTSize);
@ -190,4 +189,3 @@ WiiUPartitions::make_unique(const std::shared_ptr<DiscReader> &discReader, uint3
WiiUPartitions::WiiUPartitions(std::vector<std::shared_ptr<WiiUPartition>> pPartitions) : partitions(std::move(pPartitions)) {
}

18
source/WUD/content/partitions/WiiUPartitions.h
View File

@ -16,17 +16,17 @@
****************************************************************************/
#pragma once
#include <memory>
#include <cstdint>
#include <utils/blocksize/DiscBlockSize.h>
#include <utils/blocksize/AddressInDiscBlocks.h>
#include <WUD/entities/FST/FST.h>
#include <WUD/DiscReader.h>
#include "WiiUPartition.h"
#include <WUD/DiscReader.h>
#include <WUD/entities/FST/FST.h>
#include <cstdint>
#include <memory>
#include <utils/blocksize/AddressInDiscBlocks.h>
#include <utils/blocksize/DiscBlockSize.h>
#define WUD_TMD_FILENAME "title.tmd"
#define WUD_TICKET_FILENAME "title.tik"
#define WUD_CERT_FILENAME "title.cert"
#define WUD_TMD_FILENAME "title.tmd"
#define WUD_TICKET_FILENAME "title.tik"
#define WUD_CERT_FILENAME "title.cert"
class WiiUPartitions {

2
source/WUD/content/partitions/volumes/H3HashArray.cpp
View File

@ -15,8 +15,8 @@
* along with this program. If not, see <http://www.gnu.org/licenses/>.
****************************************************************************/
#include "H3HashArray.h"
#include <cstring>
#include <coreinit/debug.h>
#include <cstring>
H3HashArray::H3HashArray(uint8_t *pData, uint32_t pSize) {
size = pSize;

30
source/WUD/content/partitions/volumes/VolumeHeader.cpp
View File

@ -15,12 +15,12 @@
* along with this program. If not, see <http://www.gnu.org/licenses/>.
****************************************************************************/
#include <memory>
#include "VolumeHeader.h"
#include <coreinit/debug.h>
#include <memory>
#include <utils/logger.h>
uint32_t VolumeHeader::MAGIC = 0xCC93A4F5;
uint32_t VolumeHeader::MAGIC = 0xCC93A4F5;
std::vector<std::shared_ptr<H3HashArray>> VolumeHeader::getH3HashArray(uint8_t *h3Data, uint32_t pNumberOfH3HashArray, uint32_t pH3HashArrayListSize) {
std::vector<std::shared_ptr<H3HashArray>> arrayList;
@ -29,9 +29,9 @@ std::vector<std::shared_ptr<H3HashArray>> VolumeHeader::getH3HashArray(uint8_t *
}
for (uint32_t i = 1; i < pNumberOfH3HashArray; i++) {
auto *offsetPtr = (uint32_t *) &h3Data[i * 4];
auto *offsetPtr = (uint32_t *) &h3Data[i * 4];
uint32_t curOffset = offsetPtr[0];
uint32_t curEnd = pH3HashArrayListSize;
uint32_t curEnd = pH3HashArrayListSize;
if (i < pNumberOfH3HashArray - 1) {
// If it's not the last element, the end of our .h3 is the start of the next .h3
curEnd = offsetPtr[1];
@ -64,16 +64,16 @@ std::optional<std::shared_ptr<VolumeHeader>> VolumeHeader::make_shared(const std
return {};
}
auto blockSize = VolumeBlockSize(bufferUint[1]);
auto volumeSize = SizeInVolumeBlocks(blockSize, bufferUint[2]);
auto h3HashArrayListSize = bufferUint[3];
auto numberOfH3HashArray = bufferUint[4];
auto FSTSize = bufferUint[5];
auto FSTAddress = AddressInVolumeBlocks(blockSize, bufferUint[6]);
auto FSTHashMode = buffer[36];
auto encryptType = buffer[37];
auto majorVersion = buffer[38];
auto minorVersion = buffer[39];
auto blockSize = VolumeBlockSize(bufferUint[1]);
auto volumeSize = SizeInVolumeBlocks(blockSize, bufferUint[2]);
auto h3HashArrayListSize = bufferUint[3];
auto numberOfH3HashArray = bufferUint[4];
auto FSTSize = bufferUint[5];
auto FSTAddress = AddressInVolumeBlocks(blockSize, bufferUint[6]);
auto FSTHashMode = buffer[36];
auto encryptType = buffer[37];
auto majorVersion = buffer[38];
auto minorVersion = buffer[39];
auto expiringMajorVersion = buffer[40];
free(buffer);
@ -123,5 +123,3 @@ VolumeHeader::VolumeHeader(const VolumeBlockSize &pBlockSize,
h3HashArrayListSize(pH3HashArrayListSize),
numberOfH3HashArray(pNumberOfH3HashArray) {
}

14
source/WUD/content/partitions/volumes/VolumeHeader.h
View File

@ -16,16 +16,17 @@
****************************************************************************/
#pragma once
#include <utility>
#include <vector>
#include <cstdint>
#include "H3HashArray.h"
#include <WUD/DiscReader.h>
#include <utils/blocksize/VolumeBlockSize.h>
#include <cstdint>
#include <memory>
#include <optional>
#include <utility>
#include <utils/blocksize/AddressInVolumeBlocks.h>
#include <utils/blocksize/SizeInVolumeBlocks.h>
#include <optional>
#include <utils/blocksize/VolumeBlockSize.h>
#include <utils/utils.h>
#include "H3HashArray.h"
#include <vector>
class VolumeHeader {
@ -63,5 +64,4 @@ private:
std::vector<std::shared_ptr<H3HashArray>> pH3HashArrayList,
uint32_t pH3HashArrayListSize,
uint32_t pNumberOfH3HashArray);
};

10
source/WUD/entities/FST/FST.cpp
View File

@ -85,10 +85,8 @@ std::optional<std::shared_ptr<FST>> FST::make_shared(const std::vector<uint8_t>
FST::FST(std::unique_ptr<FSTHeader> pHeader,
std::shared_ptr<SectionEntries> pSectionEntries,
std::shared_ptr<StringTable> pStringTable,
std::unique_ptr<NodeEntries> pNodeEntries) :
sectionEntries(std::move(pSectionEntries)),
stringTable(std::move(pStringTable)),
nodeEntries(std::move(pNodeEntries)),
header(std::move(pHeader)) {
std::unique_ptr<NodeEntries> pNodeEntries) : sectionEntries(std::move(pSectionEntries)),
stringTable(std::move(pStringTable)),
nodeEntries(std::move(pNodeEntries)),
header(std::move(pHeader)) {
}

16
source/WUD/entities/FST/FST.h
View File

@ -16,15 +16,15 @@
****************************************************************************/
#pragma once
#include <optional>
#include <memory>
#include <cstdint>
#include <utility>
#include <WUD/entities/FST/header/FSTHeader.h>
#include <WUD/entities/FST/sectionentry/SectionEntries.h>
#include <WUD/entities/FST/stringtable/StringTable.h>
#include <WUD/entities/FST/nodeentry/NodeEntries.h>
#include <WUD/entities/FST/nodeentry/RootEntry.h>
#include <WUD/entities/FST/sectionentry/SectionEntries.h>
#include <WUD/entities/FST/stringtable/StringTable.h>
#include <cstdint>
#include <memory>
#include <optional>
#include <utility>
class FST {
public:
@ -33,12 +33,12 @@ public:
static std::optional<std::shared_ptr<FST>> make_shared(const std::vector<uint8_t> &data, uint32_t offset, const VolumeBlockSize &blockSize);
std::shared_ptr<SectionEntries> sectionEntries;
private:
FST(std::unique_ptr<FSTHeader> pHeader,
std::shared_ptr<SectionEntries> pSectionEntries,
std::shared_ptr<StringTable> pStringTable,
std::unique_ptr<NodeEntries> pNodeEntries
);
std::unique_ptr<NodeEntries> pNodeEntries);
std::shared_ptr<StringTable> stringTable;
std::unique_ptr<NodeEntries> nodeEntries;

12
source/WUD/entities/FST/header/FSTHeader.cpp
View File

@ -14,9 +14,9 @@
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
****************************************************************************/
#include "FSTHeader.h"
#include <utils/blocksize/SectionBlockSize.h>
#include <utils/logger.h>
#include "FSTHeader.h"
std::optional<std::unique_ptr<FSTHeader>> FSTHeader::make_unique(const std::array<uint8_t, FSTHeader::LENGTH> &data) {
auto *dataAsUint = (uint32_t *) data.data();
@ -24,22 +24,20 @@ std::optional<std::unique_ptr<FSTHeader>> FSTHeader::make_unique(const std::arra
DEBUG_FUNCTION_LINE("FST Header magic was wrong");
return {};
}
auto FSTVersion = data[3];
auto blockSize = SectionBlockSize(dataAsUint[1]);
auto FSTVersion = data[3];
auto blockSize = SectionBlockSize(dataAsUint[1]);
auto numberOfSections = dataAsUint[2];
auto hashDisabled = data[12];
auto hashDisabled = data[12];
return std::unique_ptr<FSTHeader>(new FSTHeader(
FSTVersion,
blockSize,
numberOfSections,
hashDisabled
));
hashDisabled));
}
FSTHeader::FSTHeader(uint8_t pFSTVersion, SectionBlockSize pBlockSize, uint32_t pNumberOfSections, uint8_t pHashDisabled) : FSTVersion(pFSTVersion),
blockSize(pBlockSize),
numberOfSections(pNumberOfSections),
hashDisabled(pHashDisabled) {
}

5
source/WUD/entities/FST/header/FSTHeader.h
View File

@ -16,9 +16,9 @@
****************************************************************************/
#pragma once
#include <optional>
#include <memory>
#include <cstdint>
#include <memory>
#include <optional>
#include <utils/blocksize/SectionBlockSize.h>
class FSTHeader {
@ -35,5 +35,4 @@ public:
private:
FSTHeader(uint8_t pFSTVersion, SectionBlockSize pBlockSize, uint32_t pNumberOfSections, uint8_t pHashDisabled);
};

47
source/WUD/entities/FST/nodeentry/DirectoryEntry.cpp
View File

@ -14,15 +14,15 @@
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
****************************************************************************/
#include <coreinit/debug.h>
#include "DirectoryEntry.h"
#include <coreinit/debug.h>
std::optional<std::shared_ptr<DirectoryEntry>>
DirectoryEntry::parseData(const std::array<uint8_t, NodeEntry::LENGTH> &data, const NodeEntryParam &param, const std::shared_ptr<SectionEntries> &sectionEntries,
const std::shared_ptr<StringTable> &stringTable) {
auto parentEntryNumber = ((uint32_t *) &data[4])[0];
auto lastEntryNumber = ((uint32_t *) &data[8])[0];
auto stringNameOpt = stringTable->getStringEntry(param.uint24);
auto lastEntryNumber = ((uint32_t *) &data[8])[0];
auto stringNameOpt = stringTable->getStringEntry(param.uint24);
if (!stringNameOpt.has_value()) {
DEBUG_FUNCTION_LINE("Failed to get string name");
return {};
@ -40,7 +40,7 @@ DirectoryEntry::parseData(const std::array<uint8_t, NodeEntry::LENGTH> &data, co
std::vector<std::shared_ptr<DirectoryEntry>> DirectoryEntry::getDirChildren() const {
std::vector<std::shared_ptr<DirectoryEntry>> res;
for (auto &cur: children) {
for (auto &cur : children) {
if (cur->isDirectory()) {
res.push_back(std::dynamic_pointer_cast<DirectoryEntry>(cur));
}
@ -50,7 +50,7 @@ std::vector<std::shared_ptr<DirectoryEntry>> DirectoryEntry::getDirChildren() co
std::vector<std::shared_ptr<FileEntry>> DirectoryEntry::getFileChildren() const {
std::vector<std::shared_ptr<FileEntry>> res;
for (auto &cur: children) {
for (auto &cur : children) {
if (cur->isFile()) {
res.push_back(std::dynamic_pointer_cast<FileEntry>(cur));
}
@ -64,7 +64,7 @@ std::vector<std::shared_ptr<NodeEntry>> DirectoryEntry::getChildren() const {
void DirectoryEntry::printPathRecursive() {
DEBUG_FUNCTION_LINE("%s", getFullPath().c_str());
for (auto &child: children) {
for (auto &child : children) {
child->printPathRecursive();
}
}
@ -77,25 +77,22 @@ DirectoryEntry::DirectoryEntry(const NodeEntryParam &param,
const std::shared_ptr<StringEntry> &pStringEntry,
const std::shared_ptr<SectionEntry> &pSectionEntry,
uint32_t pParentEntryNumber,
uint32_t pLastEntryNumber) :
NodeEntry(param.permission,
pStringEntry,
pSectionEntry,
param.parent,
param.type,
param.entryNumber),
parentEntryNumber(pParentEntryNumber),
lastEntryNumber(pLastEntryNumber) {
uint32_t pLastEntryNumber) : NodeEntry(param.permission,
pStringEntry,
pSectionEntry,
param.parent,
param.type,
param.entryNumber),
parentEntryNumber(pParentEntryNumber),
lastEntryNumber(pLastEntryNumber) {
}
DirectoryEntry::DirectoryEntry(const std::shared_ptr<DirectoryEntry> &input) :
NodeEntry(input->permission,
input->nameString,
input->sectionEntry,
input->parent,
input->entryType,
input->entryNumber),
parentEntryNumber(input->parentEntryNumber),
lastEntryNumber(input->lastEntryNumber) {
DirectoryEntry::DirectoryEntry(const std::shared_ptr<DirectoryEntry> &input) : NodeEntry(input->permission,
input->nameString,
input->sectionEntry,
input->parent,
input->entryType,
input->entryNumber),
parentEntryNumber(input->parentEntryNumber),
lastEntryNumber(input->lastEntryNumber) {
}

6
source/WUD/entities/FST/nodeentry/DirectoryEntry.h
View File

@ -16,11 +16,11 @@
****************************************************************************/
#pragma once
#include "FileEntry.h"
#include "NodeEntry.h"
#include "NodeEntryParam.h"
#include <WUD/entities/FST/sectionentry/SectionEntries.h>
#include <WUD/entities/FST/stringtable/StringTable.h>
#include "NodeEntryParam.h"
#include "NodeEntry.h"
#include "FileEntry.h"
class DirectoryEntry : public NodeEntry {
public:

20
source/WUD/entities/FST/nodeentry/FileEntry.cpp
View File

@ -27,7 +27,7 @@ FileEntry::parseData(const std::array<uint8_t, NodeEntry::LENGTH> &data,
const std::shared_ptr<SectionEntries> &sectionEntries,
const std::shared_ptr<StringTable> &stringTable,
const SectionBlockSize &blockSize) {
auto size = ((uint32_t *) &data[8])[0];
auto size = ((uint32_t *) &data[8])[0];
auto offset = SectionAddress(blockSize, ((uint32_t *) &data[4])[0]);
auto stringNameOpt = stringTable->getStringEntry(param.uint24);
@ -61,14 +61,12 @@ FileEntry::FileEntry(
const NodeEntryParam &param,
const std::shared_ptr<StringEntry> &pStringEntry,
const std::shared_ptr<SectionEntry> &pSectionEntry,
uint32_t pSize, SectionAddress pAddress) :
NodeEntry(param.permission,
pStringEntry,
pSectionEntry,
param.parent,
param.type,
param.entryNumber),
address(std::move(pAddress)),
size(pSize) {
uint32_t pSize, SectionAddress pAddress) : NodeEntry(param.permission,
pStringEntry,
pSectionEntry,
param.parent,
param.type,
param.entryNumber),
address(std::move(pAddress)),
size(pSize) {
}

1
source/WUD/entities/FST/nodeentry/FileEntry.h
View File

@ -23,7 +23,6 @@
class FileEntry : public NodeEntry {
public:
static std::optional<std::shared_ptr<NodeEntry>>
parseData(const std::array<uint8_t, NodeEntry::LENGTH> &data,
const NodeEntryParam &param,

2
source/WUD/entities/FST/nodeentry/NodeEntries.cpp
View File

@ -14,8 +14,8 @@
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
****************************************************************************/
#include <coreinit/debug.h>
#include "NodeEntries.h"
#include <coreinit/debug.h>
std::optional<std::shared_ptr<NodeEntry>> NodeEntries::DeserializeImpl(const std::vector<uint8_t> &pData,
uint32_t pOffset,

8
source/WUD/entities/FST/nodeentry/NodeEntries.h
View File

@ -16,15 +16,15 @@
****************************************************************************/
#pragma once
#include <WUD/entities/FST/sectionentry/SectionEntries.h>
#include <WUD/entities/FST/stringtable/StringTable.h>
#include <utils/blocksize/SectionBlockSize.h>
#include <WUD/entities/FST/sectionentry/SectionEntries.h>
#include <utility>
#include "DirectoryEntry.h"
#include "RootEntry.h"
#include "NodeEntry.h"
#include "NodeEntries.h"
#include "NodeEntry.h"
#include "RootEntry.h"
#include <utility>
class NodeEntries {

35
source/WUD/entities/FST/nodeentry/NodeEntry.cpp
View File

@ -14,15 +14,15 @@
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
****************************************************************************/
#include <utils/blocksize/SectionBlockSize.h>
#include <WUD/entities/FST/stringtable/StringTable.h>
#include <WUD/entities/FST/sectionentry/SectionEntries.h>
#include <WUD/entities/FST/stringtable/StringTable.h>
#include <utils/blocksize/SectionBlockSize.h>
#include "DirectoryEntry.h"
#include "NodeEntry.h"
#include "RootEntry.h"
#include <algorithm>
#include <utility>
#include "NodeEntry.h"
#include "DirectoryEntry.h"
#include "RootEntry.h"
std::optional<std::shared_ptr<NodeEntry>>
NodeEntry::AutoDeserialize(const std::vector<uint8_t> &data,
@ -39,12 +39,12 @@ NodeEntry::AutoDeserialize(const std::vector<uint8_t> &data,
std::copy_n(data.begin() + (int) offset, NodeEntry::LENGTH, curEntryData.begin());
NodeEntryParam param{};
param.permission = ((uint16_t *) &curEntryData[12])[0];
param.permission = ((uint16_t *) &curEntryData[12])[0];
param.sectionNumber = ((uint16_t *) &curEntryData[14])[0];
param.entryNumber = eEntryNumber;
param.parent = pParent;
param.type = curEntryData[0];
param.uint24 = ((uint32_t *) &curEntryData[0])[0] & 0x00FFFFFF;
param.entryNumber = eEntryNumber;
param.parent = pParent;
param.type = curEntryData[0];
param.uint24 = ((uint32_t *) &curEntryData[0])[0] & 0x00FFFFFF;
if ((param.type & ENTRY_TYPE_Directory) == ENTRY_TYPE_Directory && param.uint24 == 0) { // Root
auto res = RootEntry::parseData(curEntryData, param, sectionEntries, stringTable);
@ -123,17 +123,14 @@ NodeEntry::NodeEntry(const uint16_t pPermission,
std::shared_ptr<StringEntry> pNameString,
std::shared_ptr<SectionEntry> pSectionEntry,
std::optional<std::shared_ptr<DirectoryEntry>> pParent,
const uint8_t pType, const uint32_t pEntryNumber) :
permission(pPermission),
nameString(std::move(pNameString)),
sectionEntry(std::move(pSectionEntry)),
parent(std::move(pParent)),
entryType(pType),
entryNumber(pEntryNumber) {
const uint8_t pType, const uint32_t pEntryNumber) : permission(pPermission),
nameString(std::move(pNameString)),
sectionEntry(std::move(pSectionEntry)),
parent(std::move(pParent)),
entryType(pType),
entryNumber(pEntryNumber) {
}
void NodeEntry::printPathRecursive() {
DEBUG_FUNCTION_LINE("%s", getFullPath().c_str());
}

14
source/WUD/entities/FST/nodeentry/NodeEntry.h
View File

@ -16,17 +16,17 @@
****************************************************************************/
#pragma once
#include "NodeEntryParam.h"
#include <WUD/entities/FST/sectionentry/SectionEntries.h>
#include <WUD/entities/FST/sectionentry/SectionEntry.h>
#include <WUD/entities/FST/stringtable/StringEntry.h>
#include <cstdint>
#include <utils/blocksize/SectionBlockSize.h>
#include <WUD/entities/FST/stringtable/StringEntry.h>
#include <WUD/entities/FST/sectionentry/SectionEntry.h>
#include <WUD/entities/FST/sectionentry/SectionEntries.h>
#include <utils/logger.h>
#include "NodeEntryParam.h"
#define ENTRY_TYPE_File 0
#define ENTRY_TYPE_Directory 1
#define ENTRY_TYPE_Link 0x80
#define ENTRY_TYPE_File 0
#define ENTRY_TYPE_Directory 1
#define ENTRY_TYPE_Link 0x80
class DirectoryEntry;

2
source/WUD/entities/FST/nodeentry/NodeEntryParam.h
View File

@ -17,6 +17,8 @@
#pragma once
#include <cstdint>
#include <memory>
#include <optional>
class DirectoryEntry;

12
source/WUD/entities/FST/nodeentry/RootEntry.cpp
View File

@ -14,11 +14,10 @@
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
****************************************************************************/
#include <coreinit/debug.h>
#include "RootEntry.h"
#include <coreinit/debug.h>
RootEntry::RootEntry(const std::shared_ptr<DirectoryEntry> &input) : DirectoryEntry(input) {
}
uint32_t RootEntry::parseLastEntryNumber(const std::array<uint8_t, NodeEntry::LENGTH> &data) {
@ -26,11 +25,10 @@ uint32_t RootEntry::parseLastEntryNumber(const std::array<uint8_t, NodeEntry::LE
}
std::optional<std::shared_ptr<NodeEntry>>
RootEntry::parseData
(const std::array<uint8_t, NodeEntry::LENGTH> &data,
const NodeEntryParam &param,
const std::shared_ptr<SectionEntries> &sectionEntries,
const std::shared_ptr<StringTable> &stringTable) {
RootEntry::parseData(const std::array<uint8_t, NodeEntry::LENGTH> &data,
const NodeEntryParam &param,
const std::shared_ptr<SectionEntries> &sectionEntries,
const std::shared_ptr<StringTable> &stringTable) {
auto dir = DirectoryEntry::parseData(data, param, sectionEntries, stringTable);
if (dir.has_value()) {
if ((dir.value()->entryType & ENTRY_TYPE_Directory) != ENTRY_TYPE_Directory || dir.value()->entryNumber != 0) {

8
source/WUD/entities/FST/nodeentry/RootEntry.h
View File

@ -16,11 +16,11 @@
****************************************************************************/
#pragma once
#include <cstdint>
#include <WUD/entities/FST/stringtable/StringTable.h>
#include <utils/blocksize/SectionBlockSize.h>
#include <WUD/entities/FST/sectionentry/SectionEntries.h>
#include "DirectoryEntry.h"
#include <WUD/entities/FST/sectionentry/SectionEntries.h>
#include <WUD/entities/FST/stringtable/StringTable.h>
#include <cstdint>
#include <utils/blocksize/SectionBlockSize.h>
class RootEntry : public DirectoryEntry {

8
source/WUD/entities/FST/sectionentry/SectionEntries.cpp
View File

@ -17,7 +17,7 @@
#include "SectionEntries.h"
std::optional<std::shared_ptr<SectionEntry>> SectionEntries::getSection(uint16_t sectionNumber) const {
for (auto const &e: list) {
for (auto const &e : list) {
if (e->sectionNumber == sectionNumber) {
return e;
}
@ -42,15 +42,15 @@ std::optional<std::shared_ptr<SectionEntries>> SectionEntries::make_shared(const
}
std::array<uint8_t, SectionEntry::LENGTH> sectionEntryData{};
memcpy(sectionEntryData.data(), data.data() + (i * SectionEntry::LENGTH), SectionEntry::LENGTH);
list.push_back(std::make_shared<SectionEntry>(sectionEntryData, i, pBlockSize));;
list.push_back(std::make_shared<SectionEntry>(sectionEntryData, i, pBlockSize));
;
}
return std::shared_ptr<SectionEntries>(new SectionEntries(list));
}
std::vector<std::shared_ptr<SectionEntry>> SectionEntries::getSections() const &{
std::vector<std::shared_ptr<SectionEntry>> SectionEntries::getSections() const & {
return list;
}
SectionEntries::SectionEntries(std::vector<std::shared_ptr<SectionEntry>> pList) : list(std::move(pList)) {
}

8
source/WUD/entities/FST/sectionentry/SectionEntries.h
View File

@ -16,14 +16,14 @@
****************************************************************************/
#pragma once
#include <optional>
#include <memory>
#include "SectionEntry.h"
#include <cstdint>
#include <memory>
#include <optional>
#include <utility>
#include <vector>
#include <utils/blocksize/VolumeBlockSize.h>
#include <utils/logger.h>
#include "SectionEntry.h"
#include <vector>
class SectionEntries {

10
source/WUD/entities/FST/sectionentry/SectionEntry.cpp
View File

@ -18,15 +18,15 @@
SectionEntry::SectionEntry(const std::array<uint8_t, SectionEntry::LENGTH> &data, uint32_t pSectionNumber, const VolumeBlockSize &pBlockSize) {
auto *dataAsUint = (uint32_t *) data.data();
address = AddressInVolumeBlocks(pBlockSize, dataAsUint[0]);
size = SizeInVolumeBlocks(pBlockSize, dataAsUint[1]);
address = AddressInVolumeBlocks(pBlockSize, dataAsUint[0]);
size = SizeInVolumeBlocks(pBlockSize, dataAsUint[1]);
ownerID = ((uint64_t *) (&data[8]))[0];
groupID = ((uint64_t *) (&data[16]))[0];
ownerID = ((uint64_t *) (&data[8]))[0];
groupID = ((uint64_t *) (&data[16]))[0];
hashMode = data[20];
char buff[32];
snprintf(buff, sizeof(buff), "Section: %d", pSectionNumber);
name = std::string(buff);
name = std::string(buff);
sectionNumber = pSectionNumber;
}

2
source/WUD/entities/FST/sectionentry/SectionEntry.h
View File

@ -16,9 +16,9 @@
****************************************************************************/
#pragma once
#include <array>
#include <cstdint>
#include <string>
#include <array>
#include <utils/blocksize/AddressInVolumeBlocks.h>
#include <utils/blocksize/SizeInVolumeBlocks.h>

2
source/WUD/entities/FST/stringtable/StringEntry.cpp
View File

@ -16,9 +16,9 @@
****************************************************************************/
#include "StringEntry.h"
#include "StringTable.h"
#include <utility>
#include <utils/logger.h>
#include "StringTable.h"
std::optional<std::string> StringEntry::toString() const {
return stringTable->getByAddress(offset);

2
source/WUD/entities/FST/stringtable/StringEntry.h
View File

@ -17,9 +17,9 @@
#pragma once
#include <cstdint>
#include <string>
#include <memory>
#include <optional>
#include <string>
class StringTable;

16
source/WUD/entities/FST/stringtable/StringTable.cpp
View File

@ -14,10 +14,10 @@
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
****************************************************************************/
#include <cstring>
#include <coreinit/debug.h>
#include <utils/logger.h>
#include "StringTable.h"
#include <coreinit/debug.h>
#include <cstring>
#include <utils/logger.h>
std::optional<std::shared_ptr<StringTable>> StringTable::make_shared(const std::vector<uint8_t> &data, uint32_t offset, uint32_t stringCount) {
@ -25,7 +25,7 @@ std::optional<std::shared_ptr<StringTable>> StringTable::make_shared(const std::
DEBUG_FUNCTION_LINE("Invalid offset for reading StringTable");
return {};
}
auto stringTable = std::shared_ptr<StringTable>(new StringTable());
auto stringTable = std::shared_ptr<StringTable>(new StringTable());
uint32_t curOffset = 0;
uint32_t i;
for (i = 0; curOffset < data.size() && i < stringCount; ++curOffset) {
@ -41,9 +41,9 @@ std::optional<std::shared_ptr<StringTable>> StringTable::make_shared(const std::
uint32_t curLength = 0;
for (i = 0; i < stringCount; ++i) {
curOffset = offset + curLength;
curOffset = offset + curLength;
stringTable->stringMap[curLength] = std::make_shared<StringEntry>(stringTable, curLength);
stringTable->strings[curLength] = (char *) &data[curOffset];
stringTable->strings[curLength] = (char *) &data[curOffset];
curLength += strlen((char *) &data[curOffset]) + 1;
}
@ -67,14 +67,14 @@ std::optional<std::shared_ptr<StringEntry>> StringTable::getStringEntry(uint32_t
uint32_t StringTable::getSize() {
uint32_t capacity = 1; // root entry
for (auto &cur: strings) {
for (auto &cur : strings) {
capacity += cur.second.length() + 1;
}
return capacity;
}
std::optional<std::shared_ptr<StringEntry>> StringTable::getEntry(std::string &str) {
for (auto &cur: strings) {
for (auto &cur : strings) {
if (cur.second == str) {
return stringMap[cur.first];
}

10
source/WUD/entities/FST/stringtable/StringTable.h
View File

@ -16,12 +16,12 @@
****************************************************************************/
#pragma once
#include <optional>
#include <memory>
#include <vector>
#include <string>
#include <map>
#include "StringEntry.h"
#include <map>
#include <memory>
#include <optional>
#include <string>
#include <vector>
class StringTable {

19
source/WUD/entities/TMD/Content.cpp
View File

@ -14,21 +14,20 @@
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
****************************************************************************/
#include <cstring>
#include "Content.h"
#include <cstring>
Content::Content(uint32_t pId, uint16_t pIndex, uint16_t pType, uint64_t pEncryptedFileSize, const std::array<uint8_t, 0x14> &pHash) :
ID(pId),
index(pIndex),
type(pType),
encryptedFileSize(pEncryptedFileSize),
hash(pHash) {
Content::Content(uint32_t pId, uint16_t pIndex, uint16_t pType, uint64_t pEncryptedFileSize, const std::array<uint8_t, 0x14> &pHash) : ID(pId),
index(pIndex),
type(pType),
encryptedFileSize(pEncryptedFileSize),
hash(pHash) {
}
std::optional<std::shared_ptr<Content>> Content::make_shared(const std::array<uint8_t, 0x30> &data) {
auto id = ((uint32_t *) &data[0x00])[0];
auto index = ((uint16_t *) &data[0x04])[0];
auto type = ((uint16_t *) &data[0x06])[0];
auto id = ((uint32_t *) &data[0x00])[0];
auto index = ((uint16_t *) &data[0x04])[0];
auto type = ((uint16_t *) &data[0x06])[0];
auto encryptedFileSize = ((uint64_t *) &data[0x08])[0];
std::array<uint8_t, 0x14> hash{};
memcpy(hash.data(), &data[0x10], 0x14);

2
source/WUD/entities/TMD/Content.h
View File

@ -17,8 +17,8 @@
#pragma once
#include <cstdint>
#include <optional>
#include <memory>
#include <optional>
class Content {
public:

3
source/WUD/entities/TMD/TitleMetaData.cpp
View File

@ -22,11 +22,10 @@
TitleMetaData::TitleMetaData(std::vector<std::shared_ptr<Content>> pContentList) : contentList(std::move(pContentList)) {
// Get Contents
}
std::optional<std::shared_ptr<Content>> TitleMetaData::getContentByIndex(uint16_t i) {
for (auto &content: contentList) {
for (auto &content : contentList) {
if (content->index == i) {
return content;
}

8
source/WUD/entities/TMD/TitleMetaData.h
View File

@ -16,11 +16,11 @@
****************************************************************************/
#pragma once
#include <optional>
#include <memory>
#include <cstdint>
#include <vector>
#include "Content.h"
#include <cstdint>
#include <memory>
#include <optional>
#include <vector>
class TitleMetaData {
public:

11
source/WUD/header/WiiUDiscHeader.cpp
View File

@ -21,10 +21,9 @@ uint32_t WiiUDiscHeader::LENGTH = 131072L;
WiiUDiscHeader::WiiUDiscHeader(std::unique_ptr<WiiUManufactorDiscId> pManufactorDiscId,
std::unique_ptr<WiiUDiscId> pDiscId,
std::unique_ptr<WiiUContentsInformation> pWiiUContentsInformation) :
manufactorDiscId(std::move(pManufactorDiscId)),
discId(std::move(pDiscId)),
wiiUContentsInformation(std::move(pWiiUContentsInformation)) {
std::unique_ptr<WiiUContentsInformation> pWiiUContentsInformation) : manufactorDiscId(std::move(pManufactorDiscId)),
discId(std::move(pDiscId)),
wiiUContentsInformation(std::move(pWiiUContentsInformation)) {
}
std::optional<std::unique_ptr<WiiUDiscHeader>> WiiUDiscHeader::make_unique(const std::shared_ptr<DiscReader> &discReader) {
@ -32,8 +31,8 @@ std::optional<std::unique_ptr<WiiUDiscHeader>> WiiUDiscHeader::make_unique(const
DEBUG_FUNCTION_LINE("DiscReader is not ready");
return {};
}
uint32_t offset = 0;
uint32_t curOffset = offset;
uint32_t offset = 0;
uint32_t curOffset = offset;
auto manufactorDiscIDOpt = WiiUManufactorDiscId::make_unique(discReader);
if (!manufactorDiscIDOpt.has_value()) {
DEBUG_FUNCTION_LINE("Failed to read ManufactorDiscId");

16
source/WUD/header/WiiUDiscHeader.h
View File

@ -16,17 +16,16 @@
****************************************************************************/
#pragma once
#include <cstdint>
#include <WUD/DiscReader.h>
#include <WUD/content/WiiUContentsInformation.h>
#include <WUD/DiscReaderDiscDrive.h>
#include <memory>
#include "WiiUManufactorDiscId.h"
#include "WiiUDiscId.h"
#include "WiiUManufactorDiscId.h"
#include <WUD/DiscReader.h>
#include <WUD/DiscReaderDiscDrive.h>
#include <WUD/content/WiiUContentsInformation.h>
#include <cstdint>
#include <memory>
class WiiUDiscHeader {
public:
static std::optional<std::unique_ptr<WiiUDiscHeader>> make_unique(const std::shared_ptr<DiscReader> &discReader);
std::unique_ptr<WiiUManufactorDiscId> manufactorDiscId;
@ -39,6 +38,5 @@ private:
explicit WiiUDiscHeader(
std::unique_ptr<WiiUManufactorDiscId> pManufactorDiscId,
std::unique_ptr<WiiUDiscId> pDiscId,
std::unique_ptr<WiiUContentsInformation> pWiiUContentsInformation
);
std::unique_ptr<WiiUContentsInformation> pWiiUContentsInformation);
};

10
source/WUD/header/WiiUDiscId.cpp
View File

@ -15,8 +15,8 @@
* along with this program. If not, see <http://www.gnu.org/licenses/>.
****************************************************************************/
#include "WiiUDiscId.h"
#include <memory>
#include <coreinit/debug.h>
#include <memory>
#include <utils/logger.h>
std::optional<std::unique_ptr<WiiUDiscId>> WiiUDiscId::make_unique(const std::shared_ptr<DiscReader> &discReader, uint32_t offset) {
@ -46,9 +46,7 @@ std::optional<std::unique_ptr<WiiUDiscId>> WiiUDiscId::make_unique(const std::sh
return std::unique_ptr<WiiUDiscId>(new WiiUDiscId(minorVersion, majorVersion, footprint));
}
WiiUDiscId::WiiUDiscId(uint8_t pMinorVersion, uint8_t pMajorVersion, const std::string &pFootprint) :
minorVersion(pMinorVersion),
majorVersion(pMajorVersion),
footprint(pFootprint) {
WiiUDiscId::WiiUDiscId(uint8_t pMinorVersion, uint8_t pMajorVersion, const std::string &pFootprint) : minorVersion(pMinorVersion),
majorVersion(pMajorVersion),
footprint(pFootprint) {
}

6
source/WUD/header/WiiUDiscId.h
View File

@ -16,17 +16,17 @@
****************************************************************************/
#pragma once
#include <memory>
#include <string>
#include <WUD/DiscReader.h>
#include <memory>
#include <optional>
#include <string>
#include <utility>
class WiiUDiscId {
public:
static constexpr uint32_t LENGTH = 32768;
static constexpr uint32_t MAGIC = 0xCC549EB9;
static constexpr uint32_t MAGIC = 0xCC549EB9;
uint8_t minorVersion;
uint8_t majorVersion;
std::string footprint;

4
source/WUD/header/WiiUManufactorDiscId.h
View File

@ -16,9 +16,9 @@
****************************************************************************/
#pragma once
#include <memory>
#include <cstdint>
#include <WUD/DiscReader.h>
#include <cstdint>
#include <memory>
#include <optional>
class WiiUManufactorDiscId {

44
source/WUDDumperState.cpp
View File

@ -14,20 +14,20 @@
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
****************************************************************************/
#include <malloc.h>
#include <utils/WiiUScreen.h>
#include <common/common.h>
#include <iosuhax.h>
#include <fs/FSUtils.h>
#include <utils/StringTools.h>
#include <utils/utils.h>
#include <WUD/content/WiiUDiscContentsHeader.h>
#include "WUDDumperState.h"
#include <WUD/content/WiiUDiscContentsHeader.h>
#include <common/common.h>
#include <fs/FSUtils.h>
#include <iosuhax.h>
#include <malloc.h>
#include <utils/StringTools.h>
#include <utils/WiiUScreen.h>
#include <utils/utils.h>
WUDDumperState::WUDDumperState(WUDDumperState::eDumpTargetFormat pTargetFormat, eDumpTarget pTargetDevice)
: targetFormat(pTargetFormat), targetDevice(pTargetDevice) {
: targetFormat(pTargetFormat), targetDevice(pTargetDevice) {
this->sectorBufSize = READ_SECTOR_SIZE * READ_NUM_SECTORS;
this->state = STATE_OPEN_ODD1;
this->state = STATE_OPEN_ODD1;
}
WUDDumperState::~WUDDumperState() {
@ -139,11 +139,11 @@ ApplicationState::eSubState WUDDumperState::update(Input *input) {
this->startTime = OSGetTime();
this->state = STATE_DUMP_DISC;
this->state = STATE_DUMP_DISC;
this->totalSectorCount = (WUD_FILE_SIZE / SECTOR_SIZE);
this->currentSector = 0;
this->writtenSectors = 0;
this->retryCount = 10;
this->currentSector = 0;
this->writtenSectors = 0;
this->retryCount = 10;
} else if (this->state == STATE_DUMP_DISC) {
size_t numSectors = this->currentSector + READ_NUM_SECTORS > this->totalSectorCount ? this->totalSectorCount - this->currentSector : READ_NUM_SECTORS;
if ((this->readResult = IOSUHAX_FSA_RawRead(gFSAfd, sectorBuf, READ_SECTOR_SIZE, numSectors, this->currentSector, this->oddFd)) >= 0) {
@ -207,7 +207,7 @@ ApplicationState::eSubState WUDDumperState::update(Input *input) {
this->writtenSectors += curWrittenSectors;
this->readResult = 0;
} else if (input->data.buttons_d & Input::BUTTON_B) {
this->state = STATE_OPEN_ODD1;
this->state = STATE_OPEN_ODD1;
this->readResult = 0;
} else if (input->data.buttons_d & Input::BUTTON_Y) {
this->autoSkipOnError = true;
@ -264,13 +264,13 @@ void WUDDumperState::render() {
WiiUScreen::drawLine("Press A to skip this sector (will be replaced by 0's)");
WiiUScreen::drawLine("Press B to try again");
} else {
OSTime curTime = OSGetTime();
float remaining = (WUD_FILE_SIZE - (READ_SECTOR_SIZE * this->currentSector)) / 1024.0f / 1024.0f;
float curSpeed = READ_SECTOR_SIZE * ((this->currentSector / 1000.0f) / OSTicksToMilliseconds(curTime - startTime));
OSTime curTime = OSGetTime();
float remaining = (WUD_FILE_SIZE - (READ_SECTOR_SIZE * this->currentSector)) / 1024.0f / 1024.0f;
float curSpeed = READ_SECTOR_SIZE * ((this->currentSector / 1000.0f) / OSTicksToMilliseconds(curTime - startTime));
int32_t remainingSec = remaining / curSpeed;
int32_t minutes = (remainingSec / 60) % 60;
int32_t seconds = remainingSec % 60;
int32_t hours = remainingSec / 3600;
int32_t minutes = (remainingSec / 60) % 60;
int32_t seconds = remainingSec % 60;
int32_t hours = remainingSec / 3600;
WiiUScreen::drawLinef("Speed: %.2f MiB/s ETA: %02dh %02dm %02ds", curSpeed, remaining, hours, minutes, seconds);
}
@ -288,7 +288,7 @@ void WUDDumperState::render() {
}
void WUDDumperState::setError(WUDDumperState::eErrorState err) {
this->state = STATE_ERROR;
this->state = STATE_ERROR;
this->errorState = err;
//OSEnableHomeButtonMenu(true);
}

20
source/WUDDumperState.h
View File

@ -16,23 +16,22 @@
****************************************************************************/
#pragma once
#include "ApplicationState.h"
#include "fs/WUXFileWriter.h"
#include "fs/WriteOnlyFileWithCache.h"
#include <common/common.h>
#include <input/Input.h>
#include <map>
#include <memory>
#include <string>
#include <vector>
#include <memory>
#include <input/Input.h>
#include <common/common.h>
#include "ApplicationState.h"
#include "fs/WriteOnlyFileWithCache.h"
#include "fs/WUXFileWriter.h"
#define READ_NUM_SECTORS 128
#define READ_NUM_SECTORS 128
#define WRITE_BUFFER_NUM_SECTORS 128
#define WUD_FILE_SIZE 0x5D3A00000L
#define WUD_FILE_SIZE 0x5D3A00000L
class WUDDumperState : public ApplicationState {
public:
enum eDumpTargetFormat {
DUMP_AS_WUX,
DUMP_AS_WUD,
@ -86,7 +85,7 @@ public:
void *sectorBuf = nullptr;
int readResult = 0;
int oddFd = -1;
int oddFd = -1;
int retryCount = 10;
OSTime startTime{};
@ -109,5 +108,4 @@ public:
int32_t writtenSectors{};
void *emptySector = nullptr;
};

2
source/common/common.h
View File

@ -5,7 +5,7 @@
extern int32_t gFSAfd;
#define SECTOR_SIZE 0x8000
#define SECTOR_SIZE 0x8000
#define READ_SECTOR_SIZE SECTOR_SIZE
extern ntfs_md *ntfs_mounts;

18
source/fs/CFile.cpp
View File

@ -1,14 +1,14 @@
#include "CFile.hpp"
#include <cstdarg>
#include <cstdio>
#include <strings.h>
#include <utils/logger.h>
#include "CFile.hpp"
CFile::CFile() {
iFd = -1;
iFd = -1;
mem_file = nullptr;
filesize = 0;
pos = 0;
pos = 0;
}
CFile::CFile(const std::string &filepath, eOpenTypes mode) {
@ -34,7 +34,7 @@ int32_t CFile::open(const std::string &filepath, eOpenTypes mode) {
switch (mode) {
default:
case ReadOnly: // file must exist
case ReadOnly: // file must exist
openMode = O_RDONLY;
break;
case WriteOnly: // file will be created / zerod
@ -76,10 +76,10 @@ void CFile::close() {
if (iFd >= 0)
::close(iFd);
iFd = -1;
iFd = -1;
mem_file = nullptr;
filesize = 0;
pos = 0;
pos = 0;
}
int32_t CFile::read(uint8_t *ptr, size_t size) {
@ -129,7 +129,7 @@ int32_t CFile::write(const uint8_t *ptr, size_t size) {
}
int32_t CFile::seek(int64_t offset, int32_t origin) {
int32_t ret = 0;
int32_t ret = 0;
int64_t newPos = pos;
if (origin == SEEK_SET) {
@ -160,7 +160,7 @@ int32_t CFile::seek(int64_t offset, int32_t origin) {
int32_t CFile::fwrite(const char *format, ...) {
char tmp[512];
tmp[0] = 0;
tmp[0] = 0;
int32_t result = -1;
va_list va;
@ -173,5 +173,3 @@ int32_t CFile::fwrite(const char *format, ...) {
return result;
}

4
source/fs/CFile.hpp
View File

@ -1,12 +1,12 @@
#pragma once
#include <cstdio>
#include <string>
#include <cstring>
#include <fcntl.h>
#include <string>
#include <unistd.h>
#include <wut_types.h>
#include <utils/logger.h>
#include <wut_types.h>
class CFile {
public:

19
source/fs/FSUtils.cpp
View File

@ -1,11 +1,11 @@
#include <malloc.h>
#include <string.h>
#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
#include "FSUtils.h"
#include "CFile.hpp"
#include "utils/logger.h"
#include <fcntl.h>
#include <malloc.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
int32_t FSUtils::LoadFileToMem(const char *filepath, uint8_t **inbuffer, uint32_t *size) {
//! always initialze input
@ -27,8 +27,8 @@ int32_t FSUtils::LoadFileToMem(const char *filepath, uint8_t **inbuffer, uint32_
}
uint32_t blocksize = 0x4000;
uint32_t done = 0;
int32_t readBytes = 0;
uint32_t done = 0;
int32_t readBytes = 0;
while (done < filesize) {
if (done + blocksize > filesize) {
@ -136,7 +136,7 @@ bool FSUtils::copyFile(const std::string &in, const std::string &out) {
size_t size;
int source = open(in.c_str(), O_RDONLY, 0);
int dest = open(out.c_str(), 0x602, 0644);
int dest = open(out.c_str(), 0x602, 0644);
if (source < 0) {
return false;
}
@ -146,7 +146,7 @@ bool FSUtils::copyFile(const std::string &in, const std::string &out) {
}
auto bufferSize = 1024 * 1024;
char *buf = (char *) malloc(bufferSize);
char *buf = (char *) malloc(bufferSize);
if (buf == NULL) {
return false;
}
@ -171,4 +171,3 @@ int32_t FSUtils::saveBufferToFile(const char *path, void *buffer, uint32_t size)
file.close();
return written;
}

2
source/fs/FSUtils.h
View File

@ -1,7 +1,7 @@
#pragma once
#include <wut_types.h>
#include <string>
#include <wut_types.h>
class FSUtils {
public:

8
source/fs/WUDFileWriter.cpp
View File

@ -14,12 +14,11 @@
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
****************************************************************************/
#include <utils/logger.h>
#include "WUDFileWriter.h"
#include <utils/logger.h>
WUDFileWriter::WUDFileWriter(const char *path, int32_t cacheSize, int32_t pSectorSize, bool split) :
WriteOnlyFileWithCache(path, cacheSize, split),
sectorSize(pSectorSize) {
WUDFileWriter::WUDFileWriter(const char *path, int32_t cacheSize, int32_t pSectorSize, bool split) : WriteOnlyFileWithCache(path, cacheSize, split),
sectorSize(pSectorSize) {
}
int32_t WUDFileWriter::writeSector(const uint8_t *buffer, uint32_t numberOfSectors) {
@ -31,5 +30,4 @@ int32_t WUDFileWriter::writeSector(const uint8_t *buffer, uint32_t numberOfSecto
}
void WUDFileWriter::finalize() {
}

1
source/fs/WUDFileWriter.h
View File

@ -25,6 +25,7 @@ public:
virtual int32_t writeSector(const uint8_t *buffer, uint32_t numberOfSectors);
virtual void finalize();
protected:
int32_t sectorSize;
};

22
source/fs/WUXFileWriter.cpp
View File

@ -14,18 +14,17 @@
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
****************************************************************************/
#include <utils/logger.h>
#include "WUXFileWriter.h"
#include "WUDDumperState.h"
#include <utils/logger.h>
WUXFileWriter::WUXFileWriter(const char *path, int32_t cacheSize, int32_t sectorSize, bool split) :
WUDFileWriter(path, cacheSize, sectorSize, split) {
wuxHeader_t wuxHeader = {0};
wuxHeader.magic0 = WUX_MAGIC_0;
wuxHeader.magic1 = WUX_MAGIC_1;
wuxHeader.sectorSize = swap_uint32(this->sectorSize);
WUXFileWriter::WUXFileWriter(const char *path, int32_t cacheSize, int32_t sectorSize, bool split) : WUDFileWriter(path, cacheSize, sectorSize, split) {
wuxHeader_t wuxHeader = {0};
wuxHeader.magic0 = WUX_MAGIC_0;
wuxHeader.magic1 = WUX_MAGIC_1;
wuxHeader.sectorSize = swap_uint32(this->sectorSize);
wuxHeader.uncompressedSize = swap_uint64(WUD_FILE_SIZE);
wuxHeader.flags = 0;
wuxHeader.flags = 0;
this->write((uint8_t *) &wuxHeader, sizeof(wuxHeader_t));
this->sectorTableStart = this->tell();
@ -45,12 +44,12 @@ WUXFileWriter::WUXFileWriter(const char *path, int32_t cacheSize, int32_t sector
}
this->sectorTableEnd = this->tell();
uint64_t tableEnd = this->sectorTableEnd;
uint64_t tableEnd = this->sectorTableEnd;
this->sectorTableEnd += this->sectorSize - 1;
this->sectorTableEnd -= (this->sectorTableEnd % this->sectorSize);
uint64_t padding = this->sectorTableEnd - tableEnd;
uint64_t padding = this->sectorTableEnd - tableEnd;
auto *paddingData = (uint8_t *) malloc(padding);
memset(paddingData, 0, padding);
this->write(reinterpret_cast<const uint8_t *>(paddingData), padding);
@ -77,7 +76,7 @@ int32_t WUXFileWriter::writeSector(const uint8_t *buffer, uint32_t numberOfSecto
indexTable[this->currentSector] = swap_uint32(this->hashMap[hash]);
} else {
indexTable[this->currentSector] = swap_uint32(this->writtenSector);
hashMap[hash] = writtenSector;
hashMap[hash] = writtenSector;
if (isOpen()) {
if (!write((uint8_t *) addr, this->sectorSize)) {
DEBUG_FUNCTION_LINE("Write failed");
@ -111,5 +110,4 @@ void WUXFileWriter::finalize() {
WUDFileWriter::finalize();
writeSectorIndexTable();
WUXFileWriter::close();
}

6
source/fs/WUXFileWriter.h
View File

@ -16,8 +16,8 @@
****************************************************************************/
#pragma once
#include "utils/utils.h"
#include "WUDFileWriter.h"
#include "utils/utils.h"
#include <map>
typedef struct {
@ -28,8 +28,8 @@ typedef struct {
unsigned int flags;
} wuxHeader_t;
#define WUX_MAGIC_0 0x57555830
#define WUX_MAGIC_1 swap_uint32(0x1099d02e)
#define WUX_MAGIC_0 0x57555830
#define WUX_MAGIC_1 swap_uint32(0x1099d02e)
class WUXFileWriter : public WUDFileWriter {
public:

14
source/fs/WriteOnlyFileWithCache.cpp
View File

@ -14,11 +14,11 @@
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
****************************************************************************/
#include <malloc.h>
#include <coreinit/memory.h>
#include <utils/logger.h>
#include <utils/StringTools.h>
#include "WriteOnlyFileWithCache.h"
#include <coreinit/memory.h>
#include <malloc.h>
#include <utils/StringTools.h>
#include <utils/logger.h>
#define SPLIT_SIZE (0x80000000)
@ -29,7 +29,7 @@ WriteOnlyFileWithCache::WriteOnlyFileWithCache(const char *path, int32_t cacheSi
return;
}
this->writeBufferSize = cacheSize;
this->writeBuffer = (void *) memalign(0x1000, this->writeBufferSize);
this->writeBuffer = (void *) memalign(0x1000, this->writeBufferSize);
if (this->writeBuffer == nullptr) {
this->close();
return;
@ -55,7 +55,7 @@ bool WriteOnlyFileWithCache::flush() {
}
int32_t WriteOnlyFileWithCache::write(const uint8_t *addr, size_t writeSize) {
auto finalAddr = addr;
auto finalAddr = addr;
size_t finalWriteSize = writeSize;
if (splitFile) {
if (pos + writeBufferPos + finalWriteSize >= SPLIT_SIZE) {
@ -73,7 +73,7 @@ int32_t WriteOnlyFileWithCache::write(const uint8_t *addr, size_t writeSize) {
}
}
finalWriteSize = writeSize - realWriteSize;
finalAddr = (uint8_t *) ((uint32_t) addr + realWriteSize);
finalAddr = (uint8_t *) ((uint32_t) addr + realWriteSize);
part++;
if (!flush()) {
return -2;

2
source/fs/WriteOnlyFileWithCache.h
View File

@ -43,6 +43,6 @@ public:
size_t writeBufferPos;
bool splitFile = false;
int32_t part = 1;
int32_t part = 1;
std::string originalPath;
};

2
source/input/CombinedInput.h
View File

@ -1,5 +1,5 @@
#pragma once
#include "Input.h"
class CombinedInput : public Input {
public:
void combine(const Input &b) {

63
source/input/Input.h
View File

@ -1,7 +1,7 @@
#pragma once
#include <cstring>
#include <cstdint>
#include <cstring>
class Input {
public:
@ -12,36 +12,36 @@ public:
virtual ~Input() = default;
enum eButtons {
BUTTON_NONE = 0x0000,
VPAD_TOUCH = 0x80000000,
BUTTON_Z = 0x20000,
BUTTON_C = 0x10000,
BUTTON_A = 0x8000,
BUTTON_B = 0x4000,
BUTTON_X = 0x2000,
BUTTON_Y = 0x1000,
BUTTON_1 = BUTTON_Y,
BUTTON_2 = BUTTON_X,
BUTTON_LEFT = 0x0800,
BUTTON_RIGHT = 0x0400,
BUTTON_UP = 0x0200,
BUTTON_DOWN = 0x0100,
BUTTON_ZL = 0x0080,
BUTTON_ZR = 0x0040,
BUTTON_L = 0x0020,
BUTTON_R = 0x0010,
BUTTON_PLUS = 0x0008,
BUTTON_MINUS = 0x0004,
BUTTON_HOME = 0x0002,
BUTTON_SYNC = 0x0001,
STICK_R_LEFT = 0x04000000,
STICK_R_RIGHT = 0x02000000,
STICK_R_UP = 0x01000000,
STICK_R_DOWN = 0x00800000,
STICK_L_LEFT = 0x40000000,
STICK_L_RIGHT = 0x20000000,
STICK_L_UP = 0x10000000,
STICK_L_DOWN = 0x08000000
BUTTON_NONE = 0x0000,
VPAD_TOUCH = 0x80000000,
BUTTON_Z = 0x20000,
BUTTON_C = 0x10000,
BUTTON_A = 0x8000,
BUTTON_B = 0x4000,
BUTTON_X = 0x2000,
BUTTON_Y = 0x1000,
BUTTON_1 = BUTTON_Y,
BUTTON_2 = BUTTON_X,
BUTTON_LEFT = 0x0800,
BUTTON_RIGHT = 0x0400,
BUTTON_UP = 0x0200,
BUTTON_DOWN = 0x0100,
BUTTON_ZL = 0x0080,
BUTTON_ZR = 0x0040,
BUTTON_L = 0x0020,
BUTTON_R = 0x0010,
BUTTON_PLUS = 0x0008,
BUTTON_MINUS = 0x0004,
BUTTON_HOME = 0x0002,
BUTTON_SYNC = 0x0001,
STICK_R_LEFT = 0x04000000,
STICK_R_RIGHT = 0x02000000,
STICK_R_UP = 0x01000000,
STICK_R_DOWN = 0x00800000,
STICK_L_LEFT = 0x40000000,
STICK_L_RIGHT = 0x20000000,
STICK_L_UP = 0x10000000,
STICK_L_DOWN = 0x08000000
};
typedef struct {
@ -57,5 +57,4 @@ public:
PadData data{};
PadData lastData{};
};

10
source/input/VPADInput.h
View File

@ -16,8 +16,8 @@
* along with this program. If not, see <http://www.gnu.org/licenses/>.
****************************************************************************/
#include <vpad/input.h>
#include "Input.h"
#include <vpad/input.h>
class VPadInput : public Input {
public:
@ -36,11 +36,11 @@ public:
VPADRead(VPAD_CHAN_0, &vpad, 1, &vpadError);
if (vpadError == VPAD_READ_SUCCESS) {
data.buttons_r = vpad.release;
data.buttons_h = vpad.hold;
data.buttons_d = vpad.trigger;
data.buttons_r = vpad.release;
data.buttons_h = vpad.hold;
data.buttons_d = vpad.trigger;
data.validPointer = !vpad.tpNormal.validity;
data.touched = vpad.tpNormal.touched;
data.touched = vpad.tpNormal.touched;
VPADGetTPCalibratedPoint(VPAD_CHAN_0, &tpCalib, &vpad.tpFiltered1);

2
source/input/WPADInput.h
View File

@ -16,9 +16,9 @@
* along with this program. If not, see <http://www.gnu.org/licenses/>.
****************************************************************************/
#include "Input.h"
#include <padscore/kpad.h>
#include <padscore/wpad.h>
#include "Input.h"
class WPADInput : public Input {
public:

27
source/main.cpp
View File

@ -1,21 +1,21 @@
#include <whb/proc.h>
#include <whb/log.h>
#include <whb/log_udp.h>
#include <whb/proc.h>
#include <thread>
#include <iosuhax.h>
#include <ntfs.h>
#include <coreinit/debug.h>
#include <coreinit/energysaver.h>
#include <padscore/kpad.h>
#include <input/WPADInput.h>
#include <input/CombinedInput.h>
#include <input/WPADInput.h>
#include <iosuhax.h>
#include <ntfs.h>
#include <padscore/kpad.h>
#include "utils/logger.h"
#include "utils/WiiUScreen.h"
#include "input/VPADInput.h"
#include "MainApplicationState.h"
#include "input/VPADInput.h"
#include "utils/WiiUScreen.h"
#include "utils/logger.h"
void initIOSUHax();
@ -84,8 +84,7 @@ void main_loop() {
WPAD_CHAN_0,
WPAD_CHAN_1,
WPAD_CHAN_2,
WPAD_CHAN_3
};
WPAD_CHAN_3};
if (gFSAfd < 0 || !sIosuhaxMount) {
// state.setError(MainApplicationState::eErrorState::ERROR_IOSUHAX_FAILED);
@ -98,8 +97,8 @@ void main_loop() {
if (vpadInput.update(1280, 720)) {
baseInput.combine(vpadInput);
}
for (auto &wpadInput: wpadInputs) {
if(wpadInput.update(1280, 720)){
for (auto &wpadInput : wpadInputs) {
if (wpadInput.update(1280, 720)) {
baseInput.combine(wpadInput);
}
}
@ -111,12 +110,12 @@ void main_loop() {
void initIOSUHax() {
sIosuhaxMount = false;
int res = IOSUHAX_Open(nullptr);
int res = IOSUHAX_Open(nullptr);
if (res < 0) {
DEBUG_FUNCTION_LINE("IOSUHAX_open failed");
} else {
sIosuhaxMount = true;
gFSAfd = IOSUHAX_FSA_Open();
gFSAfd = IOSUHAX_FSA_Open();
if (gFSAfd < 0) {
DEBUG_FUNCTION_LINE("IOSUHAX_FSA_Open failed");
} else {

10
source/utils/FSTUtils.cpp
View File

@ -25,16 +25,16 @@ std::optional<std::shared_ptr<NodeEntry>> FSTUtils::getFSTEntryByFullPath(const
fullPath = "/" + fullPath;
}
auto pathOpt = std::optional(root);
auto pathOpt = std::optional(root);
std::filesystem::path asPath = fullPath;
std::string dirPath = asPath.parent_path().string();
std::string dirPath = asPath.parent_path().string();
if (dirPath != "/") {
pathOpt = getFileEntryDir(root, dirPath);
}
if (!pathOpt.has_value()) {
return {};
}
for (auto &child: pathOpt.value()->getChildren()) {
for (auto &child : pathOpt.value()->getChildren()) {
if (child->getFullPath() == fullPath) {
return child;
}
@ -48,7 +48,7 @@ std::optional<std::shared_ptr<DirectoryEntry>> FSTUtils::getFileEntryDir(const s
if (!string.ends_with("/")) {
string += "/";
}
for (auto &curChild: curEntry->getDirChildren()) {
for (auto &curChild : curEntry->getDirChildren()) {
std::string compareTo = curChild->getFullPath();
if (!compareTo.ends_with("/")) {
compareTo += "/";
@ -64,7 +64,7 @@ std::optional<std::shared_ptr<DirectoryEntry>> FSTUtils::getFileEntryDir(const s
}
std::optional<std::shared_ptr<SectionEntry>> FSTUtils::getSectionEntryForIndex(const std::shared_ptr<FST> &pFst, uint16_t index) {
for (const auto &entry: pFst->sectionEntries->getSections()) {
for (const auto &entry : pFst->sectionEntries->getSections()) {
if (entry->sectionNumber == index) {
return entry;
}

7
source/utils/FSTUtils.h
View File

@ -16,10 +16,10 @@
****************************************************************************/
#pragma once
#include <string>
#include <WUD/entities/FST/nodeentry/NodeEntry.h>
#include <WUD/entities/FST/nodeentry/DirectoryEntry.h>
#include <WUD/entities/FST/FST.h>
#include <WUD/entities/FST/nodeentry/DirectoryEntry.h>
#include <WUD/entities/FST/nodeentry/NodeEntry.h>
#include <string>
class FSTUtils {
public:
@ -29,4 +29,3 @@ public:
static std::optional<std::shared_ptr<SectionEntry>> getSectionEntryForIndex(const std::shared_ptr<FST> &pFst, uint16_t index);
};

2
source/utils/ScreenUtils.cpp
View File

@ -14,8 +14,8 @@
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
****************************************************************************/
#include <coreinit/screen.h>
#include "ScreenUtils.h"
#include <coreinit/screen.h>
void ScreenUtils::printTextOnScreen(ConsoleScreenID screen, int x, int y, const char *msg) {
if (!msg) {

1
source/utils/ScreenUtils.h
View File

@ -15,6 +15,7 @@
* along with this program. If not, see <http://www.gnu.org/licenses/>.
****************************************************************************/
#pragma once
#include <stdint.h>
//! Defines the ID of a display usable with OSScreen.
typedef enum ConsoleScreenID {

30
source/utils/StringTools.cpp
View File

@ -23,17 +23,16 @@
*
* for WiiXplorer 2010
***************************************************************************/
#include <vector>
#include <string>
#include <string.h>
#include <stdarg.h>
#include <stdlib.h>
#include <stdio.h>
#include <wchar.h>
#include <strings.h>
#include <wut_types.h>
#include <stdio.h>
#include "StringTools.h"
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <strings.h>
#include <vector>
#include <wchar.h>
#include <wut_types.h>
BOOL StringTools::EndsWith(const std::string &a, const std::string &b) {
@ -85,7 +84,7 @@ const wchar_t *StringTools::wfmt(const char *format, ...) {
static char tmp[512];
static wchar_t strWChar[512];
strWChar[0] = 0;
tmp[0] = 0;
tmp[0] = 0;
if (!format)
return (const wchar_t *) strWChar;
@ -98,7 +97,7 @@ const wchar_t *StringTools::wfmt(const char *format, ...) {
if ((vsprintf(tmp, format, va) >= 0)) {
int32_t bt;
int32_t strlength = strlen(tmp);
bt = mbstowcs(strWChar, tmp, (strlength < 512) ? strlength : 512);
bt = mbstowcs(strWChar, tmp, (strlength < 512) ? strlength : 512);
if (bt > 0) {
strWChar[bt] = 0;
@ -112,13 +111,13 @@ const wchar_t *StringTools::wfmt(const char *format, ...) {
int32_t StringTools::strprintf(std::string &str, const char *format, ...) {
static char tmp[512];
tmp[0] = 0;
tmp[0] = 0;
int32_t result = 0;
va_list va;
va_start(va, format);
if ((vsprintf(tmp, format, va) >= 0)) {
str = tmp;
str = tmp;
result = str.size();
}
va_end(va);
@ -214,8 +213,7 @@ bool StringTools::findStringIC(const std::string &strHaystack, const std::string
auto it = std::search(
strHaystack.begin(), strHaystack.end(),
strNeedle.begin(), strNeedle.end(),
[](char ch1, char ch2) { return std::toupper(ch1) == std::toupper(ch2); }
);
[](char ch1, char ch2) { return std::toupper(ch1) == std::toupper(ch2); });
return (it != strHaystack.end());
}

8
source/utils/StringTools.h
View File

@ -25,11 +25,11 @@
***************************************************************************/
#pragma once
#include <vector>
#include <string>
#include <wut_types.h>
#include <algorithm>
#include <cctype>
#include <string>
#include <vector>
#include <wut_types.h>
class StringTools {
public:
@ -57,7 +57,7 @@ public:
if (!path)
return path;
const char *ptr = path;
const char *ptr = path;
const char *Filename = ptr;
while (*ptr != '\0') {

1
source/utils/TinySHA1.hpp
View File

@ -1,3 +1,4 @@
// clang-format off
/*
*
* TinySHA1 - a header only implementation of the SHA1 algorithm in C++. Based

14
source/utils/WiiUScreen.cpp
View File

@ -4,13 +4,13 @@
#include <cstdarg>
#include <cstdio>
void *WiiUScreen::sBufferTV = nullptr;
void *WiiUScreen::sBufferDRC = nullptr;
uint32_t WiiUScreen::sBufferSizeTV = 0;
uint32_t WiiUScreen::sBufferSizeDRC = 0;
void *WiiUScreen::sBufferTV = nullptr;
void *WiiUScreen::sBufferDRC = nullptr;
uint32_t WiiUScreen::sBufferSizeTV = 0;
uint32_t WiiUScreen::sBufferSizeDRC = 0;
bool WiiUScreen::sConsoleHasForeground = true;
uint32_t WiiUScreen::consoleColor = 0x041F60FF;
uint32_t WiiUScreen::consoleCursorY = 0;
uint32_t WiiUScreen::consoleColor = 0x041F60FF;
uint32_t WiiUScreen::consoleCursorY = 0;
uint32_t WiiUScreen::ProcCallbackAcquired(void *context) {
@ -38,7 +38,7 @@ uint32_t WiiUScreen::ProcCallbackReleased(void *context) {
bool WiiUScreen::Init() {
OSScreenInit();
sBufferSizeTV = OSScreenGetBufferSizeEx(SCREEN_TV);
sBufferSizeTV = OSScreenGetBufferSizeEx(SCREEN_TV);
sBufferSizeDRC = OSScreenGetBufferSizeEx(SCREEN_DRC);
WiiUScreen::ProcCallbackAcquired(nullptr);

19
source/utils/WiiUScreen.h
View File

@ -3,23 +3,24 @@
#include <whb/log.h>
#include <whb/log_console.h>
#include <coreinit/memheap.h>
#include "utils/logger.h"
#include <coreinit/cache.h>
#include <coreinit/memfrmheap.h>
#include <coreinit/memheap.h>
#include <coreinit/memory.h>
#include <coreinit/screen.h>
#include <proc_ui/procui.h>
#include <cstring>
#include "utils/logger.h"
#include <proc_ui/procui.h>
#define NUM_LINES (16)
#define LINE_LENGTH (128)
#define NUM_LINES (16)
#define LINE_LENGTH (128)
#define CONSOLE_FRAME_HEAP_TAG (0x000DECAF)
#define PRINTF_BUFFER_LENGTH 2048
#define PRINTF_BUFFER_LENGTH 2048
#define DEBUG_CONSOLE_LOG(FMT, ARGS...)do { \
DEBUG_FUNCTION_LINE(FMT, ## ARGS); \
WiiUScreen::drawLinef(FMT, ## ARGS); \
#define DEBUG_CONSOLE_LOG(FMT, ARGS...) \
do { \
DEBUG_FUNCTION_LINE(FMT, ##ARGS); \
WiiUScreen::drawLinef(FMT, ##ARGS); \
} while (0)

3
source/utils/blocksize/AddressInBlocks.h
View File

@ -16,13 +16,12 @@
****************************************************************************/
#pragma once
#include <cstdint>
#include "BlockSize.h"
#include <cstdint>
class AddressInBlocks {
public:
explicit AddressInBlocks(const BlockSize &pBlockSize, uint32_t pValue) : blockSize(pBlockSize), value(pValue) {
}
AddressInBlocks() = default;

2
source/utils/blocksize/AddressInDiscBlocks.h
View File

@ -38,4 +38,4 @@ namespace std {
return lhs.getAddressInBytes() < rhs.getAddressInBytes();
}
};
}
} // namespace std

2
source/utils/blocksize/AddressInVolumeBlocks.h
View File

@ -16,8 +16,8 @@
****************************************************************************/
#pragma once
#include "VolumeBlockSize.h"
#include "AddressInBlocks.h"
#include "VolumeBlockSize.h"
class AddressInVolumeBlocks : public AddressInBlocks {

3
source/utils/blocksize/DiscBlockSize.h
View File

@ -16,8 +16,8 @@
****************************************************************************/
#pragma once
#include "utils/logger.h"
#include "BlockSize.h"
#include "utils/logger.h"
class DiscBlockSize : public BlockSize {
@ -25,6 +25,5 @@ public:
DiscBlockSize() = default;
explicit DiscBlockSize(uint32_t blockSize) : BlockSize(blockSize) {
}
};

Some files were not shown because too many files have changed in this diff Show More