// Copyright 2024 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 "payload_update.hpp"

#include "google3/host_commands.h"

#include "message_util.hpp"

#include "sys.hpp"

#include <fcntl.h>

#include <unistd.h>

#include <boost/endian/conversion.hpp>

#include <stdplus/print.hpp>

#include <stdplus/raw.hpp>

#include <xyz/openbmc_project/Control/Hoth/error.hpp>

#include <array>

#include <cstdint>

#include <format>

#include <memory>

#include <span>

#include <string>

#include <vector>

namespace google

{

namespace hoth

{

namespace internal

{

enum hoth_status : uint16_t

{

    /*

      There is no update payload pending confirmation

    */

    HOTH_PAYLOAD_UPDATE_CONFIRM_NO_PENDING_PAYLOAD = 0xD004,

};

using sdbusplus::error::xyz::openbmc_project::control::hoth::ResponseFailure;

void PayloadUpdateImpl::initiate() const

{

    sendCommand(PAYLOAD_UPDATE_INITIATE);

}

void PayloadUpdateImpl::erase(const uint32_t offset, const uint32_t size) const

{

    sendCommand(PAYLOAD_UPDATE_ERASE, offset, size);

}

bool PayloadUpdateImpl::findDescriptor(const std::string& path,

                                       uint32_t* desc_offset) const

{

    Fd fd(sys->open(path.c_str(), O_RDONLY), sys);

    if (*fd < 0)

    {

        (void)fd.release();

        throw errnoException(std::format("Failed to open file {}", path));

    }

    auto seekRet = sys->lseek(*fd, 0, SEEK_END);

    size_t fsize = seekRet;

    if (seekRet < 0)

    {

        throw errnoException(std::format("Error seeking on file", path));

    }

    uint64_t read_data = 0;

    bool desc_found = false;

    // Find the nearest aligned address to the end of the file. We can't

    // assume that the file-size is aligned.

    ssize_t offset = static_cast<ssize_t>(

        (fsize / kImageDescriptorAlignment) * kImageDescriptorAlignment);

    if (offset + sizeof(kDescriptorMagic) > fsize)

    {

        offset -= kImageDescriptorAlignment;

    }

    for (; offset >= 0; offset -= kImageDescriptorAlignment)

    {

        auto seek = sys->lseek(*fd, offset, SEEK_SET);

        if (seek < 0)

        {

            throw errnoException(std::format("Error seeking on file", path));

        }

        auto actualReadSize = sys->read(*fd, &read_data, sizeof(read_data));

        if (actualReadSize < 0)

        {

            throw errnoException(

                std::format("Failed to read from file {}", path));

        }

        if (read_data == kDescriptorMagic)

        {

            if (desc_offset)

            {

                *desc_offset = offset;

                desc_found = true;

                break;

            }

        }

    }

    return desc_found;

}

void PayloadUpdateImpl::eraseAndSendStaticWPRegions(const std::string& path,

                                                    uint32_t desc_offset) const

{

    Fd fd(sys->open(path.c_str(), O_RDONLY), sys);

    if (*fd < 0)

    {

        (void)fd.release();

        throw errnoException(std::format("Failed to open file {}", path));

    }

    struct image_descriptor descriptor;

    if (sys->lseek(*fd, desc_offset, SEEK_SET) < 0)

    {

        throw errnoException(std::format("Error seeking on file", path));

    }

    auto actualReadSize = sys->read(*fd, &descriptor, sizeof(descriptor));

    if (actualReadSize < 0)

    {

        throw errnoException(std::format("Failed to read from file {}", path));

    }

    if (descriptor.descriptor_magic != DESCRIPTOR_MAGIC ||

        descriptor.descriptor_offset != desc_offset ||

        descriptor.region_count == 0)

    {

        throw errnoException(

            std::format("Invalid descriptor at offset {}", path));

    }

    std::vector<struct image_region> image_regions(descriptor.region_count);

    actualReadSize =

        sys->read(*fd, image_regions.data(),

                  sizeof(struct image_region) * descriptor.region_count);

    if (actualReadSize < 0)

    {

        throw errnoException(std::format("Failed to read from file {}", path));

    }

    // Erase all the static and Write Protected regions of the payload

    for (uint32_t i = 0; i < descriptor.region_count; i++)

    {

        if ((image_regions[i].region_attributes & IMAGE_REGION_STATIC) ||

            (image_regions[i].region_attributes & IMAGE_REGION_WRITE_PROTECTED))

        {

            if (image_regions[i].region_size == 0 ||

                (image_regions[i].region_size % kSectorSizeBytes) != 0)

            {

                throw errnoException(std::format("invalid staging area size"));

            }

            uint32_t regionOffset = image_regions[i].region_offset;

            uint32_t toEraseSize = image_regions[i].region_size;

            while (toEraseSize >= kEraseChunkSizeBytes)

            {

                sendCommand(PAYLOAD_UPDATE_ERASE, regionOffset,

                            kEraseChunkSizeBytes);

                regionOffset += kEraseChunkSizeBytes;

                toEraseSize -= kEraseChunkSizeBytes;

            }

            if (toEraseSize > 0)

            {

                sendCommand(PAYLOAD_UPDATE_ERASE, regionOffset, toEraseSize);

            }

        }

    }

    // Read and send static and WP sections of the payload

    for (uint32_t i = 0; i < descriptor.region_count; i++)

    {

        if ((image_regions[i].region_attributes & IMAGE_REGION_STATIC) ||

            (image_regions[i].region_attributes & IMAGE_REGION_WRITE_PROTECTED))

        {

            uint32_t offset = image_regions[i].region_offset;

            auto regionSize = image_regions[i].region_size;

            size_t readSize = 0;

            std::vector<uint8_t> readBuffer(max_packet_size);

            if (sys->lseek(*fd, offset, SEEK_SET) != offset)

            {

                throw errnoException(

                    std::format("Failed to read file size {}", path));

            }

            do

            {

                if (regionSize <= max_packet_size)

                {

                    readSize = regionSize;

                }

                else

                {

                    readSize = max_packet_size;

                }

                if (!sys->read(*fd, readBuffer.data(), readSize))

                {

                    throw errnoException(

                        std::format("Failed to read from file {}", path));

                }

                // Decided not to use initializer list to create the span here

                // as actualReadSize is ssize_t and we'd need to static_cast

                trimAndSend(std::span<uint8_t>(readBuffer.data(), readSize),

                            offset);

                offset += readSize;

                regionSize -= readSize;

            } while (regionSize); // actualReadSize will be 0 when EOF is

                                  // reached, exit loop

        }

    }

}

void PayloadUpdateImpl::eraseAndSendStaticWP(const std::string& path) const

{

    uint32_t desc_offset = 0;

    if (!findDescriptor(path, &desc_offset))

    {

        throw errnoException(std::format("No valid descriptor found"));

    }

    eraseAndSendStaticWPRegions(path, desc_offset);

}

void PayloadUpdateImpl::read(uint32_t offset, std::span<uint8_t> data) const

{

    std::vector<uint8_t> buf;

    auto rsp = sendCommand(buf, PAYLOAD_UPDATE_READ, offset, data.size());

    if (rsp.size() != data.size())

    {

        stdplus::print(

            stderr,

            "Payload command received a short response from Hoth `{} < {}`\n",

            rsp.size(), data.size());

        throw ResponseFailure();

    }

    memcpy(data.data(), rsp.data(), data.size());

}

void PayloadUpdateImpl::verify() const

{

    payload_update_packet request = {};

    request.type = PAYLOAD_UPDATE_VERIFY_DESCRIPTOR;

    auto buf = hostCmd->sendCommand(

        EC_CMD_BOARD_SPECIFIC_BASE + EC_PRV_CMD_HOTH_PAYLOAD_UPDATE, 0,

        &request, sizeof(request));

    std::span<uint8_t> rsp = buf;

    auto& hdr = stdplus::raw::extractRef<RspHeader>(rsp);

    // In case PAYLOAD_UPDATE_VERIFY is not supported (EC_RES_ERROR),

    // we fall back to PAYLOAD_UPDATE_VERIFY instead.

    if (hdr.result == EC_RES_INVALID_PARAM || hdr.result == EC_RES_ERROR)

    {

        sendCommand(PAYLOAD_UPDATE_VERIFY);

        return;

    }

    if (hdr.result != EC_RES_SUCCESS)

    {

        stdplus::print(stderr, "VERIFY_DESCRIPTOR error: {:#x}\n",

                       static_cast<uint16_t>(hdr.result));

        throw ResponseFailure();

    }

}

payload_update_status PayloadUpdateImpl::getStatus() const

{

    std::vector<uint8_t> buf;

    std::span<const uint8_t> output =

        sendCommand(buf, PAYLOAD_UPDATE_GET_STATUS);

    return stdplus::raw::copyFrom<payload_update_status>(output);

}

void PayloadUpdateImpl::activate(Side side, Persistence persistence) const

{

    ActivateRequest request;

    request.header.offset = 0;

    request.header.len = sizeof(request.activate);

    request.header.type = PAYLOAD_UPDATE_ACTIVATE;

    request.activate.half = static_cast<uint8_t>(side);

    request.activate.make_persistent = static_cast<uint8_t>(persistence);

    sendCommand(

        {reinterpret_cast<const uint8_t*>(&request), sizeof(ActivateRequest)});

}

std::optional<payload_update_confirm_response> PayloadUpdateImpl::confirm(

    enum payload_update_confirm_option option, uint32_t timeout,

    uint64_t confirmation_cookie) const

{

    ConfirmRequest request;

    request.header.offset = 0;

    request.header.len = sizeof(request.confirm);

    request.header.type = PAYLOAD_UPDATE_CONFIRM;

    request.confirm.option = option;

    request.confirm.timeout_value = boost::endian::native_to_little(timeout);

    request.confirm.confirmation_cookie =

        boost::endian::native_to_little(confirmation_cookie);

    std::vector<uint8_t> buf = hostCmd->sendCommand(

        EC_CMD_BOARD_SPECIFIC_BASE + EC_PRV_CMD_HOTH_PAYLOAD_UPDATE, 0,

        &request, sizeof(request));

    // Extract the response header out when returning the span

    std::span<const uint8_t> output = buf;

    auto rsp = stdplus::raw::extract<RspHeader>(output);

    if (rsp.result == HOTH_PAYLOAD_UPDATE_CONFIRM_NO_PENDING_PAYLOAD)

    {

        return std::nullopt;

    }

    if (rsp.result != EC_RES_SUCCESS)

    {

        stdplus::print(

            stderr,

            "Payload confirm command received a bad response from Hoth {:#x}\n",

            static_cast<uint16_t>(rsp.result));

        throw ResponseFailure();

    }

    return stdplus::raw::copyFrom<payload_update_confirm_response>(output);

}

namespace

{

// Helper functions for PayloadUpdateImpl::send

size_t SizeToSkip(std::span<const uint8_t> data)

{

    size_t i;

    for (i = 0; i < data.size(); i++)

    {

        if (data[i] != 0xff)

        {

            break;

        }

    }

    return i;

}

size_t SizeToSend(std::span<const uint8_t> data)

{

    size_t i;

    for (i = data.size(); i > 0; i--)

    {

        if (data[i - 1] != 0xff)

        {

            break;

        }

    }

    return i;

}

} // namespace

void PayloadUpdateImpl::send(const std::string& path) const

{

    Fd fd(sys->open(path.c_str(), O_RDONLY), sys);

    if (*fd < 0)

    {

        (void)fd.release();

        throw errnoException(std::format("Failed to open file {}", path));

    }

    std::array<uint8_t, max_packet_size> readBuffer;

    uint32_t offset = 0;

    ssize_t actualReadSize = 0;

    // Read and send payload until we reach EOF of the given file

    do

    {

        actualReadSize = sys->read(*fd, readBuffer.data(), max_packet_size);

        if (actualReadSize < 0)

        {

            throw errnoException(

                std::format("Failed to read from file {}", path));

        }

        if (actualReadSize > 0)

        {

            // Decided not to use initializer list to create the span here as

            // actualReadSize is ssize_t and we'd need to static_cast

            trimAndSend(std::span<uint8_t>(readBuffer.data(), actualReadSize),

                        offset);

            offset += actualReadSize;

        }

        // actualReadSize will be 0 when EOF is reached, exit loop

    } while (actualReadSize);

}

/* Parse and send the given data after trimming 0xff from the front and back

 * - This works because PayloadUpdateImpl::Initiate erased the

 * EEPROM to 0xff.

 * - This is also more efficient than sending everything, as our

 * image binaries tend to have large sections of 0xff and we can

 * avoid sending those sections.

 */

void PayloadUpdateImpl::trimAndSend(std::span<const uint8_t> data,

                                    uint32_t globalOffset) const

{

    // Allocate the payload buffer at "buffer".

    // "request" will point to the payload_update_packet section of the buffer

    // "request_payload" will point to the beginning of the payload

    // (after the payload_update_packet header).

    std::array<uint8_t, sizeof(payload_update_packet) + max_packet_size> buffer;

    payload_update_packet* request =

        reinterpret_cast<payload_update_packet*>(buffer.data());

    uint8_t* request_payload = &buffer[sizeof(payload_update_packet)];

    const size_t dataSize = data.size();

    if (dataSize > max_packet_size)

    {

        throw errnoException(

            "data to send cannot be bigger than max_packet_size");

    }

    size_t localOffset = SizeToSkip(data);

    if (localOffset >= dataSize)

    {

        // No need to send any payload

        return;

    }

    size_t max_size_to_send = std::min(dataSize - localOffset, max_packet_size);

    size_t size_to_send =

        SizeToSend(data.subspan(localOffset, max_size_to_send));

    // Construct and send payload

    request->offset = globalOffset + localOffset;

    request->len = size_to_send;

    request->type = PAYLOAD_UPDATE_CONTINUE;

    memcpy(request_payload, &data[localOffset], size_to_send);

    sendCommand({buffer.data(), sizeof(*request) + size_to_send});

}

void PayloadUpdateImpl::sendCommand(uint8_t command, uint32_t offset,

                                    uint32_t len) const

{

    std::vector<uint8_t> buf;

    (void)sendCommand(buf, command, offset, len);

}

void PayloadUpdateImpl::sendCommand(std::span<const uint8_t> request) const

{

    std::vector<uint8_t> buf;

    (void)sendCommand(buf, request);

}

[[nodiscard]] std::span<const uint8_t> PayloadUpdateImpl::sendCommand(

    std::vector<uint8_t>& buf, uint8_t command, uint32_t offset,

    uint32_t len) const

{

    // For most basic commands, request offset and length are zero

    payload_update_packet request;

    request.offset = offset;

    request.len = len;

    request.type = command;

    return sendCommand(buf, {reinterpret_cast<const uint8_t*>(&request),

                             sizeof(payload_update_packet)});

}

[[nodiscard]] std::span<const uint8_t> PayloadUpdateImpl::sendCommand(

    std::vector<uint8_t>& buf, std::span<const uint8_t> request) const

{

    buf = hostCmd->sendCommand(

        EC_CMD_BOARD_SPECIFIC_BASE + EC_PRV_CMD_HOTH_PAYLOAD_UPDATE, 0,

        request.data(), request.size());

    // Extract the response header out when returning the span

    std::span<const uint8_t> output = buf;

    auto rsp = stdplus::raw::extract<RspHeader>(output);

    if (rsp.result != EC_RES_SUCCESS)

    {

        stdplus::print(

            stderr, "Payload command received a bad response from Hoth {:#x}\n",

            static_cast<uint16_t>(rsp.result));

        throw ResponseFailure();

    }

    return output;

}

} // namespace internal

} // namespace hoth

} // namespace google