typo fix - Thanks A. M. Kuchlingi

         removed all use of word 'Rendezvous' - this is an API change"""

                  - IPv6 address

                  - hostinfo

                 ignore unknown DNS record types

                 fixes to name decoding

                 works alongside other processes using port 5353 (e.g. on Mac OS X)

                 tested against Mac OS X 10.3.2's mDNSResponder

                 corrections to removal of list entries for service browser"""

                 correct a pointer encoding problem

                 can now write records in any order

                 traceback shown on failure

                 better TXT record parsing

                 server is now separate from name

                 can cancel a service browser

                 modified some unit tests to accommodate these changes"""

                 ServiceBrowser now works

                 new unit tests"""

                 new style objects

                 fixed hostname/interface problem

                 fixed socket timeout problem

                 fixed addServiceListener() typo bug

                 using select() for socket reads

                 tested on Debian unstable with Python 2.2.2"""

                 ensure names end in '.local.'

                 timeout on receiving socket for clean shutdown"""

             _CLASS_CS : "cs",

             _CLASS_CH : "ch",

             _CLASS_HS : "hs",

             _CLASS_NONE : "none",

             _CLASS_ANY : "any" }

           _TYPE_NS : "ns",

           _TYPE_MD : "md",

           _TYPE_MF : "mf",

           _TYPE_CNAME : "cname",

           _TYPE_SOA : "soa",

           _TYPE_MB : "mb",

           _TYPE_MG : "mg",

           _TYPE_MR : "mr",

           _TYPE_NULL : "null",

           _TYPE_WKS : "wks",

           _TYPE_PTR : "ptr",

           _TYPE_HINFO : "hinfo",

           _TYPE_MINFO : "minfo",

           _TYPE_MX : "mx",

           _TYPE_TXT : "txt",

           _TYPE_AAAA : "quada",

           _TYPE_SRV : "srv",

           _TYPE_ANY : "any" }

    """Current system time in milliseconds"""

    return time.time() * 1000

    pass

    pass

    pass

    pass

    pass

    def __init__(self, pos):

        Exception.__init__(self, "at position %s" % pos)

    pass

    """A DNS entry"""

    def __init__(self, name, type, clazz):

        self.key = string.lower(name)

        self.name = name

        self.type = type

        self.clazz = clazz & _CLASS_MASK

        self.unique = (clazz & _CLASS_UNIQUE) != 0

    def __eq__(self, other):

        """Equality test on name, type, and class"""

        if isinstance(other, DNSEntry):

            return self.name == other.name and self.type == other.type and self.clazz == other.clazz

        return 0

    def __ne__(self, other):

        """Non-equality test"""

        return not self.__eq__(other)

    def getClazz(self, clazz):

        """Class accessor"""

        try:

            return _CLASSES[clazz]

        except KeyError:

            return "?(%s)" % (clazz)

    def getType(self, type):

        """Type accessor"""

        try:

            return _TYPES[type]

        except KeyError:

            return "?(%s)" % (type)

    def toString(self, hdr, other):

        """String representation with additional information"""

        result = "%s[%s,%s" % (hdr, self.getType(self.type), self.getClazz(self.clazz))

        if self.unique:

            result += "-unique,"

        else:

            result += ","

        result += self.name

        if other is not None:

            result += ",%s]" % (other)

        else:

            result += "]"

        return result

    """A DNS question entry"""

    def __init__(self, name, type, clazz):

        if not name.endswith(".local."):

            raise NonLocalNameException(name)

        DNSEntry.__init__(self, name, type, clazz)

    def answeredBy(self, rec):

        """Returns true if the question is answered by the record"""

        return self.clazz == rec.clazz and (self.type == rec.type or self.type == _TYPE_ANY) and self.name == rec.name

    def __repr__(self):

        """String representation"""

        return DNSEntry.toString(self, "question", None)

    """A DNS record - like a DNS entry, but has a TTL"""

    def __init__(self, name, type, clazz, ttl):

        DNSEntry.__init__(self, name, type, clazz)

        self.ttl = ttl

        self.created = currentTimeMillis()

    def __eq__(self, other):

        """Tests equality as per DNSRecord"""

        if isinstance(other, DNSRecord):

            return DNSEntry.__eq__(self, other)

        return 0

    def suppressedBy(self, msg):

        """Returns true if any answer in a message can suffice for the

        information held in this record."""

        for record in msg.answers:

            if self.suppressedByAnswer(record):

                return 1

        return 0

    def suppressedByAnswer(self, other):

        """Returns true if another record has same name, type and class,

        and if its TTL is at least half of this record's."""

        if self == other and other.ttl > (self.ttl / 2):

            return 1

        return 0

    def getExpirationTime(self, percent):

        """Returns the time at which this record will have expired

        by a certain percentage."""

        return self.created + (percent * self.ttl * 10)

    def getRemainingTTL(self, now):

        """Returns the remaining TTL in seconds."""

        return max(0, (self.getExpirationTime(100) - now) / 1000)

    def isExpired(self, now):

        """Returns true if this record has expired."""

        return self.getExpirationTime(100) <= now

    def isStale(self, now):

        """Returns true if this record is at least half way expired."""

        return self.getExpirationTime(50) <= now

    def resetTTL(self, other):

        """Sets this record's TTL and created time to that of

        another record."""

        self.created = other.created

        self.ttl = other.ttl

    def write(self, out):

        """Abstract method"""

        raise AbstractMethodException

    def toString(self, other):

        """String representation with additional information"""

        arg = "%s/%s,%s" % (self.ttl, self.getRemainingTTL(currentTimeMillis()), other)

        return DNSEntry.toString(self, "record", arg)

    """A DNS address record"""

    def __init__(self, name, type, clazz, ttl, address):

        DNSRecord.__init__(self, name, type, clazz, ttl)

        self.address = address

    def write(self, out):

        """Used in constructing an outgoing packet"""

        out.writeString(self.address, len(self.address))

    def __eq__(self, other):

        """Tests equality on address"""

        if isinstance(other, DNSAddress):

            return self.address == other.address

        return 0

    def __repr__(self):

        """String representation"""

        try:

            return socket.inet_ntoa(self.address)

        except Exception:

            return self.address

    """A DNS host information record"""

    def __init__(self, name, type, clazz, ttl, cpu, os):

        DNSRecord.__init__(self, name, type, clazz, ttl)

        self.cpu = cpu

        self.os = os

    def write(self, out):

        """Used in constructing an outgoing packet"""

        out.writeString(self.cpu, len(self.cpu))

        out.writeString(self.os, len(self.os))

    def __eq__(self, other):

        """Tests equality on cpu and os"""

        if isinstance(other, DNSHinfo):

            return self.cpu == other.cpu and self.os == other.os

        return 0

    def __repr__(self):

        """String representation"""

        return self.cpu + " " + self.os

    """A DNS pointer record"""

    def __init__(self, name, type, clazz, ttl, alias):

        DNSRecord.__init__(self, name, type, clazz, ttl)

        self.alias = alias

    def write(self, out):

        """Used in constructing an outgoing packet"""

        out.writeName(self.alias)

    def __eq__(self, other):

        """Tests equality on alias"""

        if isinstance(other, DNSPointer):

            return self.alias == other.alias

        return 0

    def __repr__(self):

        """String representation"""

        return self.toString(self.alias)