yateasn.h

 
#ifndef __YATEASN_H
#define __YATEASN_H
 
#include <yateclass.h>
 
#ifdef _WINDOWS
 
#ifdef LIBYASN_EXPORTS
#define YASN_API __declspec(dllexport)
#else
#ifndef LIBYASN_STATIC
#define YASN_API __declspec(dllimport)
#endif
#endif
 
#endif /* _WINDOWS */
 
#ifndef YASN_API
#define YASN_API
#endif
 
namespace TelEngine {
 
#define ASN_LONG_LENGTH         0x80
#define ASN_BIT8                0x80
#define ASN_EXTENSION_ID        31
#define IS_EXTENSION_ID(byte) (((byte) & ASN_EXTENSION_ID) == ASN_EXTENSION_ID)
 
class AsnObject;
class AsnValue;
class ASNObjId;
class ASNLib;
class ASNError;
 
class YASN_API OctetString : public DataBlock
{
public:
    inline String getString()
    {
        String str((const char*)data(),length());
        return str;
    }
    inline DataBlock& operator=(const String& value)
    {
        clear();
        append(value);
        return *this;
    }
    inline DataBlock& operator=(const DataBlock& value)
    {
        clear();
        append(value);
        return *this;
    }
    inline const String toHexString() const
    {
        String str;
        str = str.hexify(data(),length());
        return str;
    }
    inline DataBlock& fromHexString(const String& value)
    {
        unHexify(value);
        return *this;
    }
};
 
class YASN_API AsnObject : public GenObject {
    YCLASS(AsnObject, GenObject)
public:
    inline AsnObject()
        {}
 
    inline AsnObject(const AsnObject& original)
        {}
 
    virtual inline ~AsnObject()
        {}
 
    virtual int decode(DataBlock& data) = 0;
 
    virtual int encode(DataBlock& data) = 0;
 
    virtual void getParams(NamedList* params) = 0;
 
    virtual void setParams(NamedList* params) = 0;
};
 
class YASN_API AsnValue : public GenObject {
    YCLASS(AsnValue, GenObject)
public:
    enum ValType {
        INTEGER                 = 1,
        STRING                  = 2,
        OBJECT_ID               = 3,
        IPADDRESS               = 4,
        COUNTER                 = 5,
        TIMETICKS               = 6,
        ARBITRARY               = 7,
        BIG_COUNTER             = 8,
        UNSIGNED_INTEGER        = 9
    };
 
    inline AsnValue()
        : m_type(0), m_data("")
        {}
 
    inline AsnValue(const AsnValue& original)
        : m_type(original.m_type), m_data(original.m_data)
        { }
 
    inline AsnValue(const String& value, int type = STRING)
        : m_type(type), m_data(value)
        { }
 
    virtual inline ~AsnValue()
        {}
 
    inline const String& getValue()
        { return m_data; }
 
    inline int type()
        { return m_type;}
 
    inline AsnValue& operator=( AsnValue* val)
    {
        if (!val)
            return *this;
        m_data = val->getValue();
        m_type = val->type();
        return *this;
    }
 
    inline AsnValue& operator=( AsnValue val)
    {
        m_data = val.getValue();
        m_type = val.type();
        return *this;
    }
 
    inline void setValue(const String& data)
        { m_data.clear();m_data = data; }
 
    inline void setType(int type)
        { m_type = type; }
 
private:
    int m_type;
    String m_data;
};
 
class YASN_API AsnMib : public GenObject {
    YCLASS(AsnMib, GenObject)
public:
    enum Access {
        notAccessible = 0,
        accessibleForNotify = 1,
        readOnly = 2,
        readWrite = 3,
        readCreate = 4
    };
    inline AsnMib()
        : m_access(""), m_accessVal(0), m_index(0)
        {}
 
    AsnMib(NamedList& params);
 
    inline ~AsnMib()
        {}
 
    inline String& getAccess()
        { return m_access;}
 
    inline int getAccessValue()
        { return m_accessVal;}
 
    inline String& getName()
        { return m_name;}
 
    inline String getOID()
        { String str = ".";
          str += m_index;
          return m_oid + str;}
 
    inline String& getType()
        { return m_type;}
 
    inline String& getRevision()
        { return m_revision; }
 
    inline const String& toString() const
        { return m_oid;}
 
    inline void setIndex(unsigned int ind)
        { m_index = ind;}
 
