Example #1
0
        /// <summary>
        /// Checks if one MIB value is less than another.
        /// </summary>
        /// <param name="strict">The strict less than flag</param>
        /// <param name="value1">The first value</param>
        /// <param name="value2">The second value</param>
        /// <returns>
        /// True if the first value is less than the second,
        /// false if not
        /// </returns>
        private bool IsLessThan(
            bool strict,
            MibValue value1,
            MibValue value2)
        {
            NumberValue nv1 = value1 as NumberValue;
            NumberValue nv2 = value2 as NumberValue;

            if (value1 != null && value2 != null)
            {
                return(this.IsLessThan(
                           strict,
                           nv1.Value,
                           nv2.Value));
            }

            StringValue s1 = value1 as StringValue;
            StringValue s2 = value2 as StringValue;

            if (s1 != null && s2 != null)
            {
                return(this.IsLessThan(
                           strict,
                           s1.ToString(),
                           s2.ToString()));
            }
            else
            {
                return(false);
            }
        }
Example #2
0
        /// <summary>
        /// Clears and prepares this value for garbage collection. This
        /// method will recursively clear any associated types or values,
        /// making sure that no data structures references this object.
        /// </summary>
        /// <remarks>
        /// This is an internal method that should
        /// only be called by the MIB loader.
        /// </remarks>
        public override void Clear()
        {
            // Recursively clear all children in same MIB
            if (this.children != null)
            {
                foreach (var c in this.children)
                {
                    c.Clear();
                }
            }

            // Remove parent reference if all children were cleared
            if (this.ChildCount <= 0)
            {
                if (this.parent != null)
                {
                    this.Parent.children.Remove(this);
                    this.parent = null;
                }

                this.children = null;
            }

            // Clear other value data
            this.symbol = null;
            base.Clear();
        }
Example #3
0
        /// <summary>
        /// Initializes the MIB type. This will remove all levels of
        /// indirection present, such as references to types or values. No
        /// information is lost by this operation. This method may modify
        /// this object as a side-effect, and will return the basic
        /// type.
        /// NOTE: This is an internal method that should
        /// only be called by the MIB loader.
        /// </summary>
        /// <param name="symbol">The MIB symbol containing this type</param>
        /// <param name="log">The MIB loader log</param>
        /// <returns>The basic MIB type</returns>
        public override MibType Initialize(MibSymbol symbol, MibLoaderLog log)
        {
            if (!(symbol is MibValueSymbol))
            {
                throw new MibException(
                          symbol.Location,
                          "only values can have the " + Name + " type");
            }

            this.syntax = this.syntax.Initialize(symbol, log);

            SnmpObjectType.CheckType((MibValueSymbol)symbol, log, this.syntax);

            foreach (SnmpIndex si in this.index)
            {
                si.Initialize(symbol, log);
            }

            if (this.augments != null)
            {
                this.augments = this.augments.Initialize(log, this.syntax);
            }

            if (this.defaultValue != null)
            {
                this.defaultValue = this.defaultValue.Initialize(log, this.syntax);
            }

            return(this);
        }
Example #4
0
        /// <summary>
        /// Checks if the specified value is compatible with this type.  A
        /// value is compatible if and only if it is an numeric value
        /// representing positive or negative infinity
        /// </summary>
        /// <param name="value">The value to check</param>
        /// <returns>True if the value is compatible, false if not</returns>
        public override bool IsCompatible(MibValue value)
        {
            if (value is RealValue number)
            {
                return(double.IsInfinity(number.Value));
            }

            return(false);
        }
        /// <summary>
        /// Compare this value to another MIB Value
        /// </summary>
        /// <param name="other">The MIB Value to compare against</param>
        /// <returns>
        /// Zero (0) if the objects are equal, an non-zero integer value if not
        /// </returns>
        public override int CompareTo(MibValue other)
        {
            if (other is NumberValue nv)
            {
                return(this.CompareToNumber(nv.value));
            }

            return(this.ToString().CompareTo(other));
        }
Example #6
0
        /// <summary>
        /// Compare this value to another MIB Value
        /// </summary>
        /// <param name="other">The MIB Value to compare against</param>
        /// <returns>
        /// Zero (0) if the objects are equal, an non-zero integer value if not
        /// </returns>
        public override int CompareTo(MibValue other)
        {
            if (!(other is BooleanValue bv))
            {
                return(1);
            }

            return(bv.value == this.value ? 0 : 1);
        }
