1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
|
// Copyright 2009 Dolphin Emulator Project
// Licensed under GPLv2+
// Refer to the license.txt file included.
#pragma once
#include <cstddef>
#include <memory>
#include <string>
#include <unordered_map>
#include <vector>
#include "Common/CommonTypes.h"
#include "Common/NandPaths.h"
#include "Core/IOS/ES/Formats.h"
namespace File
{
class IOFile;
}
namespace DiscIO
{
enum class Region;
bool AddTicket(const IOS::ES::TicketReader& signed_ticket);
IOS::ES::TicketReader FindSignedTicket(u64 title_id);
class CNANDContentData
{
public:
virtual ~CNANDContentData() = 0;
virtual void Open() {}
virtual std::vector<u8> Get() = 0;
virtual bool GetRange(u32 start, u32 size, u8* buffer) = 0;
virtual void Close() {}
};
class CNANDContentDataFile final : public CNANDContentData
{
public:
explicit CNANDContentDataFile(const std::string& filename);
~CNANDContentDataFile();
void Open() override;
std::vector<u8> Get() override;
bool GetRange(u32 start, u32 size, u8* buffer) override;
void Close() override;
private:
void EnsureOpen();
const std::string m_filename;
std::unique_ptr<File::IOFile> m_file;
};
class CNANDContentDataBuffer final : public CNANDContentData
{
public:
explicit CNANDContentDataBuffer(const std::vector<u8>& buffer) : m_buffer(buffer) {}
std::vector<u8> Get() override { return m_buffer; }
bool GetRange(u32 start, u32 size, u8* buffer) override;
private:
const std::vector<u8> m_buffer;
};
struct SNANDContent
{
IOS::ES::Content m_metadata;
std::unique_ptr<CNANDContentData> m_Data;
};
// Instances of this class must be created by CNANDContentManager
class CNANDContentLoader final
{
public:
explicit CNANDContentLoader(const std::string& content_name);
~CNANDContentLoader();
bool IsValid() const;
void RemoveTitle() const;
const SNANDContent* GetContentByIndex(int index) const;
const IOS::ES::TMDReader& GetTMD() const { return m_tmd; }
const IOS::ES::TicketReader& GetTicket() const { return m_ticket; }
const std::vector<SNANDContent>& GetContent() const { return m_Content; }
private:
bool Initialize(const std::string& name);
void InitializeContentEntries(const std::vector<u8>& data_app);
bool m_Valid = false;
bool m_IsWAD = false;
std::string m_Path;
IOS::ES::TMDReader m_tmd;
IOS::ES::TicketReader m_ticket;
std::vector<SNANDContent> m_Content;
};
// we open the NAND Content files too often... let's cache them
class CNANDContentManager
{
public:
static CNANDContentManager& Access()
{
static CNANDContentManager instance;
return instance;
}
u64 Install_WiiWAD(const std::string& fileName);
const CNANDContentLoader& GetNANDLoader(const std::string& content_path);
const CNANDContentLoader& GetNANDLoader(u64 title_id, Common::FromWhichRoot from);
bool RemoveTitle(u64 title_id, Common::FromWhichRoot from);
void ClearCache();
private:
CNANDContentManager() {}
~CNANDContentManager();
CNANDContentManager(CNANDContentManager const&) = delete;
void operator=(CNANDContentManager const&) = delete;
std::unordered_map<std::string, std::unique_ptr<CNANDContentLoader>> m_map;
};
class CSharedContent final
{
public:
explicit CSharedContent(Common::FromWhichRoot root);
std::string GetFilenameFromSHA1(const u8* hash) const;
std::string AddSharedContent(const u8* hash);
private:
#pragma pack(push, 1)
struct SElement
{
u8 FileName[8];
u8 SHA1Hash[20];
};
#pragma pack(pop)
Common::FromWhichRoot m_root;
u32 m_LastID;
std::string m_ContentMap;
std::vector<SElement> m_Elements;
};
class cUIDsys final
{
public:
explicit cUIDsys(Common::FromWhichRoot root);
u32 GetUIDFromTitle(u64 title_id);
void AddTitle(u64 title_id);
void GetTitleIDs(std::vector<u64>& title_ids, bool owned = false);
private:
#pragma pack(push, 1)
struct SElement
{
u8 titleID[8];
u8 UID[4];
};
#pragma pack(pop)
u32 m_LastUID;
std::string m_UidSys;
std::vector<SElement> m_Elements;
};
}
|
