|
@@ -0,0 +1,1042 @@
|
|
|
+# ASN.1 "universal" data types
|
|
|
+import operator, sys
|
|
|
+from pyasn1.type import base, tag, constraint, namedtype, namedval, tagmap
|
|
|
+from pyasn1.codec.ber import eoo
|
|
|
+from pyasn1.compat import octets
|
|
|
+from pyasn1 import error
|
|
|
+
|
|
|
+# "Simple" ASN.1 types (yet incomplete)
|
|
|
+
|
|
|
+class Integer(base.AbstractSimpleAsn1Item):
|
|
|
+ tagSet = baseTagSet = tag.initTagSet(
|
|
|
+ tag.Tag(tag.tagClassUniversal, tag.tagFormatSimple, 0x02)
|
|
|
+ )
|
|
|
+ namedValues = namedval.NamedValues()
|
|
|
+ def __init__(self, value=None, tagSet=None, subtypeSpec=None,
|
|
|
+ namedValues=None):
|
|
|
+ if namedValues is None:
|
|
|
+ self.__namedValues = self.namedValues
|
|
|
+ else:
|
|
|
+ self.__namedValues = namedValues
|
|
|
+ base.AbstractSimpleAsn1Item.__init__(
|
|
|
+ self, value, tagSet, subtypeSpec
|
|
|
+ )
|
|
|
+
|
|
|
+ def __and__(self, value): return self.clone(self._value & value)
|
|
|
+ def __rand__(self, value): return self.clone(value & self._value)
|
|
|
+ def __or__(self, value): return self.clone(self._value | value)
|
|
|
+ def __ror__(self, value): return self.clone(value | self._value)
|
|
|
+ def __xor__(self, value): return self.clone(self._value ^ value)
|
|
|
+ def __rxor__(self, value): return self.clone(value ^ self._value)
|
|
|
+ def __lshift__(self, value): return self.clone(self._value << value)
|
|
|
+ def __rshift__(self, value): return self.clone(self._value >> value)
|
|
|
+
|
|
|
+ def __add__(self, value): return self.clone(self._value + value)
|
|
|
+ def __radd__(self, value): return self.clone(value + self._value)
|
|
|
+ def __sub__(self, value): return self.clone(self._value - value)
|
|
|
+ def __rsub__(self, value): return self.clone(value - self._value)
|
|
|
+ def __mul__(self, value): return self.clone(self._value * value)
|
|
|
+ def __rmul__(self, value): return self.clone(value * self._value)
|
|
|
+ def __mod__(self, value): return self.clone(self._value % value)
|
|
|
+ def __rmod__(self, value): return self.clone(value % self._value)
|
|
|
+ def __pow__(self, value, modulo=None): return self.clone(pow(self._value, value, modulo))
|
|
|
+ def __rpow__(self, value): return self.clone(pow(value, self._value))
|
|
|
+
|
|
|
+ if sys.version_info[0] <= 2:
|
|
|
+ def __div__(self, value): return self.clone(self._value // value)
|
|
|
+ def __rdiv__(self, value): return self.clone(value // self._value)
|
|
|
+ else:
|
|
|
+ def __truediv__(self, value): return self.clone(self._value / value)
|
|
|
+ def __rtruediv__(self, value): return self.clone(value / self._value)
|
|
|
+ def __divmod__(self, value): return self.clone(self._value // value)
|
|
|
+ def __rdivmod__(self, value): return self.clone(value // self._value)
|
|
|
+
|
|
|
+ __hash__ = base.AbstractSimpleAsn1Item.__hash__
|
|
|
+
|
|
|
+ def __int__(self): return int(self._value)
|
|
|
+ if sys.version_info[0] <= 2:
|
|
|
+ def __long__(self): return long(self._value)
|
|
|
+ def __float__(self): return float(self._value)
|
|
|
+ def __abs__(self): return abs(self._value)
|
|
|
+ def __index__(self): return int(self._value)
|
|
|
+
|
|
|
+ def __lt__(self, value): return self._value < value
|
|
|
+ def __le__(self, value): return self._value <= value
|
|
|
+ def __eq__(self, value): return self._value == value
|
|
|
+ def __ne__(self, value): return self._value != value
|
|
|
+ def __gt__(self, value): return self._value > value
|
|
|
+ def __ge__(self, value): return self._value >= value
|
|
|
+
|
|
|
+ def prettyIn(self, value):
|
|
|
+ if not isinstance(value, str):
|
|
|
+ try:
|
|
|
+ return int(value)
|
|
|
+ except:
|
|
|
+ raise error.PyAsn1Error(
|
|
|
+ 'Can\'t coerce %s into integer: %s' % (value, sys.exc_info()[1])
|
|
|
+ )
|
|
|
+ r = self.__namedValues.getValue(value)
|
|
|
+ if r is not None:
|
|
|
+ return r
|
|
|
+ try:
|
|
|
+ return int(value)
|
|
|
+ except:
|
|
|
+ raise error.PyAsn1Error(
|
|
|
+ 'Can\'t coerce %s into integer: %s' % (value, sys.exc_info()[1])
|
|
|
+ )
|
|
|
+
|
|
|
+ def prettyOut(self, value):
|
|
|
+ r = self.__namedValues.getName(value)
|
|
|
+ return r is None and str(value) or repr(r)
|
|
|
+
|
|
|
+ def getNamedValues(self): return self.__namedValues
|
|
|
+
|
|
|
+ def clone(self, value=None, tagSet=None, subtypeSpec=None,
|
|
|
+ namedValues=None):
|
|
|
+ if value is None and tagSet is None and subtypeSpec is None \
|
|
|
+ and namedValues is None:
|
|
|
+ return self
|
|
|
+ if value is None:
|
|
|
+ value = self._value
|
|
|
+ if tagSet is None:
|
|
|
+ tagSet = self._tagSet
|
|
|
+ if subtypeSpec is None:
|
|
|
+ subtypeSpec = self._subtypeSpec
|
|
|
+ if namedValues is None:
|
|
|
+ namedValues = self.__namedValues
|
|
|
+ return self.__class__(value, tagSet, subtypeSpec, namedValues)
|
|
|
+
|
|
|
+ def subtype(self, value=None, implicitTag=None, explicitTag=None,
|
|
|
+ subtypeSpec=None, namedValues=None):
|
|
|
+ if value is None:
|
|
|
+ value = self._value
|
|
|
+ if implicitTag is not None:
|
|
|
+ tagSet = self._tagSet.tagImplicitly(implicitTag)
|
|
|
+ elif explicitTag is not None:
|
|
|
+ tagSet = self._tagSet.tagExplicitly(explicitTag)
|
|
|
+ else:
|
|
|
+ tagSet = self._tagSet
|
|
|
+ if subtypeSpec is None:
|
|
|
+ subtypeSpec = self._subtypeSpec
|
|
|
+ else:
|
|
|
+ subtypeSpec = subtypeSpec + self._subtypeSpec
|
|
|
+ if namedValues is None:
|
|
|
+ namedValues = self.__namedValues
|
|
|
+ else:
|
|
|
+ namedValues = namedValues + self.__namedValues
|
|
|
+ return self.__class__(value, tagSet, subtypeSpec, namedValues)
|
|
|
+
|
|
|
+class Boolean(Integer):
|
|
|
+ tagSet = baseTagSet = tag.initTagSet(
|
|
|
+ tag.Tag(tag.tagClassUniversal, tag.tagFormatSimple, 0x01),
|
|
|
+ )
|
|
|
+ subtypeSpec = Integer.subtypeSpec+constraint.SingleValueConstraint(0,1)
|
|
|
+ namedValues = Integer.namedValues.clone(('False', 0), ('True', 1))
|
|
|
+
|
|
|
+class BitString(base.AbstractSimpleAsn1Item):
|
|
|
+ tagSet = baseTagSet = tag.initTagSet(
|
|
|
+ tag.Tag(tag.tagClassUniversal, tag.tagFormatSimple, 0x03)
|
|
|
+ )
|
|
|
+ namedValues = namedval.NamedValues()
|
|
|
+ def __init__(self, value=None, tagSet=None, subtypeSpec=None,
|
|
|
+ namedValues=None):
|
|
|
+ if namedValues is None:
|
|
|
+ self.__namedValues = self.namedValues
|
|
|
+ else:
|
|
|
+ self.__namedValues = namedValues
|
|
|
+ base.AbstractSimpleAsn1Item.__init__(
|
|
|
+ self, value, tagSet, subtypeSpec
|
|
|
+ )
|
|
|
+
|
|
|
+ def clone(self, value=None, tagSet=None, subtypeSpec=None,
|
|
|
+ namedValues=None):
|
|
|
+ if value is None and tagSet is None and subtypeSpec is None \
|
|
|
+ and namedValues is None:
|
|
|
+ return self
|
|
|
+ if value is None:
|
|
|
+ value = self._value
|
|
|
+ if tagSet is None:
|
|
|
+ tagSet = self._tagSet
|
|
|
+ if subtypeSpec is None:
|
|
|
+ subtypeSpec = self._subtypeSpec
|
|
|
+ if namedValues is None:
|
|
|
+ namedValues = self.__namedValues
|
|
|
+ return self.__class__(value, tagSet, subtypeSpec, namedValues)
|
|
|
+
|
|
|
+ def subtype(self, value=None, implicitTag=None, explicitTag=None,
|
|
|
+ subtypeSpec=None, namedValues=None):
|
|
|
+ if value is None:
|
|
|
+ value = self._value
|
|
|
+ if implicitTag is not None:
|
|
|
+ tagSet = self._tagSet.tagImplicitly(implicitTag)
|
|
|
+ elif explicitTag is not None:
|
|
|
+ tagSet = self._tagSet.tagExplicitly(explicitTag)
|
|
|
+ else:
|
|
|
+ tagSet = self._tagSet
|
|
|
+ if subtypeSpec is None:
|
|
|
+ subtypeSpec = self._subtypeSpec
|
|
|
+ else:
|
|
|
+ subtypeSpec = subtypeSpec + self._subtypeSpec
|
|
|
+ if namedValues is None:
|
|
|
+ namedValues = self.__namedValues
|
|
|
+ else:
|
|
|
+ namedValues = namedValues + self.__namedValues
|
|
|
+ return self.__class__(value, tagSet, subtypeSpec, namedValues)
|
|
|
+
|
|
|
+ def __str__(self): return str(tuple(self))
|
|
|
+
|
|
|
+ # Immutable sequence object protocol
|
|
|
+
|
|
|
+ def __len__(self):
|
|
|
+ if self._len is None:
|
|
|
+ self._len = len(self._value)
|
|
|
+ return self._len
|
|
|
+ def __getitem__(self, i):
|
|
|
+ if isinstance(i, slice):
|
|
|
+ return self.clone(operator.getitem(self._value, i))
|
|
|
+ else:
|
|
|
+ return self._value[i]
|
|
|
+
|
|
|
+ def __add__(self, value): return self.clone(self._value + value)
|
|
|
+ def __radd__(self, value): return self.clone(value + self._value)
|
|
|
+ def __mul__(self, value): return self.clone(self._value * value)
|
|
|
+ def __rmul__(self, value): return self * value
|
|
|
+
|
|
|
+ def prettyIn(self, value):
|
|
|
+ r = []
|
|
|
+ if not value:
|
|
|
+ return ()
|
|
|
+ elif isinstance(value, str):
|
|
|
+ if value[0] == '\'':
|
|
|
+ if value[-2:] == '\'B':
|
|
|
+ for v in value[1:-2]:
|
|
|
+ if v == '0':
|
|
|
+ r.append(0)
|
|
|
+ elif v == '1':
|
|
|
+ r.append(1)
|
|
|
+ else:
|
|
|
+ raise error.PyAsn1Error(
|
|
|
+ 'Non-binary BIT STRING initializer %s' % (v,)
|
|
|
+ )
|
|
|
+ return tuple(r)
|
|
|
+ elif value[-2:] == '\'H':
|
|
|
+ for v in value[1:-2]:
|
|
|
+ i = 4
|
|
|
+ v = int(v, 16)
|
|
|
+ while i:
|
|
|
+ i = i - 1
|
|
|
+ r.append((v>>i)&0x01)
|
|
|
+ return tuple(r)
|
|
|
+ else:
|
|
|
+ raise error.PyAsn1Error(
|
|
|
+ 'Bad BIT STRING value notation %s' % (value,)
|
|
|
+ )
|
|
|
+ else:
|
|
|
+ for i in value.split(','):
|
|
|
+ j = self.__namedValues.getValue(i)
|
|
|
+ if j is None:
|
|
|
+ raise error.PyAsn1Error(
|
|
|
+ 'Unknown bit identifier \'%s\'' % (i,)
|
|
|
+ )
|
|
|
+ if j >= len(r):
|
|
|
+ r.extend([0]*(j-len(r)+1))
|
|
|
+ r[j] = 1
|
|
|
+ return tuple(r)
|
|
|
+ elif isinstance(value, (tuple, list)):
|
|
|
+ r = tuple(value)
|
|
|
+ for b in r:
|
|
|
+ if b and b != 1:
|
|
|
+ raise error.PyAsn1Error(
|
|
|
+ 'Non-binary BitString initializer \'%s\'' % (r,)
|
|
|
+ )
|
|
|
+ return r
|
|
|
+ elif isinstance(value, BitString):
|
|
|
+ return tuple(value)
|
|
|
+ else:
|
|
|
+ raise error.PyAsn1Error(
|
|
|
+ 'Bad BitString initializer type \'%s\'' % (value,)
|
|
|
+ )
|
|
|
+
|
|
|
+ def prettyOut(self, value):
|
|
|
+ return '\"\'%s\'B\"' % ''.join([str(x) for x in value])
|
|
|
+
|
|
|
+class OctetString(base.AbstractSimpleAsn1Item):
|
|
|
+ tagSet = baseTagSet = tag.initTagSet(
|
|
|
+ tag.Tag(tag.tagClassUniversal, tag.tagFormatSimple, 0x04)
|
|
|
+ )
|
|
|
+ defaultBinValue = defaultHexValue = base.noValue
|
|
|
+ encoding = 'us-ascii'
|
|
|
+ def __init__(self, value=None, tagSet=None, subtypeSpec=None,
|
|
|
+ encoding=None, binValue=None, hexValue=None):
|
|
|
+ if encoding is None:
|
|
|
+ self._encoding = self.encoding
|
|
|
+ else:
|
|
|
+ self._encoding = encoding
|
|
|
+ if binValue is not None:
|
|
|
+ value = self.fromBinaryString(binValue)
|
|
|
+ if hexValue is not None:
|
|
|
+ value = self.fromHexString(hexValue)
|
|
|
+ if value is None or value is base.noValue:
|
|
|
+ value = self.defaultHexValue
|
|
|
+ if value is None or value is base.noValue:
|
|
|
+ value = self.defaultBinValue
|
|
|
+ self.__intValue = None
|
|
|
+ base.AbstractSimpleAsn1Item.__init__(self, value, tagSet, subtypeSpec)
|
|
|
+
|
|
|
+ def clone(self, value=None, tagSet=None, subtypeSpec=None,
|
|
|
+ encoding=None, binValue=None, hexValue=None):
|
|
|
+ if value is None and tagSet is None and subtypeSpec is None and \
|
|
|
+ encoding is None and binValue is None and hexValue is None:
|
|
|
+ return self
|
|
|
+ if value is None and binValue is None and hexValue is None:
|
|
|
+ value = self._value
|
|
|
+ if tagSet is None:
|
|
|
+ tagSet = self._tagSet
|
|
|
+ if subtypeSpec is None:
|
|
|
+ subtypeSpec = self._subtypeSpec
|
|
|
+ if encoding is None:
|
|
|
+ encoding = self._encoding
|
|
|
+ return self.__class__(
|
|
|
+ value, tagSet, subtypeSpec, encoding, binValue, hexValue
|
|
|
+ )
|
|
|
+
|
|
|
+ if sys.version_info[0] <= 2:
|
|
|
+ def prettyIn(self, value):
|
|
|
+ if isinstance(value, str):
|
|
|
+ return value
|
|
|
+ elif isinstance(value, (tuple, list)):
|
|
|
+ try:
|
|
|
+ return ''.join([ chr(x) for x in value ])
|
|
|
+ except ValueError:
|
|
|
+ raise error.PyAsn1Error(
|
|
|
+ 'Bad OctetString initializer \'%s\'' % (value,)
|
|
|
+ )
|
|
|
+ else:
|
|
|
+ return str(value)
|
|
|
+ else:
|
|
|
+ def prettyIn(self, value):
|
|
|
+ if isinstance(value, bytes):
|
|
|
+ return value
|
|
|
+ elif isinstance(value, OctetString):
|
|
|
+ return value.asOctets()
|
|
|
+ elif isinstance(value, (tuple, list, map)):
|
|
|
+ try:
|
|
|
+ return bytes(value)
|
|
|
+ except ValueError:
|
|
|
+ raise error.PyAsn1Error(
|
|
|
+ 'Bad OctetString initializer \'%s\'' % (value,)
|
|
|
+ )
|
|
|
+ else:
|
|
|
+ try:
|
|
|
+ return str(value).encode(self._encoding)
|
|
|
+ except UnicodeEncodeError:
|
|
|
+ raise error.PyAsn1Error(
|
|
|
+ 'Can\'t encode string \'%s\' with \'%s\' codec' % (value, self._encoding)
|
|
|
+ )
|
|
|
+
|
|
|
+
|
|
|
+ def fromBinaryString(self, value):
|
|
|
+ bitNo = 8; byte = 0; r = ()
|
|
|
+ for v in value:
|
|
|
+ if bitNo:
|
|
|
+ bitNo = bitNo - 1
|
|
|
+ else:
|
|
|
+ bitNo = 7
|
|
|
+ r = r + (byte,)
|
|
|
+ byte = 0
|
|
|
+ if v == '0':
|
|
|
+ v = 0
|
|
|
+ elif v == '1':
|
|
|
+ v = 1
|
|
|
+ else:
|
|
|
+ raise error.PyAsn1Error(
|
|
|
+ 'Non-binary OCTET STRING initializer %s' % (v,)
|
|
|
+ )
|
|
|
+ byte = byte | (v << bitNo)
|
|
|
+ return octets.ints2octs(r + (byte,))
|
|
|
+
|
|
|
+ def fromHexString(self, value):
|
|
|
+ r = p = ()
|
|
|
+ for v in value:
|
|
|
+ if p:
|
|
|
+ r = r + (int(p+v, 16),)
|
|
|
+ p = ()
|
|
|
+ else:
|
|
|
+ p = v
|
|
|
+ if p:
|
|
|
+ r = r + (int(p+'0', 16),)
|
|
|
+ return octets.ints2octs(r)
|
|
|
+
|
|
|
+ def prettyOut(self, value):
|
|
|
+ if sys.version_info[0] <= 2:
|
|
|
+ numbers = tuple([ ord(x) for x in value ])
|
|
|
+ else:
|
|
|
+ numbers = tuple(value)
|
|
|
+ if [ x for x in numbers if x < 32 or x > 126 ]:
|
|
|
+ return '0x' + ''.join([ '%.2x' % x for x in numbers ])
|
|
|
+ else:
|
|
|
+ return str(value)
|
|
|
+
|
|
|
+ def __repr__(self):
|
|
|
+ if self._value is base.noValue:
|
|
|
+ return self.__class__.__name__ + '()'
|
|
|
+ if [ x for x in self.asNumbers() if x < 32 or x > 126 ]:
|
|
|
+ return self.__class__.__name__ + '(hexValue=\'' + ''.join([ '%.2x' % x for x in self.asNumbers() ])+'\')'
|
|
|
+ else:
|
|
|
+ return self.__class__.__name__ + '(\'' + self.prettyOut(self._value) + '\')'
|
|
|
+
|
|
|
+ if sys.version_info[0] <= 2:
|
|
|
+ def __str__(self): return str(self._value)
|
|
|
+ def __unicode__(self):
|
|
|
+ return self._value.decode(self._encoding, 'ignore')
|
|
|
+ def asOctets(self): return self._value
|
|
|
+ def asNumbers(self):
|
|
|
+ if self.__intValue is None:
|
|
|
+ self.__intValue = tuple([ ord(x) for x in self._value ])
|
|
|
+ return self.__intValue
|
|
|
+ else:
|
|
|
+ def __str__(self): return self._value.decode(self._encoding, 'ignore')
|
|
|
+ def __bytes__(self): return self._value
|
|
|
+ def asOctets(self): return self._value
|
|
|
+ def asNumbers(self):
|
|
|
+ if self.__intValue is None:
|
|
|
+ self.__intValue = tuple(self._value)
|
|
|
+ return self.__intValue
|
|
|
+
|
|
|
+ # Immutable sequence object protocol
|
|
|
+
|
|
|
+ def __len__(self):
|
|
|
+ if self._len is None:
|
|
|
+ self._len = len(self._value)
|
|
|
+ return self._len
|
|
|
+ def __getitem__(self, i):
|
|
|
+ if isinstance(i, slice):
|
|
|
+ return self.clone(operator.getitem(self._value, i))
|
|
|
+ else:
|
|
|
+ return self._value[i]
|
|
|
+
|
|
|
+ def __add__(self, value): return self.clone(self._value + self.prettyIn(value))
|
|
|
+ def __radd__(self, value): return self.clone(self.prettyIn(value) + self._value)
|
|
|
+ def __mul__(self, value): return self.clone(self._value * value)
|
|
|
+ def __rmul__(self, value): return self * value
|
|
|
+
|
|
|
+class Null(OctetString):
|
|
|
+ defaultValue = ''.encode() # This is tightly constrained
|
|
|
+ tagSet = baseTagSet = tag.initTagSet(
|
|
|
+ tag.Tag(tag.tagClassUniversal, tag.tagFormatSimple, 0x05)
|
|
|
+ )
|
|
|
+ subtypeSpec = OctetString.subtypeSpec+constraint.SingleValueConstraint(''.encode())
|
|
|
+
|
|
|
+if sys.version_info[0] <= 2:
|
|
|
+ intTypes = (int, long)
|
|
|
+else:
|
|
|
+ intTypes = int
|
|
|
+
|
|
|
+class ObjectIdentifier(base.AbstractSimpleAsn1Item):
|
|
|
+ tagSet = baseTagSet = tag.initTagSet(
|
|
|
+ tag.Tag(tag.tagClassUniversal, tag.tagFormatSimple, 0x06)
|
|
|
+ )
|
|
|
+ def __add__(self, other): return self.clone(self._value + other)
|
|
|
+ def __radd__(self, other): return self.clone(other + self._value)
|
|
|
+
|
|
|
+ def asTuple(self): return self._value
|
|
|
+
|
|
|
+ # Sequence object protocol
|
|
|
+
|
|
|
+ def __len__(self):
|
|
|
+ if self._len is None:
|
|
|
+ self._len = len(self._value)
|
|
|
+ return self._len
|
|
|
+ def __getitem__(self, i):
|
|
|
+ if isinstance(i, slice):
|
|
|
+ return self.clone(
|
|
|
+ operator.getitem(self._value, i)
|
|
|
+ )
|
|
|
+ else:
|
|
|
+ return self._value[i]
|
|
|
+
|
|
|
+ def __str__(self): return self.prettyPrint()
|
|
|
+
|
|
|
+ def index(self, suboid): return self._value.index(suboid)
|
|
|
+
|
|
|
+ def isPrefixOf(self, value):
|
|
|
+ """Returns true if argument OID resides deeper in the OID tree"""
|
|
|
+ l = len(self)
|
|
|
+ if l <= len(value):
|
|
|
+ if self._value[:l] == value[:l]:
|
|
|
+ return 1
|
|
|
+ return 0
|
|
|
+
|
|
|
+ def prettyIn(self, value):
|
|
|
+ """Dotted -> tuple of numerics OID converter"""
|
|
|
+ if isinstance(value, tuple):
|
|
|
+ pass
|
|
|
+ elif isinstance(value, ObjectIdentifier):
|
|
|
+ return tuple(value)
|
|
|
+ elif isinstance(value, str):
|
|
|
+ r = []
|
|
|
+ for element in [ x for x in value.split('.') if x != '' ]:
|
|
|
+ try:
|
|
|
+ r.append(int(element, 0))
|
|
|
+ except ValueError:
|
|
|
+ raise error.PyAsn1Error(
|
|
|
+ 'Malformed Object ID %s at %s: %s' %
|
|
|
+ (str(value), self.__class__.__name__, sys.exc_info()[1])
|
|
|
+ )
|
|
|
+ value = tuple(r)
|
|
|
+ else:
|
|
|
+ try:
|
|
|
+ value = tuple(value)
|
|
|
+ except TypeError:
|
|
|
+ raise error.PyAsn1Error(
|
|
|
+ 'Malformed Object ID %s at %s: %s' %
|
|
|
+ (str(value), self.__class__.__name__,sys.exc_info()[1])
|
|
|
+ )
|
|
|
+
|
|
|
+ for x in value:
|
|
|
+ if not isinstance(x, intTypes) or x < 0:
|
|
|
+ raise error.PyAsn1Error(
|
|
|
+ 'Invalid sub-ID in %s at %s' % (value, self.__class__.__name__)
|
|
|
+ )
|
|
|
+
|
|
|
+ return value
|
|
|
+
|
|
|
+ def prettyOut(self, value): return '.'.join([ str(x) for x in value ])
|
|
|
+
|
|
|
+class Real(base.AbstractSimpleAsn1Item):
|
|
|
+ try:
|
|
|
+ _plusInf = float('inf')
|
|
|
+ _minusInf = float('-inf')
|
|
|
+ _inf = (_plusInf, _minusInf)
|
|
|
+ except ValueError:
|
|
|
+ # Infinity support is platform and Python dependent
|
|
|
+ _plusInf = _minusInf = None
|
|
|
+ _inf = ()
|
|
|
+
|
|
|
+ tagSet = baseTagSet = tag.initTagSet(
|
|
|
+ tag.Tag(tag.tagClassUniversal, tag.tagFormatSimple, 0x09)
|
|
|
+ )
|
|
|
+
|
|
|
+ def __normalizeBase10(self, value):
|
|
|
+ m, b, e = value
|
|
|
+ while m and m % 10 == 0:
|
|
|
+ m = m / 10
|
|
|
+ e = e + 1
|
|
|
+ return m, b, e
|
|
|
+
|
|
|
+ def prettyIn(self, value):
|
|
|
+ if isinstance(value, tuple) and len(value) == 3:
|
|
|
+ for d in value:
|
|
|
+ if not isinstance(d, intTypes):
|
|
|
+ raise error.PyAsn1Error(
|
|
|
+ 'Lame Real value syntax: %s' % (value,)
|
|
|
+ )
|
|
|
+ if value[1] not in (2, 10):
|
|
|
+ raise error.PyAsn1Error(
|
|
|
+ 'Prohibited base for Real value: %s' % (value[1],)
|
|
|
+ )
|
|
|
+ if value[1] == 10:
|
|
|
+ value = self.__normalizeBase10(value)
|
|
|
+ return value
|
|
|
+ elif isinstance(value, intTypes):
|
|
|
+ return self.__normalizeBase10((value, 10, 0))
|
|
|
+ elif isinstance(value, float):
|
|
|
+ if self._inf and value in self._inf:
|
|
|
+ return value
|
|
|
+ else:
|
|
|
+ e = 0
|
|
|
+ while int(value) != value:
|
|
|
+ value = value * 10
|
|
|
+ e = e - 1
|
|
|
+ return self.__normalizeBase10((int(value), 10, e))
|
|
|
+ elif isinstance(value, Real):
|
|
|
+ return tuple(value)
|
|
|
+ elif isinstance(value, str): # handle infinite literal
|
|
|
+ try:
|
|
|
+ return float(value)
|
|
|
+ except ValueError:
|
|
|
+ pass
|
|
|
+ raise error.PyAsn1Error(
|
|
|
+ 'Bad real value syntax: %s' % (value,)
|
|
|
+ )
|
|
|
+
|
|
|
+ def prettyOut(self, value):
|
|
|
+ if value in self._inf:
|
|
|
+ return '\'%s\'' % value
|
|
|
+ else:
|
|
|
+ return str(value)
|
|
|
+
|
|
|
+ def isPlusInfinity(self): return self._value == self._plusInf
|
|
|
+ def isMinusInfinity(self): return self._value == self._minusInf
|
|
|
+ def isInfinity(self): return self._value in self._inf
|
|
|
+
|
|
|
+ def __str__(self): return str(float(self))
|
|
|
+
|
|
|
+ def __add__(self, value): return self.clone(float(self) + value)
|
|
|
+ def __radd__(self, value): return self + value
|
|
|
+ def __mul__(self, value): return self.clone(float(self) * value)
|
|
|
+ def __rmul__(self, value): return self * value
|
|
|
+ def __sub__(self, value): return self.clone(float(self) - value)
|
|
|
+ def __rsub__(self, value): return self.clone(value - float(self))
|
|
|
+ def __mod__(self, value): return self.clone(float(self) % value)
|
|
|
+ def __rmod__(self, value): return self.clone(value % float(self))
|
|
|
+ def __pow__(self, value, modulo=None): return self.clone(pow(float(self), value, modulo))
|
|
|
+ def __rpow__(self, value): return self.clone(pow(value, float(self)))
|
|
|
+
|
|
|
+ if sys.version_info[0] <= 2:
|
|
|
+ def __div__(self, value): return self.clone(float(self) / value)
|
|
|
+ def __rdiv__(self, value): return self.clone(value / float(self))
|
|
|
+ else:
|
|
|
+ def __truediv__(self, value): return self.clone(float(self) / value)
|
|
|
+ def __rtruediv__(self, value): return self.clone(value / float(self))
|
|
|
+ def __divmod__(self, value): return self.clone(float(self) // value)
|
|
|
+ def __rdivmod__(self, value): return self.clone(value // float(self))
|
|
|
+
|
|
|
+ def __int__(self): return int(float(self))
|
|
|
+ if sys.version_info[0] <= 2:
|
|
|
+ def __long__(self): return long(float(self))
|
|
|
+ def __float__(self):
|
|
|
+ if self._value in self._inf:
|
|
|
+ return self._value
|
|
|
+ else:
|
|
|
+ return float(
|
|
|
+ self._value[0] * pow(self._value[1], self._value[2])
|
|
|
+ )
|
|
|
+ def __abs__(self): return abs(float(self))
|
|
|
+
|
|
|
+ def __lt__(self, value): return float(self) < value
|
|
|
+ def __le__(self, value): return float(self) <= value
|
|
|
+ def __eq__(self, value): return float(self) == value
|
|
|
+ def __ne__(self, value): return float(self) != value
|
|
|
+ def __gt__(self, value): return float(self) > value
|
|
|
+ def __ge__(self, value): return float(self) >= value
|
|
|
+
|
|
|
+ if sys.version_info[0] <= 2:
|
|
|
+ def __nonzero__(self): return bool(float(self))
|
|
|
+ else:
|
|
|
+ def __bool__(self): return bool(float(self))
|
|
|
+ __hash__ = base.AbstractSimpleAsn1Item.__hash__
|
|
|
+
|
|
|
+ def __getitem__(self, idx):
|
|
|
+ if self._value in self._inf:
|
|
|
+ raise error.PyAsn1Error('Invalid infinite value operation')
|
|
|
+ else:
|
|
|
+ return self._value[idx]
|
|
|
+
|
|
|
+class Enumerated(Integer):
|
|
|
+ tagSet = baseTagSet = tag.initTagSet(
|
|
|
+ tag.Tag(tag.tagClassUniversal, tag.tagFormatSimple, 0x0A)
|
|
|
+ )
|
|
|
+
|
|
|
+# "Structured" ASN.1 types
|
|
|
+
|
|
|
+class SetOf(base.AbstractConstructedAsn1Item):
|
|
|
+ componentType = None
|
|
|
+ tagSet = baseTagSet = tag.initTagSet(
|
|
|
+ tag.Tag(tag.tagClassUniversal, tag.tagFormatConstructed, 0x11)
|
|
|
+ )
|
|
|
+ typeId = 1
|
|
|
+
|
|
|
+ def _cloneComponentValues(self, myClone, cloneValueFlag):
|
|
|
+ idx = 0; l = len(self._componentValues)
|
|
|
+ while idx < l:
|
|
|
+ c = self._componentValues[idx]
|
|
|
+ if c is not None:
|
|
|
+ if isinstance(c, base.AbstractConstructedAsn1Item):
|
|
|
+ myClone.setComponentByPosition(
|
|
|
+ idx, c.clone(cloneValueFlag=cloneValueFlag)
|
|
|
+ )
|
|
|
+ else:
|
|
|
+ myClone.setComponentByPosition(idx, c.clone())
|
|
|
+ idx = idx + 1
|
|
|
+
|
|
|
+ def _verifyComponent(self, idx, value):
|
|
|
+ if self._componentType is not None and \
|
|
|
+ not self._componentType.isSuperTypeOf(value):
|
|
|
+ raise error.PyAsn1Error('Component type error %s' % (value,))
|
|
|
+
|
|
|
+ def getComponentByPosition(self, idx): return self._componentValues[idx]
|
|
|
+ def setComponentByPosition(self, idx, value=None, verifyConstraints=True):
|
|
|
+ l = len(self._componentValues)
|
|
|
+ if idx >= l:
|
|
|
+ self._componentValues = self._componentValues + (idx-l+1)*[None]
|
|
|
+ if value is None:
|
|
|
+ if self._componentValues[idx] is None:
|
|
|
+ if self._componentType is None:
|
|
|
+ raise error.PyAsn1Error('Component type not defined')
|
|
|
+ self._componentValues[idx] = self._componentType.clone()
|
|
|
+ self._componentValuesSet = self._componentValuesSet + 1
|
|
|
+ return self
|
|
|
+ elif not isinstance(value, base.Asn1Item):
|
|
|
+ if self._componentType is None:
|
|
|
+ raise error.PyAsn1Error('Component type not defined')
|
|
|
+ if isinstance(self._componentType, base.AbstractSimpleAsn1Item):
|
|
|
+ value = self._componentType.clone(value=value)
|
|
|
+ else:
|
|
|
+ raise error.PyAsn1Error('Instance value required')
|
|
|
+ if verifyConstraints:
|
|
|
+ if self._componentType is not None:
|
|
|
+ self._verifyComponent(idx, value)
|
|
|
+ self._verifySubtypeSpec(value, idx)
|
|
|
+ if self._componentValues[idx] is None:
|
|
|
+ self._componentValuesSet = self._componentValuesSet + 1
|
|
|
+ self._componentValues[idx] = value
|
|
|
+ return self
|
|
|
+
|
|
|
+ def getComponentTagMap(self):
|
|
|
+ if self._componentType is not None:
|
|
|
+ return self._componentType.getTagMap()
|
|
|
+
|
|
|
+ def prettyPrint(self, scope=0):
|
|
|
+ scope = scope + 1
|
|
|
+ r = self.__class__.__name__ + ':\n'
|
|
|
+ for idx in range(len(self._componentValues)):
|
|
|
+ r = r + ' '*scope
|
|
|
+ if self._componentValues[idx] is None:
|
|
|
+ r = r + '<empty>'
|
|
|
+ else:
|
|
|
+ r = r + self._componentValues[idx].prettyPrint(scope)
|
|
|
+ return r
|
|
|
+
|
|
|
+class SequenceOf(SetOf):
|
|
|
+ tagSet = baseTagSet = tag.initTagSet(
|
|
|
+ tag.Tag(tag.tagClassUniversal, tag.tagFormatConstructed, 0x10)
|
|
|
+ )
|
|
|
+ typeId = 2
|
|
|
+
|
|
|
+class SequenceAndSetBase(base.AbstractConstructedAsn1Item):
|
|
|
+ componentType = namedtype.NamedTypes()
|
|
|
+ def __init__(self, componentType=None, tagSet=None,
|
|
|
+ subtypeSpec=None, sizeSpec=None):
|
|
|
+ base.AbstractConstructedAsn1Item.__init__(
|
|
|
+ self, componentType, tagSet, subtypeSpec, sizeSpec
|
|
|
+ )
|
|
|
+ if self._componentType is None:
|
|
|
+ self._componentTypeLen = 0
|
|
|
+ else:
|
|
|
+ self._componentTypeLen = len(self._componentType)
|
|
|
+
|
|
|
+ def __getitem__(self, idx):
|
|
|
+ if isinstance(idx, str):
|
|
|
+ return self.getComponentByName(idx)
|
|
|
+ else:
|
|
|
+ return base.AbstractConstructedAsn1Item.__getitem__(self, idx)
|
|
|
+
|
|
|
+ def __setitem__(self, idx, value):
|
|
|
+ if isinstance(idx, str):
|
|
|
+ self.setComponentByName(idx, value)
|
|
|
+ else:
|
|
|
+ base.AbstractConstructedAsn1Item.__setitem__(self, idx, value)
|
|
|
+
|
|
|
+ def _cloneComponentValues(self, myClone, cloneValueFlag):
|
|
|
+ idx = 0; l = len(self._componentValues)
|
|
|
+ while idx < l:
|
|
|
+ c = self._componentValues[idx]
|
|
|
+ if c is not None:
|
|
|
+ if isinstance(c, base.AbstractConstructedAsn1Item):
|
|
|
+ myClone.setComponentByPosition(
|
|
|
+ idx, c.clone(cloneValueFlag=cloneValueFlag)
|
|
|
+ )
|
|
|
+ else:
|
|
|
+ myClone.setComponentByPosition(idx, c.clone())
|
|
|
+ idx = idx + 1
|
|
|
+
|
|
|
+ def _verifyComponent(self, idx, value):
|
|
|
+ if idx >= self._componentTypeLen:
|
|
|
+ raise error.PyAsn1Error(
|
|
|
+ 'Component type error out of range'
|
|
|
+ )
|
|
|
+ t = self._componentType[idx].getType()
|
|
|
+ if not t.isSuperTypeOf(value):
|
|
|
+ raise error.PyAsn1Error('Component type error %r vs %r' % (t, value))
|
|
|
+
|
|
|
+ def getComponentByName(self, name):
|
|
|
+ return self.getComponentByPosition(
|
|
|
+ self._componentType.getPositionByName(name)
|
|
|
+ )
|
|
|
+ def setComponentByName(self, name, value=None, verifyConstraints=True):
|
|
|
+ return self.setComponentByPosition(
|
|
|
+ self._componentType.getPositionByName(name), value,
|
|
|
+ verifyConstraints
|
|
|
+ )
|
|
|
+
|
|
|
+ def getComponentByPosition(self, idx):
|
|
|
+ try:
|
|
|
+ return self._componentValues[idx]
|
|
|
+ except IndexError:
|
|
|
+ if idx < self._componentTypeLen:
|
|
|
+ return
|
|
|
+ raise
|
|
|
+ def setComponentByPosition(self, idx, value=None, verifyConstraints=True):
|
|
|
+ l = len(self._componentValues)
|
|
|
+ if idx >= l:
|
|
|
+ self._componentValues = self._componentValues + (idx-l+1)*[None]
|
|
|
+ if value is None:
|
|
|
+ if self._componentValues[idx] is None:
|
|
|
+ self._componentValues[idx] = self._componentType.getTypeByPosition(idx).clone()
|
|
|
+ self._componentValuesSet = self._componentValuesSet + 1
|
|
|
+ return self
|
|
|
+ elif not isinstance(value, base.Asn1Item):
|
|
|
+ t = self._componentType.getTypeByPosition(idx)
|
|
|
+ if isinstance(t, base.AbstractSimpleAsn1Item):
|
|
|
+ value = t.clone(value=value)
|
|
|
+ else:
|
|
|
+ raise error.PyAsn1Error('Instance value required')
|
|
|
+ if verifyConstraints:
|
|
|
+ if self._componentTypeLen:
|
|
|
+ self._verifyComponent(idx, value)
|
|
|
+ self._verifySubtypeSpec(value, idx)
|
|
|
+ if self._componentValues[idx] is None:
|
|
|
+ self._componentValuesSet = self._componentValuesSet + 1
|
|
|
+ self._componentValues[idx] = value
|
|
|
+ return self
|
|
|
+
|
|
|
+ def getNameByPosition(self, idx):
|
|
|
+ if self._componentTypeLen:
|
|
|
+ return self._componentType.getNameByPosition(idx)
|
|
|
+
|
|
|
+ def getDefaultComponentByPosition(self, idx):
|
|
|
+ if self._componentTypeLen and self._componentType[idx].isDefaulted:
|
|
|
+ return self._componentType[idx].getType()
|
|
|
+
|
|
|
+ def getComponentType(self):
|
|
|
+ if self._componentTypeLen:
|
|
|
+ return self._componentType
|
|
|
+
|
|
|
+ def setDefaultComponents(self):
|
|
|
+ if self._componentTypeLen == self._componentValuesSet:
|
|
|
+ return
|
|
|
+ idx = self._componentTypeLen
|
|
|
+ while idx:
|
|
|
+ idx = idx - 1
|
|
|
+ if self._componentType[idx].isDefaulted:
|
|
|
+ if self.getComponentByPosition(idx) is None:
|
|
|
+ self.setComponentByPosition(idx)
|
|
|
+ elif not self._componentType[idx].isOptional:
|
|
|
+ if self.getComponentByPosition(idx) is None:
|
|
|
+ raise error.PyAsn1Error(
|
|
|
+ 'Uninitialized component #%s at %r' % (idx, self)
|
|
|
+ )
|
|
|
+
|
|
|
+ def prettyPrint(self, scope=0):
|
|
|
+ scope = scope + 1
|
|
|
+ r = self.__class__.__name__ + ':\n'
|
|
|
+ for idx in range(len(self._componentValues)):
|
|
|
+ if self._componentValues[idx] is not None:
|
|
|
+ r = r + ' '*scope
|
|
|
+ componentType = self.getComponentType()
|
|
|
+ if componentType is None:
|
|
|
+ r = r + '<no-name>'
|
|
|
+ else:
|
|
|
+ r = r + componentType.getNameByPosition(idx)
|
|
|
+ r = '%s=%s\n' % (
|
|
|
+ r, self._componentValues[idx].prettyPrint(scope)
|
|
|
+ )
|
|
|
+ return r
|
|
|
+
|
|
|
+class Sequence(SequenceAndSetBase):
|
|
|
+ tagSet = baseTagSet = tag.initTagSet(
|
|
|
+ tag.Tag(tag.tagClassUniversal, tag.tagFormatConstructed, 0x10)
|
|
|
+ )
|
|
|
+ typeId = 3
|
|
|
+
|
|
|
+ def getComponentTagMapNearPosition(self, idx):
|
|
|
+ if self._componentType:
|
|
|
+ return self._componentType.getTagMapNearPosition(idx)
|
|
|
+
|
|
|
+ def getComponentPositionNearType(self, tagSet, idx):
|
|
|
+ if self._componentType:
|
|
|
+ return self._componentType.getPositionNearType(tagSet, idx)
|
|
|
+ else:
|
|
|
+ return idx
|
|
|
+
|
|
|
+class Set(SequenceAndSetBase):
|
|
|
+ tagSet = baseTagSet = tag.initTagSet(
|
|
|
+ tag.Tag(tag.tagClassUniversal, tag.tagFormatConstructed, 0x11)
|
|
|
+ )
|
|
|
+ typeId = 4
|
|
|
+
|
|
|
+ def getComponent(self, innerFlag=0): return self
|
|
|
+
|
|
|
+ def getComponentByType(self, tagSet, innerFlag=0):
|
|
|
+ c = self.getComponentByPosition(
|
|
|
+ self._componentType.getPositionByType(tagSet)
|
|
|
+ )
|
|
|
+ if innerFlag and isinstance(c, Set):
|
|
|
+ # get inner component by inner tagSet
|
|
|
+ return c.getComponent(1)
|
|
|
+ else:
|
|
|
+ # get outer component by inner tagSet
|
|
|
+ return c
|
|
|
+
|
|
|
+ def setComponentByType(self, tagSet, value=None, innerFlag=0,
|
|
|
+ verifyConstraints=True):
|
|
|
+ idx = self._componentType.getPositionByType(tagSet)
|
|
|
+ t = self._componentType.getTypeByPosition(idx)
|
|
|
+ if innerFlag: # set inner component by inner tagSet
|
|
|
+ if t.getTagSet():
|
|
|
+ return self.setComponentByPosition(
|
|
|
+ idx, value, verifyConstraints
|
|
|
+ )
|
|
|
+ else:
|
|
|
+ t = self.setComponentByPosition(idx).getComponentByPosition(idx)
|
|
|
+ return t.setComponentByType(
|
|
|
+ tagSet, value, innerFlag, verifyConstraints
|
|
|
+ )
|
|
|
+ else: # set outer component by inner tagSet
|
|
|
+ return self.setComponentByPosition(
|
|
|
+ idx, value, verifyConstraints
|
|
|
+ )
|
|
|
+
|
|
|
+ def getComponentTagMap(self):
|
|
|
+ if self._componentType:
|
|
|
+ return self._componentType.getTagMap(True)
|
|
|
+
|
|
|
+ def getComponentPositionByType(self, tagSet):
|
|
|
+ if self._componentType:
|
|
|
+ return self._componentType.getPositionByType(tagSet)
|
|
|
+
|
|
|
+class Choice(Set):
|
|
|
+ tagSet = baseTagSet = tag.TagSet() # untagged
|
|
|
+ sizeSpec = constraint.ConstraintsIntersection(
|
|
|
+ constraint.ValueSizeConstraint(1, 1)
|
|
|
+ )
|
|
|
+ typeId = 5
|
|
|
+ _currentIdx = None
|
|
|
+
|
|
|
+ def __eq__(self, other):
|
|
|
+ if self._componentValues:
|
|
|
+ return self._componentValues[self._currentIdx] == other
|
|
|
+ return NotImplemented
|
|
|
+ def __ne__(self, other):
|
|
|
+ if self._componentValues:
|
|
|
+ return self._componentValues[self._currentIdx] != other
|
|
|
+ return NotImplemented
|
|
|
+ def __lt__(self, other):
|
|
|
+ if self._componentValues:
|
|
|
+ return self._componentValues[self._currentIdx] < other
|
|
|
+ return NotImplemented
|
|
|
+ def __le__(self, other):
|
|
|
+ if self._componentValues:
|
|
|
+ return self._componentValues[self._currentIdx] <= other
|
|
|
+ return NotImplemented
|
|
|
+ def __gt__(self, other):
|
|
|
+ if self._componentValues:
|
|
|
+ return self._componentValues[self._currentIdx] > other
|
|
|
+ return NotImplemented
|
|
|
+ def __ge__(self, other):
|
|
|
+ if self._componentValues:
|
|
|
+ return self._componentValues[self._currentIdx] >= other
|
|
|
+ return NotImplemented
|
|
|
+ if sys.version_info[0] <= 2:
|
|
|
+ def __nonzero__(self): return bool(self._componentValues)
|
|
|
+ else:
|
|
|
+ def __bool__(self): return bool(self._componentValues)
|
|
|
+
|
|
|
+ def __len__(self): return self._currentIdx is not None and 1 or 0
|
|
|
+
|
|
|
+ def verifySizeSpec(self):
|
|
|
+ if self._currentIdx is None:
|
|
|
+ raise error.PyAsn1Error('Component not chosen')
|
|
|
+ else:
|
|
|
+ self._sizeSpec(' ')
|
|
|
+
|
|
|
+ def _cloneComponentValues(self, myClone, cloneValueFlag):
|
|
|
+ try:
|
|
|
+ c = self.getComponent()
|
|
|
+ except error.PyAsn1Error:
|
|
|
+ pass
|
|
|
+ else:
|
|
|
+ if isinstance(c, Choice):
|
|
|
+ tagSet = c.getEffectiveTagSet()
|
|
|
+ else:
|
|
|
+ tagSet = c.getTagSet()
|
|
|
+ if isinstance(c, base.AbstractConstructedAsn1Item):
|
|
|
+ myClone.setComponentByType(
|
|
|
+ tagSet, c.clone(cloneValueFlag=cloneValueFlag)
|
|
|
+ )
|
|
|
+ else:
|
|
|
+ myClone.setComponentByType(tagSet, c.clone())
|
|
|
+
|
|
|
+ def setComponentByPosition(self, idx, value=None, verifyConstraints=True):
|
|
|
+ l = len(self._componentValues)
|
|
|
+ if idx >= l:
|
|
|
+ self._componentValues = self._componentValues + (idx-l+1)*[None]
|
|
|
+ if self._currentIdx is not None:
|
|
|
+ self._componentValues[self._currentIdx] = None
|
|
|
+ if value is None:
|
|
|
+ if self._componentValues[idx] is None:
|
|
|
+ self._componentValues[idx] = self._componentType.getTypeByPosition(idx).clone()
|
|
|
+ self._componentValuesSet = 1
|
|
|
+ self._currentIdx = idx
|
|
|
+ return self
|
|
|
+ elif not isinstance(value, base.Asn1Item):
|
|
|
+ value = self._componentType.getTypeByPosition(idx).clone(
|
|
|
+ value=value
|
|
|
+ )
|
|
|
+ if verifyConstraints:
|
|
|
+ if self._componentTypeLen:
|
|
|
+ self._verifyComponent(idx, value)
|
|
|
+ self._verifySubtypeSpec(value, idx)
|
|
|
+ self._componentValues[idx] = value
|
|
|
+ self._currentIdx = idx
|
|
|
+ self._componentValuesSet = 1
|
|
|
+ return self
|
|
|
+
|
|
|
+ def getMinTagSet(self):
|
|
|
+ if self._tagSet:
|
|
|
+ return self._tagSet
|
|
|
+ else:
|
|
|
+ return self._componentType.genMinTagSet()
|
|
|
+
|
|
|
+ def getEffectiveTagSet(self):
|
|
|
+ if self._tagSet:
|
|
|
+ return self._tagSet
|
|
|
+ else:
|
|
|
+ c = self.getComponent()
|
|
|
+ if isinstance(c, Choice):
|
|
|
+ return c.getEffectiveTagSet()
|
|
|
+ else:
|
|
|
+ return c.getTagSet()
|
|
|
+
|
|
|
+ def getTagMap(self):
|
|
|
+ if self._tagSet:
|
|
|
+ return Set.getTagMap(self)
|
|
|
+ else:
|
|
|
+ return Set.getComponentTagMap(self)
|
|
|
+
|
|
|
+ def getComponent(self, innerFlag=0):
|
|
|
+ if self._currentIdx is None:
|
|
|
+ raise error.PyAsn1Error('Component not chosen')
|
|
|
+ else:
|
|
|
+ c = self._componentValues[self._currentIdx]
|
|
|
+ if innerFlag and isinstance(c, Choice):
|
|
|
+ return c.getComponent(innerFlag)
|
|
|
+ else:
|
|
|
+ return c
|
|
|
+
|
|
|
+ def getName(self, innerFlag=0):
|
|
|
+ if self._currentIdx is None:
|
|
|
+ raise error.PyAsn1Error('Component not chosen')
|
|
|
+ else:
|
|
|
+ if innerFlag:
|
|
|
+ c = self._componentValues[self._currentIdx]
|
|
|
+ if isinstance(c, Choice):
|
|
|
+ return c.getName(innerFlag)
|
|
|
+ return self._componentType.getNameByPosition(self._currentIdx)
|
|
|
+
|
|
|
+ def setDefaultComponents(self): pass
|
|
|
+
|
|
|
+class Any(OctetString):
|
|
|
+ tagSet = baseTagSet = tag.TagSet() # untagged
|
|
|
+ typeId = 6
|
|
|
+
|
|
|
+ def getTagMap(self):
|
|
|
+ return tagmap.TagMap(
|
|
|
+ { self.getTagSet(): self },
|
|
|
+ { eoo.endOfOctets.getTagSet(): eoo.endOfOctets },
|
|
|
+ self
|
|
|
+ )
|
|
|
+
|
|
|
+# XXX
|
|
|
+# coercion rules?
|