Example #7
0
        /// <summary>
        /// Checks if this object equals another object. This method will
        /// compare the string representations for equality.
        /// </summary>
        /// <param name="obj">The object to compare with</param>
        /// <returns>True if the objects are equal, false otherwise</returns>
        public override bool Equals(object obj)
        {
            MibValue mv = obj as MibValue;

            if (mv == null)
            {
                return(false);
            }

            return(this.CompareTo(mv) == 0);
        }
Example #8
0
        /// <summary>
        /// Compare this value to another MIB Value
        /// </summary>
        /// <param name="other">The MIB Value to compare against</param>
        /// <returns>
        /// Zero (0) if the objects are equal, an non-zero integer value if not
        /// </returns>
        public override int CompareTo(MibValue other)
        {
            BooleanValue bv = other as BooleanValue;

            if (bv == null)
            {
                return(1);
            }

            return(bv.value == this.value ? 0 : 1);
        }
Example #9
0
 /// <summary>
 /// Initializes a new instance of the <see cref="SnmpTrapType"/> class.
 /// </summary>
 /// <param name="enterprise">the enterprise value</param>
 /// <param name="variables">The list of MIB values</param>
 /// <param name="description">The type description or null</param>
 /// <param name="reference">The type reference or null</param>
 public SnmpTrapType(
     MibValue enterprise,
     IList <MibValue> variables,
     string description,
     string reference)
     : base("TRAP-TYPE", description)
 {
     this.enterprise = enterprise;
     this.variables  = variables;
     this.reference  = reference;
 }
Example #10
0
        /// <summary>
        /// Checks if the specified value is compatible with this type.  A
        /// value is compatible if and only if it is an numeric value
        /// representing positive or negative infinity
        /// </summary>
        /// <param name="value">The value to check</param>
        /// <returns>True if the value is compatible, false if not</returns>
        public override bool IsCompatible(MibValue value)
        {
            RealValue number = value as RealValue;

            if (number != null)
            {
                return(double.IsInfinity(number.Value));
            }

            return(false);
        }
Example #11
0
        /// <summary>
        /// Compare this value to another MIB Value
        /// </summary>
        /// <param name="other">The MIB Value to compare against</param>
        /// <returns>
        /// Zero (0) if the objects are equal, an non-zero integer value if not
        /// </returns>
        public override int CompareTo(MibValue other)
        {
            NumberValue nv = other as NumberValue;

            if (nv != null)
            {
                return(this.CompareToNumber((double)nv.Value));
            }

            return(this.ToString().CompareTo(other));
        }
Example #12
0
        /// <summary>
        /// Initializes the object. This will remove all levels of
        /// indirection present, such as references to other types and
        /// values.No information is lost by this operation.This method
        /// may modify this object as a side-effect, and will be called by
        /// the MIB loader.
        /// </summary>
        /// <param name="symbol">the MIB symbol containing this object</param>
        /// <param name="log">the MIB loader log</param>
        /// <exception cref="MibException">
        /// If an error was encountered during the initialization
        /// </exception>
        public void Initialize(MibSymbol symbol, MibLoaderLog log)
        {
            if (this.value != null)
            {
                this.value = this.value.Initialize(log, null);
            }

            if (this.type != null)
            {
                this.type = this.type.Initialize(symbol, log);
            }
        }
Example #13
0
        /// <summary>
        /// Checks if the specified value is compatible with this
        /// constraint.Only octet string values can be compatible with a
        /// size constraint, and only if the string length is compatible
        /// with the value range in the size constraint.
        /// </summary>
        /// <param name="value">The value to check</param>
        /// <returns>True if the value is compatible, false if not</returns>
        public bool IsCompatible(MibValue value)
        {
            int size;

            if (value is StringValue)
            {
                size = value.ToString().Length;
                return(this.values.IsCompatible(new NumberValue((BigInteger)size)));
            }

            return(false);
        }
