"__version__",

"Zeroconf", "ServiceInfo", "ServiceBrowser",

"Error", "InterfaceChoice", "ServiceStateChange",

_CLASS_CS: "cs",

_CLASS_CH: "ch",

_CLASS_HS: "hs",

_CLASS_NONE: "none",

_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",

"""A DNS entry"""

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

self.key = name.lower()

self.name = name

self.type = type

self.class_ = class_ & _CLASS_MASK

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

def __eq__(self, other):

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

return (isinstance(other, DNSEntry) and

self.name == other.name and

self.type == other.type and

self.class_ == other.class_)

def __ne__(self, other):

"""Non-equality test"""

return not self.__eq__(other)

def get_class_(self, class_):

"""Class accessor"""

return _CLASSES.get(class_, "?(%s)" % class_)

def get_type(self, t):

"""Type accessor"""

return _TYPES.get(t, "?(%s)" % t)

def to_string(self, hdr, other):

"""String representation with additional information"""

result = "%s[%s,%s" % (hdr, self.get_type(self.type),

self.get_class_(self.class_))

if self.unique:

result += "-unique,"

else:

result += ","

result += self.name

if other is not None:

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

else:

result += "]"

"""A DNS question entry"""

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

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

# raise NonLocalNameException

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

def answered_by(self, rec):

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

return (self.class_ == rec.class_ and

(self.type == rec.type or self.type == _TYPE_ANY) and

self.name == rec.name)

def __repr__(self):

"""String representation"""

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

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

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

self.ttl = ttl

self.created = current_time_millis()

def __eq__(self, other):

"""Tests equality as per DNSRecord"""

return isinstance(other, DNSRecord) and DNSEntry.__eq__(self, other)

def suppressed_by(self, msg):

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

for record in msg.answers:

if self.suppressed_by_answer(record):

return True

return False

def suppressed_by_answer(self, other):

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

return self == other and other.ttl > (self.ttl / 2)

def get_expiration_time(self, percent):

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

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

def get_remaining_ttl(self, now):

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

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

def is_expired(self, now):

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

return self.get_expiration_time(100) <= now

def is_stale(self, now):

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

return self.get_expiration_time(50) <= now

def reset_ttl(self, other):

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

self.created = other.created

self.ttl = other.ttl

def write(self, out):

"""Abstract method"""

raise AbstractMethodException

def to_string(self, other):

"""String representation with addtional information"""

arg = "%s/%s,%s" % (self.ttl,

self.get_remaining_ttl(current_time_millis()), other)

"""A DNS address record"""

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

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

self.address = address

def write(self, out):

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

out.write_string(self.address)

def __eq__(self, other):

"""Tests equality on address"""

return isinstance(other, DNSAddress) and self.address == other.address

def __repr__(self):

"""String representation"""

try:

return socket.inet_ntoa(self.address)

except Exception as e: # TODO stop catching all Exceptions

log.exception('Unknown error, possibly benign: %r', e)

"""A DNS host information record"""

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

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

self.cpu = cpu

self.os = os

def write(self, out):

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

out.write_string(self.cpu)

out.write_string(self.oso)

def __eq__(self, other):

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

return (isinstance(other, DNSHinfo) and

self.cpu == other.cpu and self.os == other.os)

def __repr__(self):

"""String representation"""

"""A DNS pointer record"""

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

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

self.alias = alias

def write(self, out):

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

out.write_name(self.alias)

def __eq__(self, other):

"""Tests equality on alias"""

return isinstance(other, DNSPointer) and self.alias == other.alias

def __repr__(self):

"""String representation"""

"""A DNS text record"""

def __init__(self, name, type_, class_, ttl, text):

assert isinstance(text, (bytes, type(None)))

DNSRecord.__init__(self, name, type_, class_, ttl)

self.text = text

def write(self, out):

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

out.write_string(self.text)

def __eq__(self, other):

"""Tests equality on text"""

return isinstance(other, DNSText) and self.text == other.text

def __repr__(self):

"""String representation"""

if len(self.text) > 10:

return self.to_string(self.text[:7]) + "..."

else:

"""A DNS service record"""

def __init__(self, name, type, class_, ttl, priority, weight, port, server):

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

self.priority = priority

self.weight = weight

self.port = port

self.server = server

def write(self, out):

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

out.write_short(self.priority)

out.write_short(self.weight)

