ipc_varg

// vi:set ft=cpp: -*- Mode: C++ -*-
/*
 * (c) 2014 Alexander Warg <alexander.warg@kernkonzept.com>
 *
 * License: see LICENSE.spdx (in this directory or the directories above)
 */
#pragma once
#pragma GCC system_header
 
#include "types"
#include "ipc_basics"
 
namespace L4 { namespace Ipc L4_EXPORT {
 
template< typename T, template <typename X> class B >
struct Generic_va_type : B<T>
{
  enum { Id = B<T>::Id };
  using ID = B<T>;
  using Ret_value = T const &;
  using Value = T;
 
  static Ret_value value(void const *d)
  { return *reinterpret_cast<Value const *>(d); }
 
  static void const *addr_of(Value const &v) { return &v; }
 
  static unsigned size(void const *) { return sizeof(T); }
 
  static L4_varg_type unsigned_id()
  {
    return static_cast<L4_varg_type>(Id & ~L4_VARG_TYPE_SIGN);
  }
 
  static L4_varg_type signed_id()
  {
    return static_cast<L4_varg_type>(Id | L4_VARG_TYPE_SIGN);
  }
 
  static L4_varg_type id()
  {
    return static_cast<L4_varg_type>(Id);
  }
};
 
template< typename T > struct Va_type_id;
template<> struct Va_type_id<l4_umword_t>  { enum { Id = L4_VARG_TYPE_UMWORD }; };
template<> struct Va_type_id<l4_mword_t>   { enum { Id = L4_VARG_TYPE_MWORD }; };
template<> struct Va_type_id<l4_fpage_t>   { enum { Id = L4_VARG_TYPE_FPAGE }; };
template<> struct Va_type_id<void>         { enum { Id = L4_VARG_TYPE_NIL }; };
template<> struct Va_type_id<char const *> { enum { Id = L4_VARG_TYPE_STRING }; };
 
template< typename T > struct Va_type;
 
template<> struct Va_type<l4_umword_t> : Generic_va_type<l4_umword_t, Va_type_id> {};
template<> struct Va_type<l4_mword_t> : Generic_va_type<l4_mword_t, Va_type_id> {};
template<> struct Va_type<l4_fpage_t> : Generic_va_type<l4_fpage_t, Va_type_id> {};
 
template<> struct Va_type<void>
{
  using Ret_value = void;
  using Value = void;
 
  static void const *addr_of(void) { return 0; }
 
  static void value(void const *) {}
  static L4_varg_type id() { return L4_VARG_TYPE_NIL; }
  static unsigned size(void const *) { return 0; }
};
 
template<> struct Va_type<char const *>
{
  using Ret_value = char const *;
  using Value = char const *;
 
  static void const *addr_of(Value v) { return v; }
 
  static L4_varg_type id() { return L4_VARG_TYPE_STRING; }
  static unsigned size(void const *s)
  {
    char const *_s = reinterpret_cast<char const *>(s);
    int l = 1;
    while (*_s)
      {
        ++_s; ++l;
      }
    return l;
  }
 
  static Ret_value value(void const *d) { return static_cast<char const *>(d); }
};

class Varg
{
public:
  using Tag = l4_umword_t;
 
private:
  enum { Direct_data = 0x8000 };
  Tag _tag;
  char const *_d;
 
public:
  L4_varg_type type() const { return static_cast<L4_varg_type>(_tag & 0xff); }
  unsigned length() const { return _tag >> 16; }
  Tag tag() const { return _tag & ~static_cast<Tag>(Direct_data); }
  void tag(Tag tag)
  {
    // Direct_data bit is not part of the write format. Make sure it cannot be
    // set by a remote sender. Otherwise we would mistakenly treat the _d
    // pointer as direct data.
    _tag = tag & ~static_cast<Tag>(Direct_data);
  }

  void data(char const *d) { _d = d; }

  char const *data() const
  {
    if (_tag & Direct_data)
      {
        union T { char const *d; char v[sizeof(char const *)]; };
        return reinterpret_cast<T const *>(&_d)->v;
      }
    return _d;
  }

#if __cplusplus >= 201103L
  Varg() = default;
#else
  Varg() {}
#endif

