asn1.h

Go to the documentation of this file.

// OSB library ************************************************ -*- C++ -*-
/*
   AUTHOR(S): Stephan Broennimann (vb)

   RCS information
    $Name: OSB_060808 $
    $Revision: 1.2 $

  License
   OSB rating and billing library for communication networks
   Copyright (C) 2004, 2005, 2006  OSB systems

   This file may be distributed and/or modify under the terms of the
   GNU General Public License (GPL) as published by the Free Software
   Foundation which is provided in the file LICENSE.GPL included in the
   packaging of this file.

   The file is distributed in the hope that it will be useful, but WITHOUT
   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
   FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
   for more details.

   Holders of a OSB Commercial License may use this file under the terms
   and conditions of this commercial license.
 */
#ifndef _ASN1_H_
#define _ASN1_H_

// ************************************************************************
// included header files
// + standard includes
#include <cstddef>                      // for size_t
#include <cstdio>                       // for FILE*

// + local headers
#include "asn1fwd.h"

// + class declarations
namespace OSB_LIB {
    class OsbErrors;
}

// ************************************************************************
// namespace extensions
namespace OSB_LIB {

// ************************************************************************
// class definitions

    class Asn1Tag {
    public:
        enum TypeClass {
            tcUniversal   = 0x00,       
            tcApplication = 0x40,       
            tcContext     = 0x80,       
            tcPrivate     = 0xc0        
        };

        static const size_t tagNotSet = size_t(-1);

        explicit Asn1Tag(size_t val = tagNotSet);

        Asn1Tag(TypeClass typeClass,
                size_t    tagNum,
                bool      constructed);

        size_t value() const;
        size_t tagNumber() const;
        bool isSet() const;
        TypeClass typeClass() const;
        bool isConstructed() const;
        size_t size() const;
        Asn1Byte operator[](size_t i) const;

        bool operator==(const Asn1Tag& rhs) const;
        bool operator!=(const Asn1Tag& rhs) const;
        bool operator<(const Asn1Tag& rhs) const;

        size_t read(FILE* in);

        size_t get(
            const Asn1Byte* data,
                  size_t    dataSize
        );

        void encode(Asn1Data& dest) const;

        std::string str() const;

    private:
        size_t value_;
        size_t size_;

    private:
        inline void mkSize();
    };                                  // class Asn1Tag

    class Asn1Len {
    public:
        static const size_t infinite = static_cast<size_t>(-1);

    public:
        explicit Asn1Len(size_t len = 0);
        const Asn1Len& operator=(size_t len);

    public:
        void setInfinite();

    public:
        operator size_t() const;
        bool isInfinite() const;
        size_t size() const;
        Asn1Byte operator[](size_t i) const;

        size_t read(FILE* in);

        size_t get(
            const Asn1Byte* data,
                  size_t    dataSize
        );

        void encode(Asn1Data& dest) const;

        std::string str() const;

    private:
        size_t len_;
    };
}                                       // namespace OSB_LIB

// ************************************************************************
// inline definitions
namespace OSB_LIB {
    // ********************************************************************
    // class Asn1Tag
    inline size_t Asn1Tag::value() const
    {
        return value_;
    }

    inline bool Asn1Tag::isSet() const
    {
        return tagNotSet != value_;
    }

    inline size_t Asn1Tag::size() const
    {
        return size_;
    }

    inline Asn1Tag::TypeClass Asn1Tag::typeClass() const
    {
        Asn1Byte f = (*this)[0];
        return TypeClass(tcPrivate & f);
    }

    inline bool Asn1Tag::isConstructed() const
    {
        Asn1Byte f = (*this)[0];
        return 0x20 == (0x20 & f);
    }

    inline bool Asn1Tag::operator==(const Asn1Tag& rhs) const
    {
        return value_ == rhs.value_;
    }

    inline bool Asn1Tag::operator!=(const Asn1Tag& rhs) const
    {
        return value_ != rhs.value_;
    }

    inline bool Asn1Tag::operator<(const Asn1Tag& rhs) const
    {
        return value_ < rhs.value_;
    }

    // ********************************************************************
    // class Asn1Len
    inline Asn1Len::Asn1Len(size_t len)
      : len_(len)
    {
    }

    inline const Asn1Len& Asn1Len::operator=(size_t len)
    {
        len_ = len;
        return *this;
    }

    inline void Asn1Len::setInfinite()
    {
        len_ = infinite;
    }

    inline Asn1Len::operator size_t() const
    {
        return isInfinite() ? 0 : len_;
    }

    inline bool Asn1Len::isInfinite() const
    {
        return len_ == infinite;
    }
}                                       // namespace OSB_LIB
#endif                                  // #ifndef _ASN1_H_

---