out.write_short(self.port)

out.write_name(self.server)

def __eq__(self, other):

"""Tests equality on priority, weight, port and server"""

return (isinstance(other, DNSService) and

self.priority == other.priority and

self.weight == other.weight and

self.port == other.port and

self.server == other.server)

def __repr__(self):

"""String representation"""

"""Object representation of an incoming DNS packet"""

def __init__(self, data):

"""Constructor from string holding bytes of packet"""

self.offset = 0

self.data = data

self.questions = []

self.answers = []

self.num_questions = 0

self.num_answers = 0

self.num_authorities = 0

self.num_additionals = 0

self.read_header()

self.read_questions()

self.read_others()

def unpack(self, format):

length = struct.calcsize(format)

info = struct.unpack(format, self.data[self.offset:self.offset + length])

self.offset += length

return info

def read_header(self):

"""Reads header portion of packet"""

(self.id, self.flags, self.num_questions, self.num_answers,

self.num_quthorities, self.num_additionals) = self.unpack(b'!6H')

def read_questions(self):

"""Reads questions section of packet"""

for i in xrange(self.num_questions):

name = self.read_name()

type, class_ = self.unpack(b'!HH')

question = DNSQuestion(name, type, class_)

self.questions.append(question)

def read_int(self):

"""Reads an integer from the packet"""

return self.unpack(b'!I')[0]

def read_character_string(self):

"""Reads a character string from the packet"""

length = indexbytes(self.data, self.offset)

self.offset += 1

return self.read_string(length)

def read_string(self, length):

"""Reads a string of a given length from the packet"""

info = self.data[self.offset:self.offset + length]

self.offset += length

return info

def read_unsigned_short(self):

"""Reads an unsigned short from the packet"""

return self.unpack(b'!H')[0]

def read_others(self):

"""Reads the answers, authorities and additionals section of the

n = self.num_answers + self.num_authorities + self.num_additionals

for i in xrange(n):

domain = self.read_name()

type, class_, ttl, length = self.unpack(b'!HHiH')

rec = None

if type == _TYPE_A:

rec = DNSAddress(domain, type, class_, ttl, self.read_string(4))

elif type == _TYPE_CNAME or type == _TYPE_PTR:

rec = DNSPointer(domain, type, class_, ttl, self.read_name())

elif type == _TYPE_TXT:

rec = DNSText(domain, type, class_, ttl, self.read_string(length))

elif type == _TYPE_SRV:

rec = DNSService(domain, type, class_, ttl,

self.read_unsigned_short(), self.read_unsigned_short(),

self.read_unsigned_short(), self.read_name())

elif type == _TYPE_HINFO:

rec = DNSHinfo(domain, type, class_, ttl,

self.read_character_string(), self.read_character_string())

elif type == _TYPE_AAAA:

rec = DNSAddress(domain, type, class_, ttl, self.read_string(16))

else:

# Try to ignore types we don't know about

# Skip the payload for the resource record so the next

# records can be parsed correctly

self.offset += length

if rec is not None:

self.answers.append(rec)

def is_query(self):

"""Returns true if this is a query"""

return (self.flags & _FLAGS_QR_MASK) == _FLAGS_QR_QUERY

def is_response(self):

"""Returns true if this is a response"""

return (self.flags & _FLAGS_QR_MASK) == _FLAGS_QR_RESPONSE

def read_utf(self, offset, length):

"""Reads a UTF-8 string of a given length from the packet"""

return text_type(self.data[offset:offset + length], 'utf-8', 'replace')

def read_name(self):

"""Reads a domain name from the packet"""

result = ''

off = self.offset

next = -1

first = off

while True:

length = indexbytes(self.data, off)

off += 1

if length == 0:

break

t = length & 0xC0

if t == 0x00:

result = ''.join((result, self.read_utf(off, length) + '.'))

off += length

elif t == 0xC0:

if next < 0:

next = off + 1

off = ((length & 0x3F) << 8) | indexbytes(self.data, off)

if off >= first:

# TODO raise more specific exception

raise Exception("Bad domain name (circular) at %s" % (off,))

first = off

else:

# TODO raise more specific exception

raise Exception("Bad domain name at %s" % (off,))

if next >= 0:

self.offset = next

else:

self.offset = off

"""Object representation of an outgoing packet"""

def __init__(self, flags, multicast=True):

self.finished = False

self.id = 0

self.multicast = multicast

self.flags = flags

self.names = {}

self.data = []

self.size = 12

self.questions = []

self.answers = []

self.authorities = []

self.additionals = []

def add_question(self, record):

"""Adds a question"""

self.questions.append(record)

def add_answer(self, inp, record):

"""Adds an answer"""

if not record.suppressed_by(inp):

self.add_answer_at_time(record, 0)

def add_answer_at_time(self, record, now):

"""Adds an answer if if does not expire by a certain time"""

if record is not None:

if now == 0 or not record.is_expired(now):

self.answers.append((record, now))

def add_authorative_answer(self, record):

"""Adds an authoritative answer"""

self.authorities.append(record)

def add_additional_answer(self, record):

"""Adds an additional answer"""

self.additionals.append(record)

def pack(self, format, value):

self.data.append(struct.pack(format, value))

self.size += struct.calcsize(format)

def write_byte(self, value):

"""Writes a single byte to the packet"""

self.pack(b'!c', int2byte(value))

def insert_short(self, index, value):

"""Inserts an unsigned short in a certain position in the packet"""

self.data.insert(index, struct.pack(b'!H', value))

self.size += 2

def write_short(self, value):

"""Writes an unsigned short to the packet"""

self.pack(b'!H', value)

def write_int(self, value):

"""Writes an unsigned integer to the packet"""

self.pack(b'!I', int(value))

def write_string(self, value):

"""Writes a string to the packet"""

assert isinstance(value, bytes)

self.data.append(value)

self.size += len(value)

def write_utf(self, s):

"""Writes a UTF-8 string of a given length to the packet"""

utfstr = s.encode('utf-8')

length = len(utfstr)

if length > 64:

raise NamePartTooLongException

self.write_byte(length)

self.write_string(utfstr)

def write_name(self, name):

"""Writes a domain name to the packet"""

if name in self.names:

# Find existing instance of this name in packet

#

index = self.names[name]

# An index was found, so write a pointer to it

#

self.write_byte((index >> 8) | 0xC0)

self.write_byte(index & 0xFF)

else:

# No record of this name already, so write it

# out as normal, recording the location of the name

# for future pointers to it.

#

self.names[name] = self.size

parts = name.split('.')

if parts[-1] == '':

parts = parts[:-1]

for part in parts:

self.write_utf(part)

self.write_byte(0)

def write_question(self, question):

"""Writes a question to the packet"""

self.write_name(question.name)

self.write_short(question.type)

self.write_short(question.class_)

def write_record(self, record, now):

"""Writes a record (answer, authoritative answer, additional) to

