Serializer.h

//------------------------------------------------------------------------------
/*
    This file is part of rippled: https://github.com/ripple/rippled
    Copyright (c) 2012, 2013 Ripple Labs Inc.
 
    Permission to use, copy, modify, and/or distribute this software for any
    purpose  with  or without fee is hereby granted, provided that the above
    copyright notice and this permission notice appear in all copies.
 
    THE  SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
    WITH  REGARD  TO  THIS  SOFTWARE  INCLUDING  ALL  IMPLIED  WARRANTIES  OF
    MERCHANTABILITY  AND  FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
    ANY  SPECIAL ,  DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
    WHATSOEVER  RESULTING  FROM  LOSS  OF USE, DATA OR PROFITS, WHETHER IN AN
    ACTION  OF  CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
//==============================================================================
 
#ifndef RIPPLE_PROTOCOL_SERIALIZER_H_INCLUDED
#define RIPPLE_PROTOCOL_SERIALIZER_H_INCLUDED
 
#include <ripple/basics/Blob.h>
#include <ripple/basics/Buffer.h>
#include <ripple/basics/Slice.h>
#include <ripple/basics/base_uint.h>
#include <ripple/basics/contract.h>
#include <ripple/basics/safe_cast.h>
#include <ripple/beast/crypto/secure_erase.h>
#include <ripple/protocol/HashPrefix.h>
#include <ripple/protocol/SField.h>
#include <cassert>
#include <cstdint>
#include <cstring>
#include <iomanip>
#include <sstream>
#include <type_traits>
 
namespace ripple {
 
class CKey;  // forward declaration
 
class Serializer
{
private:
    // DEPRECATED
    Blob mData;
 
public:
    explicit Serializer(int n = 256)
    {
        mData.reserve(n);
    }
 
    Serializer(void const* data, std::size_t size)
    {
        mData.resize(size);
 
        if (size)
        {
            assert(data != nullptr);
            std::memcpy(mData.data(), data, size);
        }
    }
 
    Slice
    slice() const noexcept
    {
        return Slice(mData.data(), mData.size());
    }
 
    std::size_t
    size() const noexcept
    {
        return mData.size();
    }
 
    void const*
    data() const noexcept
    {
        return mData.data();
    }
 
    // assemble functions
    int
    add8(unsigned char byte);
    int add16(std::uint16_t);
    int add32(std::uint32_t);  // ledger indexes, account sequence, timestamps
    int add32(HashPrefix);
    int add64(std::uint64_t);  // native currency amounts
    int
    add128(const uint128&);  // private key generators
    int
    add256(uint256 const&);  // transaction and ledger hashes
 
    template <typename Integer>
    int addInteger(Integer);
 
    template <int Bits, class Tag>
    int
    addBitString(base_uint<Bits, Tag> const& v)
    {
        int ret = mData.size();
        mData.insert(mData.end(), v.begin(), v.end());
        return ret;
    }
 
    // TODO(tom): merge with add128 and add256.
    template <class Tag>
    int
    add160(base_uint<160, Tag> const& i)
    {
        return addBitString<160, Tag>(i);
    }
 
    int
    addRaw(Blob const& vector);
    int
    addRaw(const void* ptr, int len);
    int
    addRaw(const Serializer& s);
    int
    addZeros(size_t uBytes);
 
    int
    addVL(Blob const& vector);
    int
    addVL(Slice const& slice);
    template <class Iter>
    int
    addVL(Iter begin, Iter end, int len);
    int
    addVL(const void* ptr, int len);
 
    // disassemble functions
    bool
    get8(int&, int offset) const;
    bool
    get256(uint256&, int offset) const;
 
    template <typename Integer>
    bool
    getInteger(Integer& number, int offset)
    {
        static const auto bytes = sizeof(Integer);
        if ((offset + bytes) > mData.size())
            return false;
        number = 0;
 
        auto ptr = &mData[offset];
        for (auto i = 0; i < bytes; ++i)
        {
            if (i)
                number <<= 8;
            number |= *ptr++;
        }
        return true;
    }
 
    template <int Bits, typename Tag = void>
    bool
    getBitString(base_uint<Bits, Tag>& data, int offset) const
    {
        auto success = (offset + (Bits / 8)) <= mData.size();
        if (success)
            memcpy(data.begin(), &(mData.front()) + offset, (Bits / 8));
        return success;
    }
 
    // TODO(tom): merge with get128 and get256.
    template <class Tag>
    bool
    get160(base_uint<160, Tag>& o, int offset) const
    {
        return getBitString<160, Tag>(o, offset);
    }
 
    bool
    getRaw(Blob&, int offset, int length) const;
    Blob
    getRaw(int offset, int length) const;
 
    bool
    getVL(Blob& objectVL, int offset, int& length) const;
    bool
    getVLLength(int& length, int offset) const;
 
    int
    addFieldID(int type, int name);
    int
    addFieldID(SerializedTypeID type, int name)
    {
        return addFieldID(safe_cast<int>(type), name);
    }
 
    // DEPRECATED
    uint256
    getSHA512Half() const;
 
    // totality functions
    Blob const&
    peekData() const
    {
        return mData;
    }
    Blob
    getData() const
    {
        return mData;
    }
    Blob&
    modData()
    {
        return mData;
    }
 
    int
    getDataLength() const
    {
        return mData.size();
    }
    const void*
    getDataPtr() const
    {
        return mData.data();
    }
    void*
    getDataPtr()
    {
        return mData.data();
    }
    int
    getLength() const
    {
        return mData.size();
    }
    std::string
    getString() const
    {
        return std::string(static_cast<const char*>(getDataPtr()), size());
    }
    void
    secureErase()
    {
        beast::secure_erase(mData.data(), mData.size());
        mData.clear();
    }
    void
    erase()
    {
        mData.clear();
    }
    bool
    chop(int num);
 
    // vector-like functions
    Blob ::iterator
    begin()
    {
        return mData.begin();
    }
    Blob ::iterator
    end()
    {
        return mData.end();
    }
    Blob ::const_iterator
    begin() const
    {
        return mData.begin();
    }
    Blob ::const_iterator
    end() const
    {
        return mData.end();
    }
    void
    reserve(size_t n)
    {
        mData.reserve(n);
    }
    void
    resize(size_t n)
    {
        mData.resize(n);
    }
    size_t
    capacity() const
    {
        return mData.capacity();
    }
 
    bool
    operator==(Blob const& v)
    {
        return v == mData;
    }
    bool
    operator!=(Blob const& v)
    {
        return v != mData;
    }
    bool
    operator==(const Serializer& v)
    {
        return v.mData == mData;
    }
    bool
    operator!=(const Serializer& v)
    {
        return v.mData != mData;
    }
 
    std::string
    getHex() const
    {
        std::stringstream h;
 
        for (unsigned char const& element : mData)
        {
            h << std::setw(2) << std::hex << std::setfill('0')
              << safe_cast<unsigned int>(element);
        }
        return h.str();
    }
 
    static int
    decodeLengthLength(int b1);
    static int
    decodeVLLength(int b1);
    static int
    decodeVLLength(int b1, int b2);
    static int
    decodeVLLength(int b1, int b2, int b3);
 
private:
    static int
    lengthVL(int length)
    {
        return length + encodeLengthLength(length);
    }
    static int
    encodeLengthLength(int length);  // length to encode length
    int
    addEncoded(int length);
};
 
template <class Iter>
int
Serializer::addVL(Iter begin, Iter end, int len)
{
    int ret = addEncoded(len);
    for (; begin != end; ++begin)
    {
        addRaw(begin->data(), begin->size());
#ifndef NDEBUG
        len -= begin->size();
#endif
    }
    assert(len == 0);
    return ret;
}
 
//------------------------------------------------------------------------------
 
// DEPRECATED
// Transitional adapter to new serialization interfaces
class SerialIter
{
private:
    std::uint8_t const* p_;
    std::size_t remain_;
    std::size_t used_ = 0;
 
public:
    SerialIter(void const* data, std::size_t size) noexcept;
 
    SerialIter(Slice const& slice) : SerialIter(slice.data(), slice.size())
    {
    }
 
    // Infer the size of the data based on the size of the passed array.
    template <int N>
    explicit SerialIter(std::uint8_t const (&data)[N]) : SerialIter(&data[0], N)
    {
        static_assert(N > 0, "");
    }
 
    std::size_t
    empty() const noexcept
    {
        return remain_ == 0;
    }
 
    void
    reset() noexcept;
 
    int
    getBytesLeft() const noexcept
    {
        return static_cast<int>(remain_);
    }
 
    // get functions throw on error
    unsigned char
    get8();
 
    std::uint16_t
    get16();
 
    std::uint32_t
    get32();
 
    std::uint64_t
    get64();
 
    template <int Bits, class Tag = void>
    base_uint<Bits, Tag>
    getBitString();
 
    uint128
    get128()
    {
        return getBitString<128>();
    }
 
    uint160
    get160()
    {
        return getBitString<160>();
    }
 
    uint256
    get256()
    {
        return getBitString<256>();
    }
 
    void
    getFieldID(int& type, int& name);
 
    // Returns the size of the VL if the
    // next object is a VL. Advances the iterator
    // to the beginning of the VL.
    int
    getVLDataLength();
 
    Slice
    getSlice(std::size_t bytes);
 
    // VFALCO DEPRECATED Returns a copy
    Blob
    getRaw(int size);
 
    // VFALCO DEPRECATED Returns a copy
    Blob
    getVL();
 
    void
    skip(int num);
 
    Buffer
    getVLBuffer();
 
    template <class T>
    T
    getRawHelper(int size);
};
 
template <int Bits, class Tag>
base_uint<Bits, Tag>
SerialIter::getBitString()
{
    base_uint<Bits, Tag> u;
    auto const n = Bits / 8;
    if (remain_ < n)
        Throw<std::runtime_error>("invalid SerialIter getBitString");
    std::memcpy(u.begin(), p_, n);
    p_ += n;
    used_ += n;
    remain_ -= n;
    return u;
}
 
}  // namespace ripple
 
#endif