  Varg(L4_varg_type t, void const *v, int len)
  : _tag(t | (static_cast<l4_mword_t>(len) << 16)),
    _d(static_cast<char const *>(v))
  {}
 
  static Varg nil() { return Varg(L4_VARG_TYPE_NIL, 0, 0); }

  template< typename V >
  typename Va_type<V>::Ret_value value() const
  {
    if (_tag & Direct_data)
      {
        union X { char const *d; V v; };
        return reinterpret_cast<X const &>(_d).v;
      }
 
    return Va_type<V>::value(_d);
  }
 

  template< typename T >
  bool is_of() const { return Va_type<T>::id() == type(); }

  bool is_nil() const { return is_of<void>(); }

  bool is_of_int() const
  { return (type() & ~L4_VARG_TYPE_SIGN) == L4_VARG_TYPE_UMWORD; }

  template< typename T >
  bool get_value(typename Va_type<T>::Value *v) const
  {
    if (!is_of<T>())
      return false;
 
    *v = this->value<T>();
    return true;
  }

  template< typename T >
  void set_value(void const *d)
  {
    using Vt = Va_type<T>;
    _tag = Vt::id() | (Vt::size(d) << 16);
    _d = static_cast<char const *>(d);
  }

  template<typename T>
  void set_direct_value(T val, L4::Types::Enable_if_t<sizeof(T) <= sizeof(char const *), bool> = true)
  {
    static_assert(sizeof(T) <= sizeof(char const *), "direct Varg value too big");
    using Vt = Va_type<T>;
    _tag = Vt::id() | (sizeof(T) << 16) | Direct_data;
    union X { char const *d; T v; };
    reinterpret_cast<X &>(_d).v = val;
  }

  template<typename T> explicit
  Varg(T const *data) { set_value<T>(data); }
  Varg(char const *data) { set_value<char const *>(data); }

  template<typename T> explicit
  Varg(T data, L4::Types::Enable_if_t<sizeof(T) <= sizeof(char const *), bool> = true)
  { set_direct_value<T>(data); }
};
 
 
template<typename T>
class Varg_t : public Varg
{
public:
  using Value = typename Va_type<T>::Value;
  explicit Varg_t(Value v) : Varg()
  { _data = v; set_value<T>(Va_type<T>::addr_of(_data)); }
 
private:
  Value _data;
};
 
template<unsigned MAX = L4_UTCB_GENERIC_DATA_SIZE>
class Varg_list;

class Varg_list_ref
{
private:
  template<unsigned T>
  friend class Varg_list;

  class Iter_state
  {
  private:
    using M = l4_umword_t; 
    using Mp = M const *;  
    Mp _c; 
    Mp _e; 

    Mp next_arg(Varg const &a) const
    {
      return _c + 1 + (Msg::align_to<M>(a.length()) / sizeof(M));
    }
 
  public:
    Iter_state() : _c(nullptr), _e(nullptr) {}

    Iter_state(Mp c, Mp e) : _c(c), _e(e)
    {}

    bool valid() const
    { return _c && _c < _e; }

    Mp begin() const { return _c; }

    Mp end() const { return _e; }

    Varg pop()
    {
      if (!valid())
        return Varg::nil();
 
      Varg a;
      a.tag(_c[0]);
      a.data(reinterpret_cast<char const *>(&_c[1]));
      _c = next_arg(a);
      if (_c > _e)
        return Varg::nil();
 
      return a;
    }

    bool operator == (Iter_state const &o) const
    { return _c == o._c; }

    bool operator != (Iter_state const &o) const
    { return _c != o._c; }
  };
 
  Iter_state _s; 
 
public:
  Varg_list_ref() = default;

  Varg_list_ref(void const *start, void const *end)
  : _s(reinterpret_cast<l4_umword_t const *>(start),
       reinterpret_cast<l4_umword_t const *>(end))
  {}

  class Iterator
  {
  private:
    Iter_state _s; 
    Varg _a; 
 
  public:
    Iterator(Iter_state const &s)
    : _s(s)
    {
      _a = _s.pop();
    }