self.write_name(record.name)

self.write_short(record.type)

if record.unique and self.multicast:

self.write_short(record.class_ | _CLASS_UNIQUE)

else:

self.write_short(record.class_)

if now == 0:

self.write_int(record.ttl)

else:

self.write_int(record.get_remaining_ttl(now))

index = len(self.data)

# Adjust size for the short we will write before this record

#

self.size += 2

record.write(self)

self.size -= 2

length = len(b''.join(self.data[index:]))

self.insert_short(index, length) # Here is the short we adjusted for

def packet(self):

"""Returns a string containing the packet's bytes

if not self.finished:

self.finished = True

for question in self.questions:

self.write_question(question)

for answer, time_ in self.answers:

self.write_record(answer, time_)

for authority in self.authorities:

self.write_record(authority, 0)

for additional in self.additionals:

self.write_record(additional, 0)

self.insert_short(0, len(self.additionals))

self.insert_short(0, len(self.authorities))

self.insert_short(0, len(self.answers))

self.insert_short(0, len(self.questions))

self.insert_short(0, self.flags)

if self.multicast:

self.insert_short(0, 0)

else:

self.insert_short(0, self.id)

"""A cache of DNS entries"""

def __init__(self):

self.cache = {}

def add(self, entry):

"""Adds an entry"""

self.cache.setdefault(entry.key, []).append(entry)

def remove(self, entry):

"""Removes an entry"""

try:

list_ = self.cache[entry.key]

list_.remove(entry)

except (KeyError, ValueError):

pass

def get(self, entry):

"""Gets an entry by key. Will return None if there is no

try:

list_ = self.cache[entry.key]

return list_[list_.index(entry)]

except (KeyError, ValueError):

return None

def get_by_details(self, name, type, class_):

