ncm: implement packagedcontent -> content for building metadb

libraries/libstratosphere/include/stratosphere/ncm/ncm_content_info_data.hpp

@@ -25,4 +25,21 @@ namespace ams::ncm {
         u8 data[crypto::Sha256Generator::HashSize];
     };
 
+    struct PackagedContentInfo {
+        Digest digest;
+        ContentInfo info;
+
+        constexpr const ContentId &GetId() const {
+            return this->info.GetId();
+        }
+
+        constexpr const ContentType GetType() const {
+            return this->info.GetType();
+        }
+
+        constexpr const u8 GetIdOffset() const {
+            return this->info.GetIdOffset();
+        }
+    };
+
 }

libraries/libstratosphere/include/stratosphere/ncm/ncm_content_meta.hpp

@@ -61,6 +61,26 @@ namespace ams::ncm {
 
     static_assert(sizeof(ContentMetaHeader) == 0x8);
 
+    struct PackagedContentMetaHeader {
+        u64 id;
+        u32 version;
+        ContentMetaType type;
+        u8 reserved_0D;
+        u16 extended_header_size;
+        u16 content_count;
+        u16 content_meta_count;
+        u8 attributes;
+        u8 storage_id;
+        ContentInstallType install_type;
+        u8 reserved_17;
+        u32 required_download_system_version;
+        u8 reserved_1C[4];
+    };
+    static_assert(sizeof(PackagedContentMetaHeader) == 0x20);
+    static_assert(OFFSETOF(PackagedContentMetaHeader, reserved_0D) == 0x0D);
+    static_assert(OFFSETOF(PackagedContentMetaHeader, reserved_17) == 0x17);
+    static_assert(OFFSETOF(PackagedContentMetaHeader, reserved_1C) == 0x1C);
+
     struct ApplicationMetaExtendedHeader {
         PatchId patch_id;
         u32 required_system_version;
@@ -277,4 +297,19 @@ namespace ams::ncm {
             using ContentMetaAccessor::CalculateSize;
     };
 
+    class PackagedContentMetaReader : public ContentMetaAccessor<PackagedContentMetaHeader, PackagedContentInfo> {
+        public:
+            constexpr PackagedContentMetaReader(const void *data, size_t size) : ContentMetaAccessor(data, size) { /* ... */ }
+
+            size_t CalculateConvertContentMetaSize() const;
+
+            void ConvertToContentMeta(void *dst, size_t size, const ContentInfo &meta);
+
+            size_t CountDeltaFragments() const;
+
+            static constexpr size_t CalculateSize(ContentMetaType type, size_t content_count, size_t content_meta_count, size_t extended_data_size) {
+                return ContentMetaAccessor::CalculateSize(type, content_count, content_meta_count, extended_data_size, true);
+            }
+    };
+
 }

libraries/libstratosphere/source/fs/fs_content.cpp

@@ -57,8 +57,8 @@ namespace ams::fs {
     }
 
     Result MountContent(const char *name, const char *path, ContentType content_type) {
-        /* This API only supports mounting Manual content. */
-        AMS_ABORT_UNLESS(content_type == ContentType_Manual);
+        /* This API only supports mounting Meta content. */
+        AMS_ABORT_UNLESS(content_type == ContentType_Meta);
 
         return MountContent(name, path, ncm::InvalidProgramId, content_type);
     }

libraries/libstratosphere/source/ncm/ncm_content_management_utils.cpp

@@ -19,7 +19,22 @@ namespace ams::ncm {
 
 
     Result ContentMetaDatabaseBuilder::BuildFromPackageContentMeta(void *buf, size_t size, const ContentInfo &meta_info) {
-        AMS_ABORT();
+        /* Create a reader for the content meta. */
+        ncm::PackagedContentMetaReader package_meta_reader(buf, size);
+
+        /* Allocate space to hold the converted meta. */
+        const size_t meta_size = package_meta_reader.CalculateConvertContentMetaSize();
+        void *meta = std::malloc(meta_size);
+        ON_SCOPE_EXIT { std::free(meta); };
+
+        /* Convert the meta from packaged form to normal form. */
+        package_meta_reader.ConvertToContentMeta(meta, meta_size, meta_info);
+        ncm::ContentMetaReader meta_reader(meta, meta_size);
+
+        /* Insert the new metas into the database. */
+        R_TRY(this->db->Set(package_meta_reader.GetKey(), meta_reader.GetData(), meta_reader.GetSize()));
+
+        /* We're done. */
         return ResultSuccess();
     }
 

libraries/libstratosphere/source/ncm/ncm_content_meta.cpp

@@ -0,0 +1,101 @@
+/*
+ * Copyright (c) 2019-2020 Adubbz, 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 <http://www.gnu.org/licenses/>.
+ */
+#include <stratosphere.hpp>
+
+namespace ams::ncm {
+
+    namespace {
+
+        void ConvertPackageContentMetaHeaderToContentMetaHeader(ContentMetaHeader *dst, const PackagedContentMetaHeader &src) {
+            /* Clear destination. */
+            *dst = {};
+
+            /* Set converted fields. */
+            dst->extended_header_size = src.extended_header_size;
+            dst->content_meta_count   = src.content_meta_count;
+            dst->content_count        = src.content_meta_count;
+            dst->attributes           = src.attributes;
+        }
+
+    }
+
+    size_t PackagedContentMetaReader::CountDeltaFragments() const {
+        size_t count = 0;
+        for (size_t i = 0; i < this->GetContentCount(); i++) {
+            if (this->GetContentInfo(i)->GetType() == ContentType::DeltaFragment) {
+                count++;
+            }
+        }
+        return count;
+    }
+
+    size_t PackagedContentMetaReader::CalculateConvertContentMetaSize() const {
+        const auto *header = this->GetHeader();
+        return this->CalculateSizeImpl<ContentMetaHeader, ContentInfo>(header->extended_header_size, header->content_count + 1, header->content_meta_count, 0, false);
+    }
+
+    void PackagedContentMetaReader::ConvertToContentMeta(void *dst, size_t size, const ContentInfo &meta) {
+        /* Ensure we have enough space to convert. */
+        AMS_ABORT_UNLESS(size >= this->CalculateConvertContentMetaSize());
+
+        /* Prepare for conversion. */
+        const auto *packaged_header = this->GetHeader();
+        uintptr_t dst_addr = reinterpret_cast<uintptr_t>(dst);
+
+        /* Convert the header. */
+        ContentMetaHeader header;
+        ConvertPackageContentMetaHeaderToContentMetaHeader(std::addressof(header), *packaged_header);
+        header.content_count += 1;
+
+        /* Don't include deltas. */
+        if (packaged_header->type == ContentMetaType::Patch) {
+            header.content_count -= this->CountDeltaFragments();
+        }
+
+        /* Copy the header. */
+        std::memcpy(reinterpret_cast<void *>(dst_addr), std::addressof(header), sizeof(header));
+        dst_addr += sizeof(header);
+
+        /* Copy the extended header. */
+        std::memcpy(reinterpret_cast<void *>(dst_addr), reinterpret_cast<void *>(this->GetExtendedHeaderAddress()), packaged_header->extended_header_size);
+        dst_addr += packaged_header->extended_header_size;
+
+        /* Copy the top level meta. */
+        std::memcpy(reinterpret_cast<void *>(dst_addr), std::addressof(meta), sizeof(meta));
+        dst_addr += sizeof(meta);
+
+        /* Copy content infos. */
+        for (size_t i = 0; i < this->GetContentCount(); i++) {
+            /* Don't copy any delta fragments. */
+            if (packaged_header->type == ContentMetaType::Patch) {
+                if (this->GetContentInfo(i)->GetType() == ContentType::DeltaFragment) {
+                    continue;
+                }
+            }
+
+            /* Copy the current info. */
+            std::memcpy(reinterpret_cast<void *>(dst_addr), std::addressof(this->GetContentInfo(i)->info), sizeof(ContentInfo));
+            dst_addr += sizeof(ContentInfo);
+        }
+
+        /* Copy content meta infos. */
+        for (size_t i = 0; i < this->GetContentMetaCount(); i++) {
+            std::memcpy(reinterpret_cast<void *>(dst_addr), this->GetContentMetaInfo(i), sizeof(ContentMetaInfo));
+            dst_addr += sizeof(ContentMetaInfo);
+        }
+    }
+
+}