subprojects/flashupdate/src/ops/read.cpp

// Copyright 2021 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#include <flasher/device.hpp>
#include <flasher/file.hpp>
#include <flasher/mod.hpp>
#include <flasher/ops.hpp>
#include <flashupdate/args.hpp>
#include <flashupdate/flash.hpp>
#include <flashupdate/info.hpp>
#include <flashupdate/logging.hpp>
#include <flashupdate/ops.hpp>
#include <flashupdate/validator.hpp>

#include <filesystem>
#include <format>
#include <string>

namespace flashupdate
{
namespace ops
{

using flasher::ModArgs;
using stdplus::fd::OpenAccess;
using stdplus::fd::OpenFlag;
using stdplus::fd::OpenFlags;

void read(const Args& args)
{
    if (args.validatorHelper == nullptr)
    {
        throw std::runtime_error("invalid Validator Helper");
    }

    auto& flashHelper = args.flashHelper;
    flashHelper->setup(args.config, args.keepMux);

    auto flash = flashHelper->getFlash(args.primary);
    if (!flash)
    {
        throw std::runtime_error("failed to find Flash partitions");
    }

    std::string image = args.file->arr.back();
    {
        flasher::NestedMutate mutate{};
        auto devMod = ModArgs(std::format("{}", flash->first));
        auto fileMod = *args.file;

        auto dev = flasher::openDevice(devMod);
        auto file = flasher::openFile(fileMod, OpenFlags(OpenAccess::WriteOnly)
                                                   .set(OpenFlag::Create)
                                                   .set(OpenFlag::Trunc));
        flasher::ops::read(*dev, 0, *file, 0, mutate,
                           std::numeric_limits<size_t>::max(), std::nullopt);
    }
    // Device has to be released before flashHelper cleanup.
    flashHelper->cleanup();

    // Validate the image read from the flash
    auto& helper = args.validatorHelper;
    auto fileMod = ModArgs(image);
    auto inputImage =
        flasher::openFile(fileMod, OpenFlags(OpenAccess::ReadOnly));
    if (!helper->validateImage(*inputImage, args.config.flash.validationKey))
    {
        throw std::runtime_error(std::format(
            "failed to validate the CR51 descriptor for {}", image));
    }
}

} // namespace ops
} // namespace flashupdate