"""Gets an entry by details. Will return None if there is

entry = DNSEntry(name, type, class_)

return self.get(entry)

def entries_with_name(self, name):

"""Returns a list of entries whose key matches the name."""

try:

return self.cache[name]

except KeyError:

return []

def entries(self):

"""Returns a list of all entries"""

if not self.cache:

return []

else:

"""An engine wraps read access to sockets, allowing objects that

def __init__(self, zc):

threading.Thread.__init__(self)

self.daemon = True

self.zc = zc

self.readers = {} # maps socket to reader

self.timeout = 5

self.condition = threading.Condition()

self.start()

def run(self):

while not _GLOBAL_DONE:

rs = self.get_readers()

if len(rs) == 0:

# No sockets to manage, but we wait for the timeout

# or addition of a socket

#

with self.condition:

self.condition.wait(self.timeout)

else:

try:

rr, wr, er = select.select(rs, [], [], self.timeout)

for socket_ in rr:

try:

self.readers[socket_].handle_read(socket_)

except Exception as e: # TODO stop catching all Exceptions

log.exception('Unknown error, possibly benign: %r', e)

except Exception as e: # TODO stop catching all Exceptions

log.exception('Unknown error, possibly benign: %r', e)

def get_readers(self):

result = []

with self.condition:

result = self.readers.keys()

return result

def add_reader(self, reader, socket):

with self.condition:

self.readers[socket] = reader

self.condition.notify()

def del_reader(self, socket):

with self.condition:

del self.readers[socket]

self.condition.notify()

def notify(self):

with self.condition:

"""A Listener is used by this module to listen on the multicast

def __init__(self, zc):

self.zc = zc

def handle_read(self, socket_):

try:

data, (addr, port) = socket_.recvfrom(_MAX_MSG_ABSOLUTE)

except socket.error as e:

# If the socket was closed by another thread -- which happens

# regularly on shutdown -- an EBADF exception is thrown here.

# Ignore it.

if e.errno == socket.EBADF:

return

else:

raise e

else:

log.debug('Received %r from %r:%r', data, addr, port)

self.data = data

msg = DNSIncoming(data)

if msg.is_query():

# Always multicast responses

#

if port == _MDNS_PORT:

self.zc.handle_query(msg, _MDNS_ADDR, _MDNS_PORT)

# If it's not a multicast query, reply via unicast

# and multicast

#

elif port == _DNS_PORT:

self.zc.handle_query(msg, addr, port)

self.zc.handle_query(msg, _MDNS_ADDR, _MDNS_PORT)

else:

"""A Reaper is used by this module to remove cache entries that

def __init__(self, zc):

threading.Thread.__init__(self)

self.daemon = True

self.zc = zc

self.start()

def run(self):

while True:

self.zc.wait(10 * 1000)

if _GLOBAL_DONE:

return

now = current_time_millis()

for record in self.zc.cache.entries():

if record.is_expired(now):

self.zc.update_record(now, record)

def __init__(self):

self._handlers = []

def fire(self, **kwargs):

for h in list(self._handlers):

h(**kwargs)

@property

def registration_interface(self):

def __init__(self, handlers):

self._handlers = handlers

def register_handler(self, handler):

self._handlers.append(handler)

return self

def unregister_handler(self, handler):

self._handlers.remove(handler)

"""Used to browse for a service of a specific type.

def __init__(self, zc, type_, handlers=None, listener=None):

"""Creates a browser for a specific type"""

assert handlers or listener, 'You need to specify at least one handler'

threading.Thread.__init__(self)

self.daemon = True

self.zc = zc

self.type = type_

self.services = {}

self.next_time = current_time_millis()

self.delay = _BROWSER_TIME

self._handlers_to_call = []

self.done = False

self.zc.add_listener(self, DNSQuestion(self.type, _TYPE_PTR, _CLASS_IN))

self._service_state_changed = Signal()

if hasattr(handlers, 'add_service'):

listener = handlers

handlers = None

handlers = handlers or []

if listener:

def on_change(zeroconf, service_type, name, state_change):

args = (zeroconf, service_type, name)

if state_change is ServiceStateChange.Added:

listener.add_service(*args)

elif state_change is ServiceStateChange.Removed:

listener.remove_service(*args)

else:

raise NotImplementedError(state_change)

handlers.append(on_change)

for h in handlers:

self.service_state_changed.register_handler(h)

self.start()

@property