Esempio n. 1
0
    def encodeValue(self, value, asn1Spec, encodeFun, **options):

        if options.get('ifNotEmpty', False) and not len(value):
            return null, True, True

        chunks = self._encodeComponents(value, asn1Spec, encodeFun, **options)

        return null.join(chunks), True, True
Esempio n. 2
0
    def encodeValue(self, value, asn1Spec, encodeFun, **options):
        chunks = self._encodeComponents(value, asn1Spec, encodeFun, **options)

        if len(chunks) > 1:
            zero = str2octs('\x00')
            maxLen = max(map(len, chunks))
            paddedChunks = [(x.ljust(maxLen, zero), x) for x in chunks]

            chunks = [x[1] for x in paddedChunks]

        return null.join(chunks), True, True
Esempio n. 3
0
    def encodeValue(self, value, asn1Spec, encodeFun, **options):
        chunks = self._encodeComponents(value, asn1Spec, encodeFun, **options)

        # sort by serialised and padded components
        if len(chunks) > 1:
            zero = str2octs('\x00')
            maxLen = max(map(len, chunks))
            paddedChunks = [(x.ljust(maxLen, zero), x) for x in chunks]
            paddedChunks.sort(key=lambda x: x[0])

            chunks = [x[1] for x in paddedChunks]

        return null.join(chunks), True, True
Esempio n. 4
0
    def encodeValue(self,
                    encodeFun,
                    value,
                    defMode,
                    maxChunkSize,
                    ifNotEmpty=False):
        value.verifySizeSpec()
        substrate = null
        idx = len(value)
        # This is certainly a hack but how else do I distinguish SetOf
        # from Set if they have the same tags&constraints?
        if isinstance(value, univ.SequenceAndSetBase):
            # Set
            namedTypes = value.componentType
            comps = []
            compsMap = {}
            while idx > 0:
                idx -= 1
                if namedTypes:
                    if namedTypes[idx].isOptional and not value[idx].isValue:
                        continue
                    if namedTypes[idx].isDefaulted and value[
                            idx] == namedTypes[idx].asn1Object:
                        continue

                comps.append(value[idx])
                compsMap[id(value[idx])] = namedTypes[idx].isOptional

            for comp in self._sortComponents(comps):
                substrate += encodeFun(comp,
                                       defMode,
                                       maxChunkSize,
                                       ifNotEmpty=compsMap[id(comp)])
        else:
            # SetOf
            components = [encodeFun(x, defMode, maxChunkSize) for x in value]

            # sort by serialized and padded components
            if len(components) > 1:
                zero = str2octs('\x00')
                maxLen = max(map(len, components))
                paddedComponents = [(x.ljust(maxLen, zero), x)
                                    for x in components]
                paddedComponents.sort(key=lambda x: x[0])

                components = [x[1] for x in paddedComponents]

            substrate = null.join(components)

        return substrate, True, True
Esempio n. 5
0
    def encodeValue(self,
                    encodeFun,
                    value,
                    defMode,
                    maxChunkSize,
                    ifNotEmpty=False):
        value.verifySizeSpec()
        substrate = null
        idx = len(value)
        if value.typeId == univ.Set.typeId:
            namedTypes = value.componentType
            comps = []
            compsMap = {}
            while idx > 0:
                idx -= 1
                if namedTypes:
                    if namedTypes[idx].isOptional and not value[idx].isValue:
                        continue
                    if namedTypes[idx].isDefaulted and value[
                            idx] == namedTypes[idx].asn1Object:
                        continue

                comps.append(value[idx])
                compsMap[id(
                    value[idx])] = namedTypes and namedTypes[idx].isOptional

            for comp in self._sortComponents(comps):
                substrate += encodeFun(comp,
                                       defMode,
                                       maxChunkSize,
                                       ifNotEmpty=compsMap[id(comp)])
        else:
            components = [encodeFun(x, defMode, maxChunkSize) for x in value]

            # sort by serialized and padded components
            if len(components) > 1:
                zero = str2octs('\x00')
                maxLen = max(map(len, components))
                paddedComponents = [(x.ljust(maxLen, zero), x)
                                    for x in components]
                paddedComponents.sort(key=lambda x: x[0])

                components = [x[1] for x in paddedComponents]

            substrate = null.join(components)

        return substrate, True, True
Esempio n. 6
0
    def encodeValue(self, value, asn1Spec, encodeFun, **options):
        if asn1Spec is None:
            value.verifySizeSpec()
        else:
            asn1Spec = asn1Spec.componentType

        components = [encodeFun(x, asn1Spec, **options) for x in value]

        # sort by serialised and padded components
        if len(components) > 1:
            zero = str2octs('\x00')
            maxLen = max(map(len, components))
            paddedComponents = [(x.ljust(maxLen, zero), x) for x in components]
            paddedComponents.sort(key=lambda x: x[0])

            components = [x[1] for x in paddedComponents]

        substrate = null.join(components)

        return substrate, True, True
Esempio n. 7
0
    def encodeValue(self, value, encodeFun, **options):
        value.verifySizeSpec()
        substrate = null
        idx = len(value)
        if value.typeId == univ.Set.typeId:
            namedTypes = value.componentType
            comps = []
            compsMap = {}
            while idx > 0:
                idx -= 1
                if namedTypes:
                    if namedTypes[idx].isOptional and not value[idx].isValue:
                        continue
                    if namedTypes[idx].isDefaulted and value[idx] == namedTypes[idx].asn1Object:
                        continue

                comps.append(value[idx])
                compsMap[id(value[idx])] = namedTypes and namedTypes[idx].isOptional

            for comp in self._sortComponents(comps):
                options.update(ifNotEmpty=compsMap[id(comp)])
                substrate += encodeFun(comp, **options)
        else:
            components = [encodeFun(x, **options) for x in value]

            # sort by serialized and padded components
            if len(components) > 1:
                zero = str2octs('\x00')
                maxLen = max(map(len, components))
                paddedComponents = [
                    (x.ljust(maxLen, zero), x) for x in components
                ]
                paddedComponents.sort(key=lambda x: x[0])

                components = [x[1] for x in paddedComponents]

            substrate = null.join(components)

        return substrate, True, True
Esempio n. 8
0
    def encodeValue(self, value, asn1Spec, encodeFun, **options):
        if asn1Spec is None:
            value.verifySizeSpec()
        else:
            asn1Spec = asn1Spec.componentType

        components = [encodeFun(x, asn1Spec, **options)
                      for x in value]

        # sort by serialised and padded components
        if len(components) > 1:
            zero = str2octs('\x00')
            maxLen = max(map(len, components))
            paddedComponents = [
                (x.ljust(maxLen, zero), x) for x in components
                ]
            paddedComponents.sort(key=lambda x: x[0])

            components = [x[1] for x in paddedComponents]

        substrate = null.join(components)

        return substrate, True, True
Esempio n. 9
0
    def encodeValue(self, value, asn1Spec, encodeFun, **options):
        chunks = self._encodeComponents(value, asn1Spec, encodeFun, **options)

        return null.join(chunks), True, True