    inline unsigned int index()
        { return m_index;}
 
    int compareTo(AsnMib* mib);
 
    inline String getParent()
    {
        int pos = m_oid.rfind('.');
        return m_oid.substr(0,pos);
    }
 
private:
    String m_name;
    String m_oid;
    String m_access;
    int m_accessVal;
    String m_type;
    String m_revision;
    int size;
    int maxVal;
    int minVal;
    unsigned int m_index;
 
    static TokenDict s_access[];
};
 
class YASN_API ASNObjId : public GenObject {
    YCLASS(ASNObjId, GenObject)
public:
    ASNObjId();
 
    inline ASNObjId(const ASNObjId& original)
        : m_value(original.m_value), m_name(original.m_name)
        { }
 
    ASNObjId(const String& val);
 
    ASNObjId(const String& name, const String& val);
 
    ASNObjId(AsnMib* mib);
 
    ~ASNObjId();
 
    inline ASNObjId& operator=(const ASNObjId& original)
        { m_value = original.toString(); return *this; }
 
    inline ASNObjId& operator=(const String& val)
        { m_value = val; return *this; }
 
    inline ASNObjId& operator=(const char* val)
        { m_value = val; return *this; }
 
    void toDataBlock();
 
    DataBlock getIds();
 
    inline const String& toString() const
        { return m_value; }
 
    inline const String& getName() const
        { return m_name; }
 
    inline void setValue(const String& value)
        { m_value = value; toDataBlock();}
 
private:
    String m_value;
    String m_name;
    DataBlock m_ids;
};
 
class AsnTag {
public:
    enum Class {
        Universal   = 0x00,
        Application = 0x40,
        Context     = 0x80,
        Private     = 0xc0,
    };
 
    enum Type {
        Primitive   = 0x00,
        Constructor = 0x20,
    };
 
    inline AsnTag()
        : m_class(Universal), m_type(Primitive), m_code(0)
    { }
 
    inline AsnTag(Class clas, Type type, unsigned int code)
        : m_class(clas), m_type(type), m_code(code)
    {
        encode();
    }
 
    inline ~AsnTag()
    {}
 
    static void decode(AsnTag& tag, DataBlock& data);
 
    static void encode(Class clas, Type type, unsigned int code, DataBlock& data);
 
    inline void encode()
        { AsnTag::encode(m_class,m_type,m_code,m_coding); }
 
    inline bool operator==(const AsnTag& tag) const
    {
        return (m_class == tag.classType() && m_type == tag.type() && m_code == tag.code());
    }
 
    inline bool operator!=(const AsnTag& tag) const
    {
        return !(m_class == tag.classType() && m_type == tag.type() && m_code == tag.code());
    }
 
    inline AsnTag& operator=(const AsnTag& value)
    {
        m_class = value.classType();
        m_type = value.type();
        m_code = value.code();
        encode();
        return *this;
    }
 
    inline const Class classType() const
        { return m_class; }
 
    inline void classType(Class clas)
        { m_class = clas; }
 
    inline const Type type() const
        { return m_type; }
 
    inline void type(Type type)
        { m_type = type; }
 
    inline const unsigned int code() const
        { return m_code; }
 
    inline void code(unsigned int code)
        { m_code = code; }
 
    inline const DataBlock& coding() const
        { return m_coding; }
 
private:
    Class m_class;
    Type m_type;
    unsigned int m_code;
    DataBlock m_coding;
};
 
class YASN_API ASNLib {
public:
    enum TypeTag {
        UNIVERSAL       = 0x00,
        BOOLEAN         = 0x01,
        INTEGER         = 0x02,
        BIT_STRING      = 0x03,
        OCTET_STRING    = 0x04,
        NULL_ID         = 0x05,
        OBJECT_ID       = 0x06,
        REAL            = 0x09, //not implemented
        UTF8_STR        = 0x0c,
        SEQUENCE        = 0x30,
        SET             = 0x31,
        NUMERIC_STR     = 0x12,
        PRINTABLE_STR   = 0x13,
        IA5_STR         = 0x16,
        UTC_TIME        = 0x17,
        GENERALIZED_TIME = 0x18,
        VISIBLE_STR     = 0x1a,
        GENERAL_STR     = 0x1b, // not implemented
        UNIVERSAL_STR   = 0x1c, // not implemented
        CHARACTER_STR   = 0x1d, // not implemented
        BMP_STR         = 0x1e, // not implemented
        CHOICE          = 0x1f, // does not have a value
        DEFINED         = 0x2d
    };
        // values not implemented
        // 10   ENUMERATED
        // 11   EMBEDDED PDV
        // 13   RELATIVE-OID
        // 20   TeletexString, T61String
        // 21   VideotexString
        // 25   GraphicString
        // 27   GeneralString
        // 28   UniversalString
        // 29   CHARACTER STRING
        // 30   BMPString
    enum Error {
        InvalidLengthOrTag = -1,
        ConstraintBreakError = -2,
        ParseError = -3,
        InvalidContentsError = -4,
        IndefiniteForm = -5,
    };
 
