Add samba.ensure_third_party_module() function, loading external python modules from...
[bbaumbach/samba-autobuild/.git] / third_party / dnspython / dns / rdtypes / ANY / CERT.py
1 # Copyright (C) 2003-2007, 2009-2011 Nominum, Inc.
2 #
3 # Permission to use, copy, modify, and distribute this software and its
4 # documentation for any purpose with or without fee is hereby granted,
5 # provided that the above copyright notice and this permission notice
6 # appear in all copies.
7 #
8 # THE SOFTWARE IS PROVIDED "AS IS" AND NOMINUM DISCLAIMS ALL WARRANTIES
9 # WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
10 # MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL NOMINUM BE LIABLE FOR
11 # ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
12 # WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
13 # ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
14 # OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
15
16 import cStringIO
17 import struct
18
19 import dns.exception
20 import dns.dnssec
21 import dns.rdata
22 import dns.tokenizer
23
24 _ctype_by_value = {
25     1 : 'PKIX',
26     2 : 'SPKI',
27     3 : 'PGP',
28     253 : 'URI',
29     254 : 'OID',
30     }
31
32 _ctype_by_name = {
33     'PKIX' : 1,
34     'SPKI' : 2,
35     'PGP' : 3,
36     'URI' : 253,
37     'OID' : 254,
38     }
39
40 def _ctype_from_text(what):
41     v = _ctype_by_name.get(what)
42     if not v is None:
43         return v
44     return int(what)
45
46 def _ctype_to_text(what):
47     v = _ctype_by_value.get(what)
48     if not v is None:
49         return v
50     return str(what)
51
52 class CERT(dns.rdata.Rdata):
53     """CERT record
54
55     @ivar certificate_type: certificate type
56     @type certificate_type: int
57     @ivar key_tag: key tag
58     @type key_tag: int
59     @ivar algorithm: algorithm
60     @type algorithm: int
61     @ivar certificate: the certificate or CRL
62     @type certificate: string
63     @see: RFC 2538"""
64
65     __slots__ = ['certificate_type', 'key_tag', 'algorithm', 'certificate']
66
67     def __init__(self, rdclass, rdtype, certificate_type, key_tag, algorithm,
68                  certificate):
69         super(CERT, self).__init__(rdclass, rdtype)
70         self.certificate_type = certificate_type
71         self.key_tag = key_tag
72         self.algorithm = algorithm
73         self.certificate = certificate
74
75     def to_text(self, origin=None, relativize=True, **kw):
76         certificate_type = _ctype_to_text(self.certificate_type)
77         return "%s %d %s %s" % (certificate_type, self.key_tag,
78                                 dns.dnssec.algorithm_to_text(self.algorithm),
79                                 dns.rdata._base64ify(self.certificate))
80
81     def from_text(cls, rdclass, rdtype, tok, origin = None, relativize = True):
82         certificate_type = _ctype_from_text(tok.get_string())
83         key_tag = tok.get_uint16()
84         algorithm = dns.dnssec.algorithm_from_text(tok.get_string())
85         if algorithm < 0 or algorithm > 255:
86             raise dns.exception.SyntaxError("bad algorithm type")
87         chunks = []
88         while 1:
89             t = tok.get().unescape()
90             if t.is_eol_or_eof():
91                 break
92             if not t.is_identifier():
93                 raise dns.exception.SyntaxError
94             chunks.append(t.value)
95         b64 = ''.join(chunks)
96         certificate = b64.decode('base64_codec')
97         return cls(rdclass, rdtype, certificate_type, key_tag,
98                    algorithm, certificate)
99
100     from_text = classmethod(from_text)
101
102     def to_wire(self, file, compress = None, origin = None):
103         prefix = struct.pack("!HHB", self.certificate_type, self.key_tag,
104                              self.algorithm)
105         file.write(prefix)
106         file.write(self.certificate)
107
108     def from_wire(cls, rdclass, rdtype, wire, current, rdlen, origin = None):
109         prefix = wire[current : current + 5].unwrap()
110         current += 5
111         rdlen -= 5
112         if rdlen < 0:
113             raise dns.exception.FormError
114         (certificate_type, key_tag, algorithm) = struct.unpack("!HHB", prefix)
115         certificate = wire[current : current + rdlen].unwrap()
116         return cls(rdclass, rdtype, certificate_type, key_tag, algorithm,
117                    certificate)
118
119     from_wire = classmethod(from_wire)
120
121     def _cmp(self, other):
122         f = cStringIO.StringIO()
123         self.to_wire(f)
124         wire1 = f.getvalue()
125         f.seek(0)
126         f.truncate()
127         other.to_wire(f)
128         wire2 = f.getvalue()
129         f.close()
130
131         return cmp(wire1, wire2)