pysnmp-se-3.5.2.tar.gz_SNMP_SNMP Agent_pysnmp_pysnmp-apps_snmp m

""" A framework for implementing ASN.1 data types. Copyright 1999-2002 by Ilya Etingof <ilya@glas.net>. See LICENSE for details. """ # Module public names __all__ = [ 'tagClasses', 'tagFormats', 'tagCategories', 'SimpleAsn1Object', \ 'RecordTypeAsn1Object', 'ChoiceTypeAsn1Object', \ 'VariableTypeAsn1Object' ] try: from sys import version_info except ImportError: version_info = (0,0) from operator import getslice, setslice, delslice try: enumerate except NameError: def enumerate( iterable ): i = 0 for x in iterable: yield i,x i+=1 from types import * from pysnmp.asn1 import error from pysnmp.error import PySnmpError import operator # ASN.1 tagging tagClasses = { 'UNIVERSAL' : 0x00, 'APPLICATION' : 0x40, 'CONTEXT' : 0x80, 'PRIVATE' : 0xC0 } tagFormats = { 'SIMPLE' : 0x00, 'CONSTRUCTED' : 0x20 } tagCategories = { 'IMPLICIT' : 0x01, 'EXPLICIT' : 0x02, 'UNTAGGED' : 0x04 } class Asn1Object: """Base class for all ASN.1 objects """ # # ASN.1 tags # tagClass = tagClasses['UNIVERSAL'] tagFormat = None tagId = None tagCategory = tagCategories['IMPLICIT'] # # Argument type constraint # allowedTypes = () # # Subtyping stuff # # A list of constraints.Constraint instances for checking values constraints = () def _subtype_constraint(self, value): """All constraints checking method """ for c in self.constraints: c( self, value ) return def _type_constraint(self, value): """Constraint checking to see if value is of an acceptable type """ if self.allowedTypes: if not isinstance(value, self.allowedTypes): raise error.ValueConstraintError('Value type constraint for %s: %s not in %s' % (self.__class__.__name__, type(value), str(self.allowedTypes))) def getUnderlyingTag(self): """ """ for superClass in self.__class__.__bases__: if issubclass(self.__class__, superClass): break else: raise error.BadArgumentError('No underlying type for %s' % \ self.__class__.__name__) return (superClass.tagClass, superClass.tagFormat, superClass.tagId) class SimpleAsn1Object(Asn1Object): """Base class for a simple ASN.1 object. Defines behaviour and properties of various non-structured ASN.1 objects. """ tagFormat = tagFormats['SIMPLE'] tagId = 0x00 initialValue = None # Disable not applicible constraints _subtype_inner_subtype_constraint = None def __init__(self, value=None): """Store ASN.1 value """ self.set(value) def __str__(self): """Return string representation of class instance """ return '%s: %s' % (self.__class__.__name__, str(self.get())) def __repr__(self): """Return native representation of instance payload """ return self.__class__.__name__ + '(' + repr(self.get()) + ')' def __cmp__(self, other): """Attempt to compare the payload of instances of the same class """ if hasattr(self, '_cmp'): return self._cmp(other) if isinstance(other, SimpleAsn1Object): if not isinstance(other, self.__class__): try: other = self.componentFactoryBorrow(other.get()) except PySnmpError: # Hide coercion errors return -1 else: try: other = self.componentFactoryBorrow(other) except PySnmpError: # Hide coercion errors return -1 return cmp(self.rawAsn1Value, other.rawAsn1Value) def __hash__(self): """Returns hash of the payload value """ try: return hash(self.rawAsn1Value) except TypeError: # Attempt to hash sequence value return reduce(operator.xor, map(hash, self.rawAsn1Value), hash(None)) def __nonzero__(self): """Returns true if value is true """ if self.rawAsn1Value: return 1 else: return 0 # caching types for _setRawAsn1Value instead of rebuilding tuple # for each call (minor speedup) NORMAL_STATIC_TYPES = (IntType,LongType,StringType,NoneType,FloatType,TupleType) def _setRawAsn1Value(self, value): self._subtype_constraint(value) # Supported mutable type if isinstance( value, list ): # Copy mutable object # XXX This line is most of the overhead of the method, doesn't # seem ammenable to optimisation? Other than possibly watching # for cases where we could optimise away the copy? # That would require tracking (boolean) whether we know the value # has been created anew for us, I'm guessing that in most cases # it already has been? Something to look at later. self.rawAsn1Value = value[:] # Supported immutable types elif isinstance( value, self.NORMAL_STATIC_TYPES): self.rawAsn1Value = value else: raise error.BadArgumentError('Unsupported value type to hold at %s: %s' % (self.__class__.__name__, valType)) def componentFactoryBorrow(self, value=None): if not hasattr(self, '_componentCache'): self._componentCache = self.__class__() if value is not None: self._componentCache.set(value) return self._componentCache # # Simple ASN.1 object protocol definition # def set(self, value): """Set a value to object """ if value is None: initial = self.initialValue if callable(initial): return initial() elif initial is None: self.rawAsn1Value = initial return value = initial # Allow initalization from instances if isinstance(value, SimpleAsn1Object): # Save on same-type instances if isinstance(value, self.__class__): self._setRawAsn1Value(value.rawAsn1Value) else: self.set(value.get()) return self._type_constraint(value) if hasattr(self, '_iconv'): value = self._iconv(value) self._setRawAsn1Value(value) def get(self): """Get a value from object """ if hasattr(self, '_oconv'): return self._oconv(self.rawAsn1Value) return self.rawAsn1Value # XXX left for compatibility def getTerminal(self): return self class StructuredAsn1Object(Asn1Object): """Base class for structured ASN.1 objects """ tagFormat = tagFormats['CONSTRUCTED'] # Disable not applicible constraints _subtype_value_range_constraint = None _subtype_permitted_alphabet_constraint = None class FixedTypeAsn1Object(StructuredAsn1Object): """Base class for fixed-type ASN.1 objects """ # Disable not applicible constraints _subtype_size_constraint = None def __init__(self): """Initialize object internals """ # Dictionary emulation (for strict ordering) self._names = [] self._components = {} def __str__(self): """Return string representation of class instance """ s = ', '.join( [ '%s: %s' % (name, self._components[name]) for name in self._names ]) return '%s: %s' % (self.__class__.__name__, s) def __repr__(self): """Return nativ