    ASNLib();
 
    ~ASNLib();
 
    static int decodeLength(DataBlock& data);
 
    static int decodeBoolean(DataBlock& data, bool* val, bool tagCheck);
 
    static int decodeInteger(DataBlock& data, u_int64_t& intVal, unsigned int bytes, bool tagCheck);
 
    static int decodeUINT8(DataBlock& data, u_int8_t* intVal, bool tagCheck);
 
    static int decodeUINT16(DataBlock& data, u_int16_t* intVal, bool tagCheck);
 
    static int decodeUINT32(DataBlock& data, u_int32_t* intVal, bool tagCheck);
 
    static int decodeUINT64(DataBlock& data, u_int64_t* intVal, bool tagCheck);
 
    static int decodeINT8(DataBlock& data, int8_t* intVal, bool tagCheck);
 
    static int decodeINT16(DataBlock& data, int16_t* intVal, bool tagCheck);
 
    static int decodeINT32(DataBlock& data, int32_t* intVal, bool tagCheck);
 
    static int decodeINT64(DataBlock& data, int64_t* intVal, bool tagCheck);
 
    static int decodeBitString(DataBlock& data, String* val, bool tagCheck);
 
    static int decodeOctetString(DataBlock& data, OctetString* strVal, bool tagCheck);
 
    static int decodeNull(DataBlock& data, bool tagCheck);
 
    static int decodeOID(DataBlock& data, ASNObjId* obj, bool tagCheck);
 
    static int decodeReal(DataBlock& data, float* realVal, bool tagCheck);
 
    static int decodeString(DataBlock& data, String* str, int* type, bool tagCheck);
 
    static int decodeUtf8(DataBlock& data, String* str, bool tagCheck);
 
    static int decodeGenTime(DataBlock& data, unsigned int* time, unsigned int* fractions, bool* utc, bool tagCheck);
 
    static int decodeUTCTime(DataBlock& data, unsigned int* time, bool tagCheck);
 
    static int decodeAny(DataBlock data, DataBlock* val, bool tagCheck);
 
    static int decodeSequence(DataBlock& data, bool tagCheck);
 
    static int decodeSet(DataBlock& data, bool tagCheck);
 
    static DataBlock buildLength(DataBlock& data);
 
    static DataBlock encodeBoolean(bool val, bool tagCheck);
 
    static DataBlock encodeInteger(u_int64_t intVal, bool tagCheck);
 
    static DataBlock encodeOctetString(OctetString strVal, bool tagCheck);
 
    static DataBlock encodeNull(bool tagCheck);
 
    static DataBlock encodeBitString(String val, bool tagCheck);
 
    static DataBlock encodeOID(ASNObjId obj, bool tagCheck);
 
    static DataBlock encodeReal(float val, bool tagCheck);
 
    static DataBlock encodeString(String str, int type, bool tagCheck);
 
    static DataBlock encodeUtf8(String str, bool tagCheck);
 
    static DataBlock encodeGenTime(unsigned int time, unsigned int fractions, bool tagCheck);
 
    static DataBlock encodeUTCTime(unsigned int time, bool tagCheck);
 
    static DataBlock encodeAny(DataBlock data, bool tagCheck);
 
    static int encodeSequence(DataBlock& data, bool tagCheck);
 
    static int encodeSet(DataBlock& data, bool tagCheck);
 
    static int matchEOC(DataBlock& data);
 
    static int parseUntilEoC(DataBlock& data, int length = 0);
};
 
}
 
#endif /* __YATEASN_H */
 
/* vi: set ts=8 sw=4 sts=4 noet: */