Example #14
0
 /// <summary>
 /// Initializes a new instance of the <see cref="ObjectIdentifierValue"/> class.
 /// </summary>
 /// <param name="location">The declaration file location</param>
 /// <param name="parent">The component parent</param>
 /// <param name="name">The component name</param>
 /// <param name="value">The component value</param>
 public ObjectIdentifierValue(
     FileLocation location,
     ValueReference parent,
     string name,
     int value)
     : base("OBJECT IDENTIFIER")
 {
     this.location = location;
     this.parent   = parent;
     this.name     = name;
     this.value    = value;
 }
Example #15
0
        /// <summary>
        /// Checks if the specified value is compatible with this type. A
        /// values is considered compatible with this type, if it is
        /// compatible with any single type in the union.
        /// </summary>
        /// <param name="value">The value to check</param>
        /// <returns>True if the value is compatible, false if not</returns>
        public override bool IsCompatible(MibValue value)
        {
            foreach (ElementType elem in this.elements)
            {
                if (elem.IsCompatible(value))
                {
                    return(true);
                }
            }

            return(false);
        }
Example #16
0
        /// <summary>
        /// Initializes the MIB type. This will remove all levels of
        /// indirection present, such as references to types or values. No
        /// information is lost by this operation. This method may modify
        /// this object as a side-effect, and will return the basic
        /// type.
        /// NOTE: This is an internal method that should
        /// only be called by the MIB loader.
        /// </summary>
        /// <param name="symbol">The MIB symbol containing this type</param>
        /// <param name="log">The MIB loader log</param>
        /// <returns>The basic MIB type</returns>
        /// <exception cref="MibException">
        /// If an error was encountered during the initialization
        /// </exception>
        public override MibType Initialize(MibSymbol symbol, MibLoaderLog log)
        {
            if (!(symbol is MibValueSymbol))
            {
                throw new MibException(
                          symbol.Location,
                          "only values can have the " + Name + " type");
            }

            this.enterprise = this.enterprise.Initialize(log, null);
            this.variables  = this.variables.Select(v => v.Initialize(log, null)).ToList();
            return(this);
        }
Example #17
0
        /// <summary>
        /// Initializes the MIB type. This will remove all levels of
        /// indirection present, such as references to types or values. No
        /// information is lost by this operation. This method may modify
        /// this object as a side-effect, and will return the basic
        /// type.
        /// NOTE: This is an internal method that should
        /// only be called by the MIB loader.
        /// </summary>
        /// <param name="type">The MIB type</param>
        /// <param name="log">The MIB loader log</param>
        /// <exception cref="MibException">
        /// If an error is encountered during initialization
        /// </exception>
        public void Initialize(MibType type, MibLoaderLog log)
        {
            string message;

            this.value = this.value.Initialize(log, type);
            if (this.location != null && !this.IsCompatible(type))
            {
                message = "Value constraint not compatible with this type";
                log.AddWarning(this.location, message);
            }

            this.location = null;
        }
Example #18
0
        /// <summary>
        /// Initializes this object. This will remove all levels of
        /// indirection present, such as references to other types, and
        /// returns the basic type. No type information is lost by this
        /// operation. This method may modify this object as a
        /// side-effect, and will be called by the MIB loader.
        /// </summary>
        /// <param name="log">The MIB loader log</param>
        /// <exception cref="MibException">
        /// If an error was encountered during the initialization
        /// </exception>
        public void Initialize(MibLoaderLog log)
        {
            this.value = this.value.Initialize(log, null);

            if (this.syntax != null)
            {
                this.syntax = this.syntax.Initialize(null, log);
            }

            if (this.writeSyntax != null)
            {
                this.writeSyntax = this.writeSyntax.Initialize(null, log);
            }
        }
Example #19
0
        /// <summary>
        /// Initializes a the MIB value from a value reference. This will
        /// resolve the reference, and set the bit corresponding to the
        /// value.
        /// </summary>
        /// <param name="log">The MIB loader log</param>
        /// <param name="type">The value type</param>
        /// <param name="vref">The value reference to resolve</param>
        /// <exception cref="MibException">
        /// If an error occurred during initialization
        /// </exception>
        private void Initialize(MibLoaderLog log, MibType type, ValueReference vref)
        {
            MibValue val = vref.Initialize(log, type);

            if (val is NumberValue nv)
            {
                this.value.Set((int)nv.Value, true);
            }
            else
            {
                throw new MibException(
                          vref.Location,
                          "referenced value is not a number");
            }
        }
