Exemple #1
0
    def serialize(self, include_rrsig_info=True, consolidate_clients=True, show_servers=True, loglevel=logging.DEBUG, html_format=False):
        d = collections.OrderedDict()

        if html_format:
            formatter = lambda x: cgi.escape(x, True)
        else:
            formatter = lambda x: x

        if self.rrset.rdtype == dns.rdatatype.NSEC3:
            d['name'] = formatter(fmt.format_nsec3_name(self.rrset.name))
        else:
            d['name'] = formatter(self.rrset.name.canonicalize().to_text())
        d['ttl'] = self.rrset.ttl
        d['type'] = dns.rdatatype.to_text(self.rrset.rdtype)
        d['rdata'] = []
        rdata_list = list(self.rrset)
        rdata_list.sort(cmp=self.rdata_cmp)
        for rdata in rdata_list:
            if self.rrset.rdtype == dns.rdatatype.NSEC3:
                d['rdata'].append(fmt.format_nsec3_rrset_text(self.rrset[0].to_text()))
            else:
                d['rdata'].append(formatter(rdata.to_text()))

        if include_rrsig_info:
            #TODO include RRSIG info...
            pass

        if show_servers:
            servers = tuple_to_dict(self.servers_clients)
            if consolidate_clients:
                servers = list(servers)
                servers.sort()
            d['servers'] = servers

        return d
Exemple #2
0
    def serialize(self, consolidate_clients=True, loglevel=logging.DEBUG, html_format=False):
        from analysis import status as Status

        show_basic = (self.warnings and loglevel <= logging.WARNING) or (self.errors and loglevel <= logging.ERROR)

        d = collections.OrderedDict()

        if html_format:
            formatter = lambda x: cgi.escape(x, True)
        else:
            formatter = lambda x: x

        if loglevel <= logging.INFO or show_basic:
            d['id'] = '%d/%d' % (self.rdata.algorithm, self.key_tag)
        if loglevel <= logging.DEBUG:
            d['description'] = formatter(unicode(self))
            d['flags'] = self.rdata.flags
            d['protocol'] = self.rdata.protocol
            d['algorithm'] = self.rdata.algorithm
            d['key'] = base64.b64encode(self.rdata.key)
            d['ttl'] = self.ttl
            d['key_length'] = self.key_len
            d['key_tag'] = self.key_tag
            if self.rdata.flags & fmt.DNSKEY_FLAGS['revoke']:
                d['key_tag_pre_revoke'] = self.key_tag_no_revoke

            if html_format:
                flags = [t for (t,c) in fmt.DNSKEY_FLAGS.items() if c & self.rdata.flags]
                d['flags'] = '%d (%s)' % (self.rdata.flags, ', '.join(flags))
                d['protocol'] = '%d (%s)' % (self.rdata.protocol, fmt.DNSKEY_PROTOCOLS.get(self.rdata.protocol, self.rdata.protocol))
                d['algorithm'] = '%d (%s)' % (self.rdata.algorithm, fmt.DNSKEY_ALGORITHMS.get(self.rdata.algorithm, self.rdata.algorithm))
                d['ttl'] = '%d (%s)' % (self.ttl, fmt.humanize_time(self.ttl))
                if self.key_len is None:
                    d['key_length'] = 'unknown'
                else:
                    d['key_length'] = '%d bits' % (self.key_len)

        #TODO: put DNSKEY roles in meta, if it makes sense

        if loglevel <= logging.DEBUG or show_basic:
            servers = tuple_to_dict(self.servers_clients)
            if consolidate_clients:
                servers = list(servers)
                servers.sort()
            d['servers'] = servers

        if self.warnings and loglevel <= logging.WARNING:
            d['warnings'] = [w.serialize(consolidate_clients=consolidate_clients, html_format=html_format) for w in self.warnings]

        if self.errors and loglevel <= logging.ERROR:
            d['errors'] = [e.serialize(consolidate_clients=consolidate_clients, html_format=html_format) for e in self.errors]

        return d
Exemple #3
0
    def serialize(self, consolidate_clients=True, show_servers=True, loglevel=logging.DEBUG, html_format=False):
        d = collections.OrderedDict()

        if html_format:
            formatter = lambda x: cgi.escape(x, True)
        else:
            formatter = lambda x: x

        if self.rrset.rdtype == dns.rdatatype.NSEC3:
            d['name'] = formatter(fmt.format_nsec3_name(self.rrset.name))
        else:
            d['name'] = formatter(self.rrset.name.canonicalize().to_text())
        d['ttl'] = self.rrset.ttl
        d['type'] = dns.rdatatype.to_text(self.rrset.rdtype)
        d['rdata'] = []
        rdata_list = list(self.rrset)
        rdata_list.sort(cmp=self.rdata_cmp)
        for rdata in rdata_list:
            if self.rrset.rdtype == dns.rdatatype.NSEC3:
                d['rdata'].append(fmt.format_nsec3_rrset_text(self.rrset[0].to_text()))
            else:
                d['rdata'].append(formatter(rdata.to_text()))

        if loglevel <= logging.INFO:
            servers = tuple_to_dict(self.servers_clients)
            if consolidate_clients:
                servers = list(servers)
                servers.sort()
            d['servers'] = servers

            tags = set()
            for server,client in self.servers_clients:
                for response in self.servers_clients[(server,client)]:
                    tags.add(response.effective_query_tag())
            d['query_options'] = list(tags)
            d['query_options'].sort()

        return d