simdjson/fuzz/FuzzUtils.h

#ifndef SIMDJSON_FUZZUTILS_H
#define SIMDJSON_FUZZUTILS_H

#include <cstdint>
#include <vector>
#include <string_view>
#include <cstring> //memcpy

// view data as a byte pointer
template <typename T> inline const std::uint8_t* as_bytes(const T* data) {
  return static_cast<const std::uint8_t*>(static_cast<const void*>(data));
}

// view data as a char pointer
template <typename T> inline const char* as_chars(const T* data) {
  return static_cast<const char*>(static_cast<const void*>(data));
}


// Splits the input into strings, using a four byte separator which is human
// readable. Makes for nicer debugging of fuzz data.
// See https://github.com/google/fuzzing/blob/master/docs/split-inputs.md#magic-separator
// for background. Note: don't use memmem, it is not standard C++.
inline std::vector<std::string_view> split(const char* Data, size_t Size) {

  std::vector<std::string_view> ret;

    using namespace std::literals;
    constexpr auto sep="\n~~\n"sv;

    std::string_view all(Data,Size);
    auto pos=all.find(sep);
    while(pos!=std::string_view::npos) {
      ret.push_back(all.substr(0,pos));
      all=all.substr(pos+sep.size());
      pos=all.find(sep);
    }
    ret.push_back(all);
    return ret;
}

// Generic helper to split fuzz data into usable parts, like ints etc.
// Note that it does not throw, instead it sets the data pointer to null
// if the input is exhausted.
struct FuzzData {
  // data may not be null, even if size is zero.
  FuzzData(const uint8_t* data,
           size_t size) : Data(data),Size(size){}

  ///range is inclusive
  template<int Min, int Max>
  int getInt() {
    static_assert (Min<Max,"min must be <max");

    // make this constexpr, can't overflow because that is UB and is forbidden
    // in constexpr evaluation
    constexpr int range=(Max-Min)+1;
    constexpr unsigned int urange=range;

    // don't use std::uniform_int_distribution, we don't want to pay for
    // over consumption of random data. Accept the slightly non-uniform distribution.
    if(range<256)
      return Min+static_cast<int>(get<uint8_t>()%urange);
    if(range<65536)
      return Min+static_cast<int>(get<uint16_t>()%urange);

    return Min+static_cast<int>(get<uint32_t>()%urange);
  }

  template<typename T>
  T get() {
    const auto Nbytes=sizeof(T);
    T ret{};
    if(Size<Nbytes) {
      //don't throw, signal with null instead.
      Data=nullptr;
      Size=0;
      return ret;
    }
    std::memcpy(&ret,Data,Nbytes);
    Data+=Nbytes;
    Size-=Nbytes;
    return ret;
  }

  // gets a string view with length in [Min,Max]
  template<int Min, int Max>
  std::string_view get_stringview() {
    static_assert (Min>=0,"Min must be positive");
    const int len=getInt<Min,Max>();
    const unsigned int ulen=static_cast<unsigned int>(len);
    if(ulen<Size) {
      std::string_view ret(chardata(),ulen);
      Data+=len;
      Size-=ulen;
      return ret;
    }

    //mark that there is too little data to fulfill the request
    Data=nullptr;
    Size=0;

    return {};
  }

  // consumes the rest of the data as a string view
  std::string_view remainder_as_stringview() {
    std::string_view ret{chardata(),Size};
    Data+=Size;
    Size=0;
    return ret;
  }

  // split the remainder of the data into string views,
  std::vector<std::string_view> splitIntoStrings() {
    std::vector<std::string_view> ret;
    if(Size>0) {
      ret=split(chardata(),Size);
      // all data consumed.
      Data+=Size;
      Size=0;
    }
    return ret;
  }

  //are we good?
  explicit operator bool() const { return Data!=nullptr;}

  //we are a URBG
  // https://en.cppreference.com/w/cpp/named_req/UniformRandomBitGenerator
  //The type G satisfies UniformRandomBitGenerator if    Given
  //   T, the type named by G::result_type
  //    g, a value of type G
  //
  //  The following expressions must be valid and have their specified effects
  //  Expression 	Return type 	Requirements
  //  G::result_type 	T 	T is an unsigned integer type
  using result_type=uint8_t;
  //  G::min() 	T 	Returns the smallest value that G's operator() may return. The value is strictly less than G::max(). The function must be constexpr.
  static constexpr result_type min() {return 0;}
  //  G::max() 	T 	Returns the largest value that G's operator() may return. The value is strictly greater than G::min(). The function must be constexpr.
  static constexpr result_type max() {return 255;}
  //  g() 	T 	Returns a value in the closed interval [G::min(), G::max()]. Has amortized constant complexity.
  result_type operator()() {
    if(Size==0) {
      // return something varying, otherwise uniform_int_distribution may get
      // stuck
      return failcount++;
    }
    const result_type ret=Data[0];
    Data++;
    Size--;
    return ret;
  }
  // returns a pointer to data as const char* to avoid those cstyle casts
  const char* chardata() const {return static_cast<const char*>(static_cast<const void*>(Data));}
  // members
  const uint8_t* Data;
  size_t Size;
  uint8_t failcount=0;
};


#endif // SIMDJSON_FUZZUTILS_H