Example #20
0
 /// <summary>
 /// Initializes a new instance of the <see cref="SnmpCompliance"/> class.
 /// </summary>
 /// <param name="group">The group compliance flag</param>
 /// <param name="value">The compliance value</param>
 /// <param name="syntax">The value syntax, or null</param>
 /// <param name="writeSyntax">The value write syntax, or null</param>
 /// <param name="access">The access mode, or null</param>
 /// <param name="description">The compliance description</param>
 public SnmpCompliance(
     bool group,
     MibValue value,
     MibType syntax,
     MibType writeSyntax,
     SnmpAccess access,
     string description)
 {
     this.group       = group;
     this.value       = value;
     this.syntax      = syntax;
     this.writeSyntax = writeSyntax;
     this.access      = access;
     this.description = description;
 }
Example #21
0
 /// <summary>
 /// Initializes a new instance of the <see cref="SnmpVariation"/> class.
 /// </summary>
 /// <param name="value">the variation value</param>
 /// <param name="syntax">the value syntax, or null</param>
 /// <param name="writeSyntax">the value write syntax, or null</param>
 /// <param name="access">the access mode, or null</param>
 /// <param name="requiredCells">the cell values required for creation</param>
 /// <param name="defaultValue">the default value, or null</param>
 /// <param name="description">the variation description</param>
 public SnmpVariation(
     MibValue value,
     MibType syntax,
     MibType writeSyntax,
     SnmpAccess access,
     IList <MibValue> requiredCells,
     MibValue defaultValue,
     string description)
 {
     this.value         = value;
     this.syntax        = syntax;
     this.writeSyntax   = writeSyntax;
     this.access        = access;
     this.requiredCells = requiredCells;
     this.defaultValue  = defaultValue;
     this.description   = description;
 }
Example #22
0
        /// <summary>
        /// Initializes a new instance of the <see cref="ObjectIdentifierValue"/> class.
        /// </summary>
        /// <param name="location">The declaration file location</param>
        /// <param name="parent">The component parent</param>
        /// <param name="name">The component name</param>
        /// <param name="value">The component value</param>
        /// <exception cref="MibException">
        /// If the object identifier parent already has a child with
        /// the specified value
        /// </exception>
        public ObjectIdentifierValue(
            FileLocation location,
            ObjectIdentifierValue parent,
            string name,
            int value)
            : base("OBJECT IDENTIFIER")
        {
            this.parent = parent;
            this.name   = name;
            this.value  = value;
            if (parent.GetChildByValue(value) != null)
            {
                throw new MibException(
                          location,
                          "cannot add duplicate OID children with value " + value);
            }

            parent.AddChild(null, location, this);
        }
        /// <summary>
        /// Initializes the MIB value. This will remove all levels of
        /// indirection present, such as references to other values. No
        /// value information is lost by this operation. This method may
        /// modify this object as a side-effect, and will return the basic
        /// value.
        /// </summary>
        /// <remarks>
        /// This is an internal method that should
        /// only be called by the MIB loader.
        /// </remarks>
        /// <param name="log">The MIB Loader log</param>
        /// <param name="type">The value type</param>
        /// <returns>The basic MIB value</returns>
        public override MibValue Initialize(MibLoaderLog log, MibType type)
        {
            ValueReference        vref = null;
            ObjectIdentifierValue oid;

            if (this.parent == null)
            {
                return(this);
            }
            else if (this.parent is ValueReference)
            {
                vref = (ValueReference)this.parent;
            }

            this.parent = this.parent.Initialize(log, type);

            if (vref != null)
            {
                if (this.parent is ObjectIdentifierValue)
                {
                    oid = (ObjectIdentifierValue)this.parent;
                    oid.AddChild(log, this.location, this);
                }
                else
                {
                    throw new MibException(
                              vref.Location,
                              "referenced value is not an object identifier");
                }
            }

            this.location = null;

            if (this.parent is ObjectIdentifierValue)
            {
                return(((ObjectIdentifierValue)this.parent).GetChildByValue(this.value));
            }
            else
            {
                return(this);
            }
        }
