/*
* Copyright (c) 2018-2020 Atmosphère-NX
*
* This program is free software; you can redistribute it and/or modify it
* under the terms and conditions of the GNU General Public License,
* version 2, as published by the Free Software Foundation.
*
* This program is distributed in the hope it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see .
*/
#pragma once
#include
#include
#include
#include
namespace ams::ncm {
enum class UpdateType : u8 {
ApplyAsDelta = 0,
Overwrite = 1,
Create = 2,
};
struct FragmentIndicator {
u16 content_info_index;
u16 fragment_index;
};
struct FragmentSet {
ContentId source_content_id;
ContentId destination_content_id;
u32 source_size_low;
u16 source_size_high;
u16 destination_size_high;
u32 destination_size_low;
u16 fragment_count;
ContentType target_content_type;
UpdateType update_type;
u8 reserved[4];
constexpr s64 GetSourceSize() const {
return (static_cast(this->source_size_high) << 32) + this->source_size_low;
}
constexpr s64 GetDestinationSize() const {
return (static_cast(this->destination_size_high) << 32) + this->destination_size_low;
}
constexpr void SetSourceSize(s64 size) {
this->source_size_low = size & 0xFFFFFFFFll;
this->source_size_high = static_cast(size >> 32);
}
constexpr void SetDestinationSize(s64 size) {
this->destination_size_low = size & 0xFFFFFFFFll;
this->destination_size_high = static_cast(size >> 32);
}
};
struct SystemUpdateMetaExtendedDataHeader {
u32 unk; // Always seems to be set to 2
u32 firmware_variation_count;
};
struct DeltaMetaExtendedDataHeader {
PatchId source_id;
PatchId destination_id;
u32 source_version;
u32 destination_version;
u16 fragment_set_count;
u8 reserved[6];
};
struct PatchMetaExtendedDataHeader {
u32 history_count;
u32 delta_history_count;
u32 delta_count;
u32 fragment_set_count;
u32 history_content_total_count;
u32 delta_content_total_count;
u8 reserved[4];
};
struct PatchHistoryHeader {
ContentMetaKey key;
Digest digest;
u16 content_count;
u8 reserved[2];
};
struct PatchDeltaHistory {
PatchId source_id;
PatchId destination_id;
u32 source_version;
u32 destination_version;
u64 download_size;
u8 reserved[4];
};
struct PatchDeltaHeader {
DeltaMetaExtendedDataHeader delta;
u16 content_count;
u8 reserved[4];
};
template
class PatchMetaExtendedDataReaderWriterBase {
private:
MemberTypePointer data;
const size_t size;
public:
PatchMetaExtendedDataReaderWriterBase(MemberTypePointer d, size_t sz) : data(d), size(sz) { /* ... */ }
protected:
s32 CountFragmentSet(s32 delta_index) const {
auto delta_header = this->GetPatchDeltaHeader(0);
s32 count = 0;
for (s32 i = 0; i < delta_index; i++) {
count += delta_header[i].delta.fragment_set_count;
}
return count;
}
s32 CountHistoryContent(s32 history_index) const {
auto history_header = this->GetPatchHistoryHeader(0);
s32 count = 0;
for (s32 i = 0; i < history_index; i++) {
count += history_header[i].content_count;
}
return count;
}
s32 CountDeltaContent(s32 delta_index) const {
auto delta_header = this->GetPatchDeltaHeader(0);
s32 count = 0;
for (s32 i = 0; i < delta_index; i++) {
count += delta_header[i].content_count;
}
return count;
}
s32 CountFragment(s32 index) const {
auto fragment_set = this->GetFragmentSet(0, 0);
s32 count = 0;
for (s32 i = 0; i < index; i++) {
count += fragment_set[i].fragment_count;
}
return count;
}
DataTypePointer GetHeaderAddress() const {
return reinterpret_cast(this->data);
}
DataTypePointer GetPatchHistoryHeaderAddress(s32 index) const {
auto header = this->GetHeader();
AMS_ABORT_UNLESS(static_cast(index) < header->history_count);
return this->GetHeaderAddress()
+ sizeof(PatchMetaExtendedDataHeader)
+ sizeof(PatchHistoryHeader) * index;
}
DataTypePointer GetPatchDeltaHistoryAddress(s32 index) const {
auto header = this->GetHeader();
AMS_ABORT_UNLESS(static_cast(index) < header->delta_history_count);
return this->GetHeaderAddress()
+ sizeof(PatchMetaExtendedDataHeader)
+ sizeof(PatchHistoryHeader) * header->history_count
+ sizeof(PatchDeltaHistory) * index;
}
DataTypePointer GetPatchDeltaHeaderAddress(s32 index) const {
auto header = this->GetHeader();
AMS_ABORT_UNLESS(static_cast(index) < header->delta_count);
return this->GetHeaderAddress()
+ sizeof(PatchMetaExtendedDataHeader)
+ sizeof(PatchHistoryHeader) * header->history_count
+ sizeof(PatchDeltaHistory) * header->delta_history_count
+ sizeof(PatchDeltaHeader) * index;
}
DataTypePointer GetFragmentSetAddress(s32 delta_index, s32 fragment_set_index) const {
auto header = this->GetHeader();
AMS_ABORT_UNLESS(static_cast(delta_index) < header->delta_count);
auto delta_header = this->GetPatchDeltaHeader(delta_index);
AMS_ABORT_UNLESS(static_cast(fragment_set_index) < delta_header->delta.fragment_set_count);
auto previous_fragment_set_count = this->CountFragmentSet(delta_index);
return this->GetHeaderAddress()
+ sizeof(PatchMetaExtendedDataHeader)
+ sizeof(PatchHistoryHeader) * header->history_count
+ sizeof(PatchDeltaHistory) * header->delta_history_count
+ sizeof(PatchDeltaHeader) * header->delta_count
+ sizeof(FragmentSet) * (previous_fragment_set_count + fragment_set_index);
}
DataTypePointer GetPatchHistoryContentInfoAddress(s32 history_index, s32 content_index) const {
auto header = this->GetHeader();
auto history_header = this->GetPatchHistoryHeader(history_index);
AMS_ABORT_UNLESS(static_cast(content_index) < history_header->content_count);
auto prev_history_count = this->CountHistoryContent(history_index);
return this->GetHeaderAddress()
+ sizeof(PatchMetaExtendedDataHeader)
+ sizeof(PatchHistoryHeader) * header->history_count
+ sizeof(PatchDeltaHistory) * header->delta_history_count
+ sizeof(PatchDeltaHeader) * header->delta_count
+ sizeof(FragmentSet) * header->fragment_set_count
+ sizeof(ContentInfo) * (prev_history_count + content_index);
}
DataTypePointer GetPatchDeltaPackagedContentInfoAddress(s32 delta_index, s32 content_index) const {
auto header = this->GetHeader();
auto delta_header = this->GetPatchDeltaHeader(delta_index);
AMS_ABORT_UNLESS(static_cast(content_index) < delta_header->content_count);
auto content_count = this->CountDeltaContent(delta_index);
return this->GetHeaderAddress()
+ sizeof(PatchMetaExtendedDataHeader)
+ sizeof(PatchHistoryHeader) * header->history_count
+ sizeof(PatchDeltaHistory) * header->delta_history_count
+ sizeof(PatchDeltaHeader) * header->delta_count
+ sizeof(FragmentSet) * header->fragment_set_count
+ sizeof(ContentInfo) * header->history_content_total_count
+ sizeof(PackagedContentInfo) * (content_count + content_index);
}
DataTypePointer GetFragmentIndicatorAddress(s32 delta_index, s32 fragment_set_index, s32 index) const {
auto header = this->GetHeader();
auto fragment_set = this->GetFragmentSet(delta_index, fragment_set_index);
AMS_ABORT_UNLESS(static_cast(index) < fragment_set->fragment_count);
auto fragment_set_count = this->CountFragmentSet(delta_index);
auto fragment_count = this->CountFragment(fragment_set_count + fragment_set_index);
return this->GetHeaderAddress()
+ sizeof(PatchMetaExtendedDataHeader)
+ sizeof(PatchHistoryHeader) * header->history_count
+ sizeof(PatchDeltaHistory) * header->delta_history_count
+ sizeof(PatchDeltaHeader) * header->delta_count
+ sizeof(FragmentSet) * header->fragment_set_count
+ sizeof(ContentInfo) * header->history_content_total_count
+ sizeof(PackagedContentInfo) * header->delta_content_total_count
+ sizeof(FragmentIndicator) * (fragment_count + index);
}
public:
const PatchMetaExtendedDataHeader *GetHeader() const {
return reinterpret_cast(this->GetHeaderAddress());
}
const PatchHistoryHeader *GetPatchHistoryHeader(s32 index) const {
return reinterpret_cast(this->GetPatchHistoryHeaderAddress(index));
}
const PatchDeltaHistory *GetPatchDeltaHistory(s32 index) const {
return reinterpret_cast(this->GetPatchDeltaHistoryAddress(index));
}
const ContentInfo *GetPatchHistoryContentInfo(s32 history_index, s32 content_index) const {
return reinterpret_cast(this->GetPatchHistoryContentInfoAddress(history_index, content_index));
}
const PatchDeltaHeader *GetPatchDeltaHeader(s32 index) const {
return reinterpret_cast(this->GetPatchDeltaHeaderAddress(index));
}
const PackagedContentInfo *GetPatchDeltaPackagedContentInfo(s32 delta_index, s32 content_index) const {
return reinterpret_cast(this->GetPatchDeltaPackagedContentInfoAddress(delta_index, content_index));
}
const FragmentSet *GetFragmentSet(s32 delta_index, s32 fragment_set_index) const {
return reinterpret_cast(this->GetFragmentSetIndex(delta_index, fragment_set_index));
}
const FragmentIndicator *GetFragmentIndicator(s32 delta_index, s32 fragment_set_index, s32 index) const {
return reinterpret_cast(this->GetFragmentIndicatorAddress(delta_index, fragment_set_index, index));
}
const FragmentIndicator *FindFragmentIndicator(s32 delta_index, s32 fragment_set_index, s32 fragment_index) const {
auto fragment_set = this->GetFragmentSet(delta_index, fragment_set_index);
auto fragment = this->GetFragmentIndicator(delta_index, fragment_set_index, 0);
for (s32 i = 0; i < fragment_set->fragment_count; i++) {
if (fragment[i].fragment_index == fragment_index) {
return std::addressof(fragment[i]);
}
}
return nullptr;
}
};
class PatchMetaExtendedDataReader : public PatchMetaExtendedDataReaderWriterBase {
public:
PatchMetaExtendedDataReader(const void *data, size_t size) : PatchMetaExtendedDataReaderWriterBase(data, size) { /* ... */ }
};
class SystemUpdateMetaExtendedDataReaderWriterBase {
private:
void *data;
const size_t size;
bool is_header_valid;
protected:
constexpr SystemUpdateMetaExtendedDataReaderWriterBase(const void *d, size_t sz) : data(const_cast(d)), size(sz), is_header_valid(true) { /* ... */ }
constexpr SystemUpdateMetaExtendedDataReaderWriterBase(void *d, size_t sz) : data(d), size(sz), is_header_valid(false) { /* ... */ }
uintptr_t GetHeaderAddress() const {
return reinterpret_cast(this->data);
}
uintptr_t GetFirmwarVariationIdStartAddress() const {
return this->GetHeaderAddress() + sizeof(SystemUpdateMetaExtendedDataHeader);
}
uintptr_t GetFirmwareVariationIdAddress(size_t i) const {
return this->GetFirmwarVariationIdStartAddress() + i * sizeof(FirmwareVariationId);
}
uintptr_t GetFirmwareVariationInfoStartAddress() const {
return this->GetFirmwareVariationIdAddress(this->GetFirmwareVariationCount());
}
uintptr_t GetFirmwareVariationInfoAddress(size_t i) const {
return this->GetFirmwarVariationIdStartAddress() + i * sizeof(FirmwareVariationInfo);
}
uintptr_t GetContentMetaInfoStartAddress() const {
return this->GetFirmwareVariationInfoAddress(this->GetFirmwareVariationCount());
}
uintptr_t GetContentMetaInfoAddress(size_t i) const {
return this->GetContentMetaInfoStartAddress() + i * sizeof(ContentMetaInfo);
}
public:
const SystemUpdateMetaExtendedDataHeader *GetHeader() const {
AMS_ABORT_UNLESS(this->is_header_valid);
return reinterpret_cast(this->GetHeaderAddress());
}
size_t GetFirmwareVariationCount() const {
return this->GetHeader()->firmware_variation_count;
}
const FirmwareVariationId *GetFirmwareVariationId(size_t i) const {
AMS_ABORT_UNLESS(i < this->GetFirmwareVariationCount());
return reinterpret_cast(this->GetFirmwareVariationIdAddress(i));
}
const FirmwareVariationInfo *GetFirmwareVariationInfo(size_t i) const {
AMS_ABORT_UNLESS(i < this->GetFirmwareVariationCount());
return reinterpret_cast(this->GetFirmwareVariationInfoAddress(i));
}
void GetContentMetaInfoList(Span *out_list, size_t i) const {
size_t preceding_content_meta_count = 0;
/* Count the number of preceding content metas. */
for (size_t j = 0; j < i; j++) {
preceding_content_meta_count += this->GetFirmwareVariationInfo(j)->content_meta_count;
}
/* Output the list. */
*out_list = Span(reinterpret_cast(this->GetContentMetaInfoAddress(preceding_content_meta_count)), this->GetFirmwareVariationInfo(i)->content_meta_count);
}
};
class SystemUpdateMetaExtendedDataReader : public SystemUpdateMetaExtendedDataReaderWriterBase {
public:
constexpr SystemUpdateMetaExtendedDataReader(const void *data, size_t size) : SystemUpdateMetaExtendedDataReaderWriterBase(data, size) { /* ... */ }
};
}