BasicStream.h

Go to the documentation of this file.

/****
 * Sming Framework Project - Open Source framework for high efficiency native ESP8266 development.
 * Created 2017 by Slavey Karadzhov
 * http://github.com/SmingHub/Sming
 * All files of the Sming Core are provided under the LGPL v3 license.
 *
 * BasicOtaUpgradeStream.h
 *
 ****/

#pragma once

#include <Data/Stream/ReadWriteStream.h>
#include <rboot-api.h>
#include "FileFormat.h"
#ifdef ENABLE_OTA_SIGNING
#include "SignatureVerifier.h"
#else
#include "ChecksumVerifier.h"
#endif

namespace OtaUpgrade
{
class BasicStream : public ReadWriteStream
{
public:
    BasicStream();

    enum class Error {
        None,             
        InvalidFormat,  
        UnsupportedData,  
        DecryptionFailed, 
        NoRomFound,  
        RomTooLarge, 
        DowngradeNotAllowed, 
        VerificationFailed,  
        FlashWriteFailed,   
        RomActivationFailed, 
        OutOfMemory,         
        Internal,            
    };

    Error errorCode = Error::None; 

    static String errorToString(Error code) SMING_DEPRECATED;

    size_t write(const uint8_t* data, size_t size) override;

    bool hasError() const
    {
        return (state == State::Error);
    }

    // overrides from IDataSourceStream
    uint16_t readMemoryBlock(char* data, int bufSize) override
    {
        return 0;
    }
    virtual int available() override
    {
        return 0;
    }
    bool isFinished() override
    {
        return true;
    }

protected:
    void setError(Error ec);

private:
    struct Slot {
        Slot();

        uint32_t address;
        uint32_t size;
        uint8_t index;
        bool updated{false};
    };
    Slot slot;

    // Instead of RbootOutputStream, the rboot write API is used directly because in a future extension the OTA file may contain data for multiple FLASH regions.
    rboot_write_status rbootWriteStatus{};

    enum class State {
        Error,
        Header,
        RomHeader,
        SkipRom,
        WriteRom,
        VerifyRoms,
        RomsComplete,
    };
    State state{State::Header};

#ifdef ENABLE_OTA_SIGNING
    using Verifier = SignatureVerifier;
    static const uint32_t expectedHeaderMagic{OTA_HEADER_MAGIC_SIGNED};
#else
    using Verifier = ChecksumVerifier;
    static const uint32_t expectedHeaderMagic{OTA_HEADER_MAGIC_NOT_SIGNED};
#endif
    Verifier verifier;

    OtaFileHeader fileHeader;
    OtaRomHeader romHeader;

    Verifier::VerificationData verificationData;

    size_t remainingBytes{0};
    uint8_t* destinationPtr{nullptr};
    uint8_t romIndex{0};

    void setupChunk(State nextState, size_t size, void* destination = nullptr)
    {
        state = nextState;
        remainingBytes = size;
        destinationPtr = reinterpret_cast<uint8_t*>(destination);
    }
    template <typename T> void setupChunk(State nextState, T& destination)
    {
        setupChunk(nextState, sizeof(T), &destination);
    }

    bool consume(const uint8_t*& data, size_t& size);

    void nextRom();
    void processRomHeader();
    void verifyRoms();
};

} // namespace OtaUpgrade

String toString(OtaUpgrade::BasicStream::Error code);