Example #24
0
        /// <summary>
        /// Checks if the specified value is compatible with this
        /// constraint.
        /// </summary>
        /// <param name="value">The value to check</param>
        /// <returns>True if the value is compatible, or
        /// false otherwise
        /// </returns>
        public bool IsCompatible(MibValue value)
        {
            string str1 = this.value.ToString();
            string str2 = value.ToString();

            if (this.value is NumberValue &&
                value is NumberValue)
            {
                return(str1.Equals(str2));
            }
            else if (this.value is StringValue &&
                     value is StringValue)
            {
                return(str1.Equals(str2));
            }
            else
            {
                return(false);
            }
        }
Example #25
0
 /// <summary>
 /// Initializes a new instance of the <see cref="SnmpObjectType"/> class.
 /// </summary>
 /// <param name="syntax">The object type syntax</param>
 /// <param name="units">The units description, or null</param>
 /// <param name="access">The access mode</param>
 /// <param name="status">The type status</param>
 /// <param name="description">The type description, or null</param>
 /// <param name="reference">The type reference, or null</param>
 /// <param name="index">The list of index objects</param>
 /// <param name="defaultValue">The default value, or null</param>
 public SnmpObjectType(
     MibType syntax,
     string units,
     SnmpAccess access,
     SnmpStatus status,
     string description,
     string reference,
     IList <SnmpIndex> index,
     MibValue defaultValue)
     : base("OBJECT-TYPE", description)
 {
     this.syntax       = syntax;
     this.units        = units;
     this.access       = access;
     this.status       = status;
     this.reference    = reference;
     this.index        = index;
     this.augments     = null;
     this.defaultValue = defaultValue;
 }
Example #26
0
        /// <summary>
        /// Initializes the object. This will remove all levels of
        /// indirection present, such as references to other types, and
        /// returns the basic type. No information is lost by this operation.
        /// This method may modify this object as a side-effect, and will
        /// be called by the MIB loader.
        /// </summary>
        /// <param name="log">The MIB loader log</param>
        /// <exception cref="MibException">
        /// If an error occurred during initialization
        /// </exception>
        public void Initialize(MibLoaderLog log)
        {
            MibType type = null;

            this.value = this.value.Initialize(log, null);

            if (this.BaseSymbol != null)
            {
                // TODO: use utility function to retrieve correct base type here
                type = this.BaseSymbol.Type;

                if (type is SnmpTextualConvention convention)
                {
                    type = convention.Syntax;
                }

                if (type is SnmpObjectType type1)
                {
                    type = type1.Syntax;
                }
            }

            if (this.syntax != null)
            {
                this.syntax = this.syntax.Initialize(null, log);
            }

            if (this.writeSyntax != null)
            {
                this.writeSyntax = this.writeSyntax.Initialize(null, log);
            }

            this.requiredCells = this.requiredCells.Select(rc => rc.Initialize(log, type)).ToList();

            if (this.defaultValue != null)
            {
                this.defaultValue = this.defaultValue.Initialize(log, type);
            }
        }
Example #27
0
 /// <summary>
 /// Checks if the specified value is compatible with this type.
 /// The value is considered compatible with this type, if and only
 /// if it is a null value
 /// </summary>
 /// <param name="value">The value to check</param>
 /// <returns>true if the value is compatible, false otherwise</returns>
 public override bool IsCompatible(MibValue value)
 {
     return(value is NullValue);
 }
Example #28
0
 /// <summary>
 /// Checks if the specified value is compatible with this type. A
 /// value is compatible if and only if it is an object identifier
 /// value.
 /// </summary>
 /// <param name="value">The value to check for compatibility</param>
 /// <returns>True if the value is compatible, false if not</returns>
 public override bool IsCompatible(MibValue value)
 {
     return(value is ObjectIdentifierValue);
 }
 /// <summary>
 /// Checks if the specified value is compatible with this type. No
 /// value is compatible with this type, so this method always
 /// returns false.
 /// </summary>
 /// <param name="value">The value to check</param>
 /// <returns>True if the value is compatible, false if not</returns>
 public override bool IsCompatible(MibValue value)
 {
     return(false);
 }
Example #30
0
 /// <summary>
 /// Checks if the specified value is compatible with this type. A
 /// value is compatible if and only if it is a boolean value.
 /// </summary>
 /// <param name="value">The value to be checked</param>
 /// <returns>True if the value is compatible, false if not</returns>
 public override bool IsCompatible(MibValue value)
 {
     return(value is BooleanValue);
 }