--- /dev/null
+#pragma once
+/******************************************************************************
+*
+* Copyright (c) 2019 AT&T Intellectual Property.
+* Copyright (c) 2018-2019 Nokia.
+*
+* 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.
+*
+******************************************************************************/
+
+// Standard Includes: ANSI C/C++, MSA, and Third-Party Libraries
+
+// Local Includes: Application specific classes, functions, and libraries
+#include "asn/elements.hpp"
+#include "asn/ber/common.hpp"
+#include "asn/ber/context.hpp"
+#include "asn/ber/tag.hpp"
+#include "asn/ber/length.hpp"
+#include "asn/ber/visitor.hpp"
+#include "asn/ber/opentype.hpp"
+
+namespace asn {
+namespace ber {
+
+/********************************************************************************
+pack (X.690)
+*********************************************************************************/
+template <class IE>
+bool pack(IE const& ie, EncoderCtx& ctx)
+{
+ ctx.refErrorCtx().reset();
+ Element<IE>::run(ie, ctx);
+
+ if (ctx)
+ Tools::bit_accessor::padByte(ctx.refBuffer());
+
+ return static_cast<bool>(ctx);
+}
+/********************************************************************************
+unpack (X.690)
+*********************************************************************************/
+template <class IE>
+bool unpack(IE& ie, DecoderCtx& ctx)
+{
+ Element<IE>::run(ie, ctx);
+
+ if (ctx)
+ Tools::bit_accessor::padByte(ctx.refBuffer());
+
+ if(ctx && ctx.refBuffer().getBytesLeft())
+ {
+ ctx.ie_name(IE::name());
+ ctx.refErrorCtx().lengthErrorBytes(ctx.refBuffer().getBytesLeft(), 0);
+ }
+
+ return static_cast<bool>(ctx);
+}
+
+/***************************************************************************************
+* ElementType
+***************************************************************************************/
+template <class IE, class Enabler = void>
+struct ElementType;
+
+/***************************************************************************************
+* ExplicitCodec: Codec for elements with EXPLICIT tag
+***************************************************************************************/
+template <class IE>
+struct ExplicitCodec
+{
+ using tag_t = Tag<IE, true>;
+ static bool inline is_matched(tag_value_t _tag) {return _tag == tag_t::value();}
+
+ static void inline run(IE const& ie, EncoderCtx& ctx)
+ {
+ auto & buffer = ctx.refBuffer();
+
+ tag_t::encode(ctx);
+ u8* len_ptr = buffer.advance(1); //reserve for the length
+
+ Element<typename IE::parent_t>::run(static_cast<typename IE::parent_t const&>(ie), ctx);
+
+ size_t len = buffer.begin() - len_ptr - 1;
+ if(len > 127)
+ {
+ len_ptr[0] = 0x80; //undefinite length form per X.690 8.1.3.6
+ uint8_t buff[2] = {0}; // end-of-contents octets (X.690 8.1.5)
+ buffer.putBytes(buff, sizeof(buff));
+ }
+ else
+ {
+ len_ptr[0] = static_cast<u8>(len); //one byte form per X.690 8.1.3.4
+ }
+ }
+
+ static void inline run(IE& ie, DecoderCtx& ctx, tag_value_t tag)
+ {
+ if(tag_t::value() != tag)
+ ctx.refErrorCtx().tagError(static_cast<uint32_t>(tag));
+ else
+ {
+ auto & buffer = ctx.refBuffer();
+ size_t length = Length::decode(ctx);
+
+ ASN_DECODER_TRACE("EX<tag=0x%x length=%zu> buffer: %s", static_cast<int>(tag), length, ctx.refBuffer().toString());
+
+ if(length == indefinite_length)
+ {
+ Element<typename IE::parent_t>::run(static_cast<typename IE::parent_t&>(ie), ctx);
+
+ if(ctx)
+ {
+ uint8_t const* data_in = ctx.refBuffer().getBytes(2);
+ if(data_in && (data_in[0] || data_in[1]))
+ {
+ ctx.refErrorCtx().errorWrongEndOfContent();
+ }
+ }
+ }
+ else
+ {
+ if (buffer.getBytesLeft() < length)
+ {
+ ctx.refErrorCtx().lengthErrorBytes(buffer.getBytesLeft(), length);
+ }
+ else
+ {
+ DecoderCtx::buf_type::pointer end = buffer.end();
+ buffer.set_end(buffer.begin() + length);
+
+ Element<typename IE::parent_t>::run(static_cast<typename IE::parent_t&>(ie), ctx);
+
+ buffer.set_end(end);
+ }
+ }
+
+ }
+ }
+};
+
+/***************************************************************************************
+* BOOLEAN: Encoding the boolean type (X.690 8.2)
+***************************************************************************************/
+template <class IE>
+struct ElementType<IE, std::enable_if_t<IE::ie_type == element_type::T_BOOLEAN> >
+{
+ using tag_t = Tag<IE, false>;
+
+ static bool inline is_matched(tag_value_t tag) {return tag == tag_t::value();}
+
+ static void inline run(IE const& ie, EncoderCtx& ctx)
+ {
+ tag_t::encode(ctx);
+ Length::encode(1, ctx);
+ if(ie.get())
+ Tools::put_bytes(0xFF, 1, ctx);
+ else
+ Tools::put_bytes(0, 1, ctx);
+ }
+
+ static void inline run(IE& ie, DecoderCtx& ctx, tag_value_t tag)
+ {
+ if(tag_t::value() != tag)
+ ctx.refErrorCtx().tagError(static_cast<uint32_t>(tag));
+ else
+ {
+ size_t length = Length::decode(ctx);
+ if(length != 1)
+ {
+ ctx.refErrorCtx().sizeRangeError(length, 1, 1);
+ }
+ else
+ {
+ ASN_DECODER_TRACE("IE<type=%d name=%s tag=0x%x length=%zu> buffer: %s", static_cast<int>(IE::ie_type), IE::name(), static_cast<int>(tag), length, ctx.refBuffer().toString());
+ uint8_t value;
+ Tools::get_bytes(value, 1, ctx);
+ ie.set(value > 0);
+ }
+ }
+ }
+};
+/***************************************************************************************
+* INTEGER: Encoding the integer type (X.690 8.3)
+***************************************************************************************/
+template <class IE>
+struct ElementType<IE, std::enable_if_t<IE::ie_type == element_type::T_INTEGER> >
+{
+ using tag_t = Tag<IE, false>;
+
+ static bool inline is_matched(tag_value_t tag) {return tag == tag_t::value();}
+
+ static void inline run(IE const& ie, EncoderCtx& ctx)
+ {
+ tag_t::encode(ctx);
+ size_t length = Length::get(ie.get());
+ Length::encode(length, ctx);
+ Tools::put_bytes(ie.get(), length, ctx);
+ }
+ static void inline run(IE& ie, DecoderCtx& ctx, tag_value_t tag)
+ {
+ if(tag_t::value() != tag)
+ {
+ ctx.refErrorCtx().tagError(static_cast<uint32_t>(tag));
+ }
+ else
+ {
+ size_t length = Length::decode(ctx);
+ if(!length || length == indefinite_length)
+ ctx.refErrorCtx().sizeRangeError(length);
+ else
+ {
+ ASN_DECODER_TRACE("IE<type=%d name=%s tag=0x%x length=%zu> buffer: %s", static_cast<int>(IE::ie_type), IE::name(), static_cast<int>(tag), length, ctx.refBuffer().toString());
+ typename IE::value_type value;
+ Tools::get_bytes(value, length, ctx);
+ ie.set(value);
+ }
+ }
+ }
+};
+/***************************************************************************************
+* ENUMERATED: Encoding the enumerated type (X.690 8.4)
+***************************************************************************************/
+template <class IE>
+struct ElementType<IE, std::enable_if_t<IE::ie_type == element_type::T_ENUMERATED> >
+{
+ using tag_t = Tag<IE, false>;
+
+ static bool inline is_matched(tag_value_t tag) {return tag == tag_t::value();}
+
+ static void inline run(IE const& ie, EncoderCtx& ctx)
+ {
+ tag_t::encode(ctx);
+ size_t length = Length::get(ie.get());
+ Length::encode(length, ctx);
+ Tools::put_bytes(ie.get(), length, ctx);
+ }
+ static void inline run(IE& ie, DecoderCtx& ctx, tag_value_t tag)
+ {
+ if(tag_t::value() != tag)
+ ctx.refErrorCtx().tagError(static_cast<uint32_t>(tag));
+ else
+ {
+ size_t length = Length::decode(ctx);
+ if(!length || length == indefinite_length)
+ ctx.refErrorCtx().sizeRangeError(length);
+ else
+ {
+ ASN_DECODER_TRACE("IE<type=%d name=%s tag=0x%x length=%zu> buffer: %s", static_cast<int>(IE::ie_type), IE::name(), static_cast<int>(tag), length, ctx.refBuffer().toString());
+ typename IE::value_type value;
+ Tools::get_bytes(value, length, ctx);
+ ie.set(value);
+ }
+ }
+ }
+};
+/***************************************************************************************
+* REAL: Encoding the real type (X.690 8.5)
+***************************************************************************************/
+//missing...
+/***************************************************************************************
+* BIT STRING: Encoding the bitstring type (X.690 8.6)
+***************************************************************************************/
+template <class IE>
+struct ElementType<IE, std::enable_if_t<(IE::ie_type == element_type::T_BITSTRING)> >
+{
+ using tag_t = Tag<IE, false>;
+ using ctag_t = Tag<IE, true>;
+
+ static bool inline is_matched(tag_value_t tag) {return tag == tag_t::value() || tag == ctag_t::value();}
+
+ static void inline run(IE const& ie, EncoderCtx& ctx)
+ {
+ tag_t::encode(ctx);
+
+ uint8_t tail = ie.get_bitqty() % 8;
+
+ size_t length = ie.get_buffer().size();
+ Length::encode(length + 1, ctx);
+
+ auto & buffer = ctx.refBuffer();
+ buffer.putByte((8 - tail) & 0x7F);
+
+ if (tail)
+ {
+ buffer.putBytes(ie.get_buffer().data(), length - 1);
+ u8 last_byte = *(ie.get_buffer().data() + length - 1);
+
+ last_byte <<= 8 - tail;
+ buffer.putBytes(&last_byte, 1);
+ }
+ else
+ {
+ buffer.putBytes(ie.get_buffer().data(), length);
+ }
+ }
+ static void inline run(IE& ie, DecoderCtx& ctx, tag_value_t tag)
+ {
+ ie.clear();
+ if(tag_t::value() == tag)
+ {
+ size_t length = Length::decode(ctx);
+ if(!length || length == indefinite_length)
+ {
+ ctx.refErrorCtx().sizeRangeError(length);
+ }
+ else
+ {
+ ASN_DECODER_TRACE("IE<type=%d name=%s tag=0x%x length=%zu> buffer: %s", static_cast<int>(IE::ie_type), IE::name(), static_cast<int>(tag), length, ctx.refBuffer().toString());
+ uint8_t const* data_in = ctx.refBuffer().getBytes(length);
+ if(data_in)
+ {
+ size_t len_bytes = length - 1;
+ size_t bitqty = len_bytes << 3;
+
+ if((data_in[0] & 0x80) || (bitqty < data_in[0]))
+ {
+ ctx.refErrorCtx().valueRangeError(data_in[0]);
+ }
+ else
+ {
+ bitqty = bitqty - data_in[0];
+ uint8_t* data_out = ctx.refAllocator().alloc_bytes(len_bytes);
+ if (data_out)
+ {
+ memcpy(data_out, &data_in[1], len_bytes);
+ const u8 shift = bitqty % 8;
+ if (shift)
+ {
+ data_out[len_bytes - 1] >>= 8 - shift;
+ }
+ ie.set_buffer(bitqty, data_out);
+ }
+ else
+ {
+ ctx.refErrorCtx().allocatorNoMem(0, len_bytes);
+ }
+ }
+ }
+ }
+ }
+ else if(ctag_t::value() == tag)
+ {
+ //todo: implement the segmented data
+ ctx.refErrorCtx().errorUnsupported();
+ }
+ else
+ {
+ ctx.refErrorCtx().tagError(static_cast<uint32_t>(tag));
+ }
+ }
+};
+/***************************************************************************************
+* OCTET STRING: Encoding the octetstring type (X.690 8.7)
+* Restricted Character string types (X.690 8.23)
+***************************************************************************************/
+template <class IE>
+struct ElementType<IE, std::enable_if_t<IE::ie_type == element_type::T_OCTETSTRING> >
+{
+ using tag_t = Tag<IE, false>;
+ using ctag_t = Tag<IE, true>;
+
+ static bool inline is_matched(tag_value_t tag) {return tag == tag_t::value() || tag == ctag_t::value();}
+
+ static void inline run(IE const& ie, EncoderCtx& ctx)
+ {
+ tag_t::encode(ctx);
+ size_t length = ie.get().size();
+ Length::encode(length, ctx);
+ ctx.refBuffer().putBytes(ie.get().data(), length);
+ }
+ static void inline run(IE& ie, DecoderCtx& ctx, tag_value_t tag)
+ {
+ ie.clear();
+ if(tag_t::value() == tag)
+ {
+ size_t length = Length::decode(ctx);
+ if(length == indefinite_length)
+ {
+ ctx.refErrorCtx().sizeRangeError(length);
+ }
+ else
+ {
+ ASN_DECODER_TRACE("IE<type=%d name=%s tag=0x%x length=%zu> buffer: %s", static_cast<int>(IE::ie_type), IE::name(), static_cast<int>(tag), length, ctx.refBuffer().toString());
+ uint8_t const* data_in = ctx.refBuffer().getBytes(length);
+ if(data_in)
+ {
+ ie.set(length, data_in);
+ }
+ }
+ }
+ else if(ctag_t::value() == tag)
+ {
+ //todo: implement the segmented data
+ ctx.refErrorCtx().errorUnsupported();
+ }
+ else
+ {
+ ctx.refErrorCtx().tagError(static_cast<uint32_t>(tag));
+ }
+ }
+};
+/***************************************************************************************
+* NULL: Encoding the null type (X.690 8.8)
+***************************************************************************************/
+template <class IE>
+struct ElementType<IE, std::enable_if_t<IE::ie_type == element_type::T_NULL> >
+{
+ using tag_t = Tag<IE, false>;
+
+ static bool inline is_matched(tag_value_t tag) {return tag == tag_t::value();}
+
+ static void inline run(IE const& ie, EncoderCtx& ctx)
+ {
+ tag_t::encode(ctx);
+ Length::encode(0, ctx);
+ }
+
+ static void inline run(IE& ie, DecoderCtx& ctx, tag_value_t tag)
+ {
+ if(tag_t::value() != tag)
+ ctx.refErrorCtx().tagError(static_cast<uint32_t>(tag));
+ else
+ {
+ size_t length = Length::decode(ctx);
+ if(length)
+ ctx.refErrorCtx().sizeRangeError(length);
+ ASN_DECODER_TRACE("IE<type=%d name=%s tag=0x%x length=%zu> buffer: %s", static_cast<int>(IE::ie_type), IE::name(), static_cast<int>(tag), length, ctx.refBuffer().toString());
+ }
+ }
+};
+/***************************************************************************************
+* SEQUENCE: Encoding the sequence type (X.690 8.9)
+* SET: Encoding the set type (X.690 8.11)
+***************************************************************************************/
+template <class IE>
+struct ElementType<IE, std::enable_if_t<(IE::ie_type == element_type::T_SEQUENCE) || (IE::ie_type == element_type::T_SET)> >
+{
+ using tag_t = Tag<IE, true>;
+
+ static bool inline is_matched(tag_value_t tag) {return tag == tag_t::value();}
+
+ static void inline run(IE const& ie, EncoderCtx& ctx)
+ {
+ auto & buffer = ctx.refBuffer();
+
+ tag_t::encode(ctx);
+ u8* len_ptr = buffer.advance(1); //reserve for the length
+
+ VisitorEncoderSeq<IE> ve(ctx, ie);
+ ie.encode(ve);
+
+ size_t len = buffer.begin() - len_ptr - 1;
+ if(len > 127)
+ {
+ len_ptr[0] = 0x80; //undefinite length form per X.690 8.1.3.6
+ uint8_t buff[2] = {0}; // end-of-contents octets (X.690 8.1.5)
+ buffer.putBytes(buff, sizeof(buff));
+ }
+ else
+ len_ptr[0] = static_cast<u8>(len); //one byte form per X.690 8.1.3.4
+ }
+
+ static void inline run(IE& ie, DecoderCtx& ctx, tag_value_t tag) //todo: support arbitrary order of IEs in SET
+ {
+ if(tag_t::value() != tag)
+ ctx.refErrorCtx().tagError(static_cast<uint32_t>(tag));
+ else
+ {
+ VisitorDecoderSeq<IE> vd(ctx, ie);
+ auto & buffer = ctx.refBuffer();
+
+ size_t length = Length::decode(ctx);
+
+ ASN_DECODER_TRACE("IE<type=%d name=%s tag=0x%x length=%zu> buffer: %s", static_cast<int>(IE::ie_type), IE::name(), static_cast<int>(tag), length, ctx.refBuffer().toString());
+
+ if(length == indefinite_length)
+ {
+ ie.decode(vd);
+ if(ctx)
+ {
+ if(invalid_tag != vd.get_unhandled_tag())
+ {
+ tag_value_t _tag = vd.get_unhandled_tag();
+ if(IE::constraint_t::extended) //skip the unknown extension now
+ {
+ tag_value_t const* tag_ptr = &_tag;
+ size_t _length;
+ do
+ {
+ _tag = OpenType::decode(ctx, _length, tag_ptr);
+ tag_ptr = nullptr;
+
+ } while(ctx && !(_tag == 0 && _length == 0));
+ }
+ else // it should be the end-of-contents octets (8.1.5)
+ {
+ uint8_t const* data_in = ctx.refBuffer().getBytes(1);
+ if(data_in && (_tag || data_in[0]))
+ {
+ ctx.refErrorCtx().errorWrongEndOfContent();
+ }
+ }
+ }
+ else
+ {
+ uint8_t const* data_in = ctx.refBuffer().getBytes(2);
+ if(data_in && (data_in[0] || data_in[1]))
+ {
+ ctx.refErrorCtx().errorWrongEndOfContent();
+ }
+ }
+ }
+ }
+ else
+ {
+ if (buffer.getBytesLeft() < length)
+ {
+ ctx.refErrorCtx().lengthErrorBytes(buffer.getBytesLeft(), length);
+ }
+ else
+ {
+ DecoderCtx::buf_type::pointer end = buffer.end();
+ buffer.set_end(buffer.begin() + length);
+ ie.decode(vd);
+ tag_value_t _tag = vd.get_unhandled_tag();
+ if(invalid_tag != _tag)
+ {
+ if(IE::constraint_t::extended) //skip the unknown extension now
+ {
+ tag_value_t const* tag_ptr = &_tag;
+ size_t _length;
+ do
+ {
+ _tag = OpenType::decode(ctx, _length, tag_ptr);
+ tag_ptr = nullptr;
+
+ } while(ctx && buffer.getBytesLeft() > 0);
+ }
+ else
+ ctx.refErrorCtx().tagError(static_cast<uint32_t>(tag)); // unexpected tag
+ }
+ buffer.set_end(end);
+ }
+ }
+
+ }
+ }
+};
+/***************************************************************************************
+* SEQUENCE OF: Encoding the sequence-of type (X.690 8.10)
+* SET OF: Encoding the set-of type (X.690 8.12)
+***************************************************************************************/
+template <class IE>
+struct ElementType<IE, std::enable_if_t<(IE::ie_type == element_type::T_SEQUENCE_OF) || (IE::ie_type == element_type::T_SET_OF)> >
+{
+ using tag_t = Tag<IE, true>;
+
+ static bool inline is_matched(tag_value_t tag) {return tag == tag_t::value();}
+
+ static void inline run(IE const& ie, EncoderCtx& ctx)
+ {
+ auto & buffer = ctx.refBuffer();
+
+ tag_t::encode(ctx);
+ u8* len_ptr = buffer.advance(1); //reserve for the length
+
+ for (auto& elem : ie)
+ {
+ Element<typename IE::element_t>::run(elem, ctx);
+ }
+
+ size_t len = buffer.begin() - len_ptr - 1;
+ if(len > 127)
+ {
+ len_ptr[0] = 0x80; //undefinite length form per X.690 8.1.3.6
+ uint8_t buff[2] = {0}; // end-of-contents octets (X.690 8.1.5)
+ buffer.putBytes(buff, sizeof(buff));
+ }
+ else
+ len_ptr[0] = static_cast<u8>(len); //one byte form per X.690 8.1.3.4
+ }
+ static void inline run(IE& ie, DecoderCtx& ctx, tag_value_t tag)
+ {
+ ie.clear();
+
+ if(tag_t::value() != tag)
+ ctx.refErrorCtx().tagError(static_cast<uint32_t>(tag));
+ else
+ {
+ auto & buffer = ctx.refBuffer();
+
+ size_t length = Length::decode(ctx);
+
+ ASN_DECODER_TRACE("IE<type=%d name=%s tag=0x%x length=%zu> buffer: %s", static_cast<int>(IE::ie_type), IE::name(), static_cast<int>(tag), length, ctx.refBuffer().toString());
+
+ if(length == indefinite_length)
+ {
+ tag_value_t elm_tag = get_tag(ctx);
+
+ while(ctx && Element<typename IE::element_t>::is_matched(elm_tag))
+ {
+ add_element(ie, ctx, &elm_tag);
+ elm_tag = get_tag(ctx);
+ }
+
+ if(ctx)
+ {
+ uint8_t const* data_in = ctx.refBuffer().getBytes(1);
+ if(data_in && (elm_tag || data_in[0]))
+ {
+ ctx.refErrorCtx().errorWrongEndOfContent();
+ }
+ }
+ }
+ else
+ {
+ if (buffer.getBytesLeft() < length)
+ {
+ ctx.refErrorCtx().lengthErrorBytes(buffer.getBytesLeft(), length);
+ }
+ else
+ {
+ DecoderCtx::buf_type::pointer end = buffer.end();
+ buffer.set_end(buffer.begin() + length);
+
+ while(ctx && buffer.getBytesLeft() > 0)
+ add_element(ie, ctx);
+
+ buffer.set_end(end);
+ }
+ }
+ }
+ }
+
+private:
+ static void inline add_element(IE& ie, DecoderCtx& ctx, tag_value_t const* elm_tag = nullptr)
+ {
+ uint8_t* data = ctx.refAllocator().alloc_bytes(sizeof(typename IE::value_type));
+ if (data)
+ {
+ typename IE::value_type * v = new (data) typename IE::value_type;
+ v->clear();
+ ie.push_back(*v);
+ Element<typename IE::element_t>::run(*v, ctx, elm_tag);
+ }
+ else
+ {
+ ctx.refErrorCtx().allocatorNoMem(0, sizeof(typename IE::value_type));
+ }
+ }
+};
+
+/***************************************************************************************
+* CHOICE: Encoding the choice type
+***************************************************************************************/
+struct ChoiceVisitorEncoder
+{
+ ChoiceVisitorEncoder(EncoderCtx& ctx) : m_ctx(ctx) {}
+
+ template<typename IE>
+ bool operator()(IE const& ie)
+ {
+ Element<IE>::run(ie, m_ctx);
+ return static_cast<bool>(m_ctx);
+ }
+
+ EncoderCtx& m_ctx;
+};
+
+struct ChoiceVisitorDecoder
+{
+ ChoiceVisitorDecoder(DecoderCtx& ctx, tag_value_t tag) : m_ctx(ctx), m_tag(tag) {}
+
+ template<typename IE> bool operator()(IE& ie)
+ {
+ Element<IE>::run(ie, m_ctx, &m_tag);
+ return static_cast<bool>(m_ctx);
+ }
+
+ DecoderCtx& m_ctx;
+ tag_value_t m_tag;
+};
+
+template <class IE>
+struct ElementType<IE, std::enable_if_t<IE::ie_type == element_type::T_CHOICE && IE::asn_identifier_t::class_type == class_type_t::UNSPECIFIED> >
+{
+ struct Selector
+ {
+ Selector(tag_value_t tag) : m_tag(tag) {}
+
+ template<typename ELM> void operator()(size_t idx)
+ {
+ if(!m_valid && Element<ELM>::is_matched(m_tag))
+ {
+ m_index = idx;
+ m_valid = true;
+ }
+ }
+
+ size_t get_idx() const {return m_index;}
+ bool is_valid() const {return m_valid;}
+
+ private:
+ tag_value_t m_tag;
+ size_t m_index {0};
+ bool m_valid {false};
+ };
+
+ static bool inline is_matched(tag_value_t tag)
+ {
+ Selector selector {tag};
+ IE::enumerate(selector);
+ return selector.is_valid();
+ }
+
+ static void inline run(IE const& ie, EncoderCtx& ctx)
+ {
+ ChoiceVisitorEncoder ve(ctx);
+
+ if(ctx && !ie.encode(ve))
+ ctx.refErrorCtx().tagError(ie.get_index());
+ }
+ static void inline run(IE& ie, DecoderCtx& ctx, tag_value_t tag)
+ {
+ ie.clear();
+
+ Selector selector {tag};
+ IE::enumerate(selector);
+
+ if(!selector.is_valid())
+ ctx.refErrorCtx().tagError(static_cast<uint32_t>(tag));
+ else
+ {
+ ChoiceVisitorDecoder vd {ctx, tag};
+ if(ctx && !ie.decode(selector.get_idx(), vd))
+ ctx.refErrorCtx().tagError(ie.get_index());
+ }
+ }
+};
+
+template <class IE>
+struct ElementType<IE, std::enable_if_t<IE::ie_type == element_type::T_CHOICE && IE::asn_identifier_t::class_type != class_type_t::UNSPECIFIED> >
+{
+ static bool inline is_matched(tag_value_t _tag) {return ExplicitCodec<IE>::is_matched(_tag);}
+
+ static void inline run(IE const& ie, EncoderCtx& ctx)
+ {
+ ExplicitCodec<IE>::run(ie, ctx);
+ }
+
+ static void inline run(IE& ie, DecoderCtx& ctx, tag_value_t tag)
+ {
+ ExplicitCodec<IE>::run(ie, ctx, tag);
+ }
+};
+
+/***************************************************************************************
+* IE_OBJECT_IDENTIFIER: Encoding the object identifier type
+***************************************************************************************/
+template <class IE>
+struct ElementType<IE, std::enable_if_t<IE::ie_type == element_type::T_OBJECTIDENTIFIER> >
+{
+ using tag_t = Tag<IE, false>;
+
+ static bool inline is_matched(tag_value_t _tag) {return _tag == tag_t::value();}
+
+ static void inline run(IE const& ie, EncoderCtx& ctx)
+ {
+ tag_t::encode(ctx);
+ size_t length = ie.get().size();
+ Length::encode(length, ctx);
+ ctx.refBuffer().putBytes(ie.get().data(), length);
+ }
+ static void inline run(IE& ie, DecoderCtx& ctx, tag_value_t tag)
+ {
+ ie.clear();
+ if(tag_t::value() == tag)
+ {
+ size_t length = Length::decode(ctx);
+ if(!length || length == indefinite_length)
+ {
+ ctx.refErrorCtx().sizeRangeError(length);
+ }
+ else
+ {
+ ASN_DECODER_TRACE("IE<type=%d name=%s tag=0x%x length=%zu> buffer: %s", static_cast<int>(IE::ie_type), IE::name(), static_cast<int>(tag), length, ctx.refBuffer().toString());
+ uint8_t const* data_in = ctx.refBuffer().getBytes(length);
+ if(data_in)
+ {
+ ie.set(length, data_in);
+ }
+ }
+ }
+ else
+ {
+ ctx.refErrorCtx().tagError(static_cast<uint32_t>(tag));
+ }
+ }
+};
+
+/***************************************************************************************
+* T_OBJFIELD_FTV
+***************************************************************************************/
+template <class IE>
+struct ElementType<IE, std::enable_if_t<IE::ie_type == element_type::T_OBJFIELD_FTV> >
+{
+ using tag_t = Tag<IE, false>;
+
+ static bool inline is_matched(tag_value_t _tag) {return _tag == tag_t::value();}
+};
+
+/***************************************************************************************
+* T_OBJFIELD_TF
+***************************************************************************************/
+template <class IE>
+struct ElementType<IE, std::enable_if_t<IE::ie_type == element_type::T_OBJFIELD_TF> >
+{
+ struct Selector
+ {
+ Selector(tag_value_t tag) : m_tag(tag) {}
+
+ template<typename ELM> void operator()(size_t idx)
+ {
+ if(Element<ELM>::is_matched(m_tag))
+ {
+ m_index = idx;
+ m_valid = true;
+ }
+ }
+
+ size_t get_idx() const {return m_index;}
+ bool is_valid() const {return m_valid;}
+
+ private:
+ tag_value_t m_tag;
+ size_t m_index {0};
+ bool m_valid {false};
+ };
+
+ static bool inline is_matched(tag_value_t tag)
+ {
+ Selector selector(tag);
+ IE::enumerate(selector);
+
+ return selector.is_valid();
+ }
+};
+
+/***************************************************************************************
+* Identifier
+***************************************************************************************/
+template <class IE, class Enabler = void>
+struct Identifier
+{
+ static bool inline is_matched(tag_value_t _tag)
+ {
+ return ElementType<IE>::is_matched(_tag);
+ }
+
+ static void inline run(IE const& ie, EncoderCtx& ctx)
+ {
+ ElementType<IE>::run(ie, ctx);
+ }
+
+ static void inline run(IE& ie, DecoderCtx& ctx, tag_value_t tag)
+ {
+ ElementType<IE>::run(ie, ctx, tag);
+ }
+};
+
+template <class IE>
+struct Identifier<IE, std::enable_if_t<IE::asn_identifier_t::tag_type == tag_type_t::EXPLICIT> >
+{
+ static bool inline is_matched(tag_value_t _tag) {return ExplicitCodec<IE>::is_matched(_tag);}
+
+ static void inline run(IE const& ie, EncoderCtx& ctx)
+ {
+ ExplicitCodec<IE>::run(ie, ctx);
+ }
+
+ static void inline run(IE& ie, DecoderCtx& ctx, tag_value_t tag)
+ {
+ ExplicitCodec<IE>::run(ie, ctx, tag);
+ }
+};
+
+/***************************************************************************************
+* COMMON: Element
+***************************************************************************************/
+template <class IE>
+struct Element
+{
+ static bool inline is_matched(tag_value_t _tag)
+ {
+ return Identifier<IE>::is_matched(_tag);
+ }
+
+ static void inline run(IE const& ie, EncoderCtx& ctx)
+ {
+ if (ctx)
+ {
+ ASN_ENCODER_TRACE("IE<type=%d name=%s> buffer: %s", static_cast<int>(IE::ie_type), IE::name(), ctx.refBuffer().toString());
+ ctx.ie_name(IE::name());
+ Identifier<IE>::run(ie, ctx);
+ }
+ }
+ static void inline run(IE& ie, DecoderCtx& ctx, tag_value_t const* tag_ptr = nullptr)
+ {
+ if (ctx)
+ {
+ ctx.ie_name(IE::name());
+
+ tag_value_t tag = tag_ptr ? *tag_ptr : get_tag(ctx);
+ if(ctx)
+ Identifier<IE>::run(ie, ctx, tag);
+ }
+ }
+};
+
+} //namespace ber
+} //namespace asn
Code Review / sim / e2-interface.git / blobdiff