    explicit operator bool () const
    { return !_a.is_nil(); }

    Iterator &operator ++ ()
    {
      if (!_a.is_nil())
        _a = _s.pop();
 
      return *this;
    }

    Varg operator * () const
    { return _a; }

    bool equals(Iterator const &o) const
    {
      if (_a.is_nil() && o._a.is_nil())
        return true;
 
      return _s ==  o._s;
    }
 
    bool operator == (Iterator const &o) const
    { return equals(o); }
 
    bool operator != (Iterator const &o) const
    { return !equals(o); }
  };

  Varg pop_front()
  { return _s.pop(); }

  Varg next()
    L4_DEPRECATED("Use range for or pop_front.")
  { return _s.pop(); }

  Iterator begin() const
  { return Iterator(_s); }

  Iterator end() const
  { return Iterator(Iter_state()); }
};

template<unsigned MAX>
class Varg_list : public Varg_list_ref
{
  l4_umword_t data[MAX];
  Varg_list(Varg_list const &);
 
public:
  Varg_list(Varg_list_ref const &r)
  {
    if (!r._s.valid())
      return;
 
    l4_umword_t const *rs = r._s.begin();
    unsigned c = r._s.end() - rs;
 
    // The list comes from a message, so its length is up to the sender.
    if (c > MAX)
      c = MAX;
 
    for (unsigned i = 0; i < c; ++i)
      data[i] = rs[i];
 
    this->_s = Iter_state(data, data + c);
  }
};
 
 
namespace Msg {
template<> struct Elem<Varg const *>
{
  using arg_type = Varg const *;
  using svr_type = Varg_list_ref;
  using svr_arg_type = Varg_list_ref;
  static constexpr bool Is_optional = false;
  static constexpr bool Is_input = true;
  static constexpr bool Is_output = false;
};
 
template<> struct Is_valid_rpc_type<Varg> : L4::Types::False {};
template<> struct Is_valid_rpc_type<Varg *> : L4::Types::False {};
template<> struct Is_valid_rpc_type<Varg &> : L4::Types::False {};
template<> struct Is_valid_rpc_type<Varg const &> : L4::Types::False {};
 
template<>
struct Clnt_val_ops<Varg> :
  Clnt_noops<Varg const &>
{
  static int to_msg_data(char *msg, unsigned offs, unsigned limit,
                         Varg const &a)
  {
    for (Varg const *i = &a; i->tag(); ++i)
      {
        offs = align_to<l4_umword_t>(offs);
        if (L4_UNLIKELY(!check_size<l4_umword_t>(offs, limit)))
          return -L4_EMSGTOOLONG;
        *reinterpret_cast<l4_umword_t*>(msg + offs) = i->tag();
        offs += sizeof(l4_umword_t);
        if (L4_UNLIKELY(!check_size<char>(offs, limit, i->length())))
          return -L4_EMSGTOOLONG;
        char const *d = i->data();
        for (unsigned x = 0; x < i->length(); ++x)
          msg[offs++] = *d++;
      }
 
    return offs;
  }
};
 
template<>
struct Svr_val_ops<Varg_list_ref> :
  Svr_noops<Varg_list_ref>
{
  static int to_svr_data(char *msg, unsigned offset, unsigned limit,
                         Varg_list_ref &a)
  {
    unsigned start = align_to<l4_umword_t>(offset);
    unsigned offs;
    for (offs = start; offs < limit;)
      {
        unsigned noffs = align_to<l4_umword_t>(offs);
        if (L4_UNLIKELY(!check_size<l4_umword_t>(noffs, limit)))
          break;
 
        offs = noffs;
        Varg arg;
        arg.tag(*reinterpret_cast<l4_umword_t*>(msg + offs));
 
        if (!arg.tag())
          break;
 
        offs += sizeof(l4_umword_t);
 
        if (L4_UNLIKELY(!check_size<char>(offs, limit, arg.length())))
          return -L4_EMSGTOOLONG;
        offs += arg.length();
      }
 
    a = Varg_list_ref(msg + start, msg + align_to<l4_umword_t>(offs));
    return offs;
  }
};
}
}}