beremiz: comparison Zeroconf.py

equal deleted inserted replaced

-:d0f7d36bf241
+:1c0d3aaacf3d
 Lesser General Public License for more details.
 You should have received a copy of the GNU Lesser General Public
 License along with this library; if not, write to the Free Software
 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 """
 """0.12 update - allow selection of binding interface
-		 typo fix - Thanks A. M. Kuchlingi
+typo fix - Thanks A. M. Kuchlingi
-		 removed all use of word 'Rendezvous' - this is an API change"""
+removed all use of word 'Rendezvous' - this is an API change"""
 """0.11 update - correction to comments for addListener method
 support for new record types seen from OS X
-				  - IPv6 address
+- IPv6 address
-				  - hostinfo
+- hostinfo
-				 ignore unknown DNS record types
+ignore unknown DNS record types
-				 fixes to name decoding
+fixes to name decoding
-				 works alongside other processes using port 5353 (e.g. on Mac OS X)
+works alongside other processes using port 5353 (e.g. on Mac OS X)
-				 tested against Mac OS X 10.3.2's mDNSResponder
+tested against Mac OS X 10.3.2's mDNSResponder
-				 corrections to removal of list entries for service browser"""
+corrections to removal of list entries for service browser"""
 """0.10 update - Jonathon Paisley contributed these corrections:
 always multicast replies, even when query is unicast
-				 correct a pointer encoding problem
+correct a pointer encoding problem
-				 can now write records in any order
+can now write records in any order
-				 traceback shown on failure
+traceback shown on failure
-				 better TXT record parsing
+better TXT record parsing
-				 server is now separate from name
+server is now separate from name
-				 can cancel a service browser
+can cancel a service browser
-				 modified some unit tests to accommodate these changes"""
+modified some unit tests to accommodate these changes"""
 """0.09 update - remove all records on service unregistration
 fix DOS security problem with readName"""
 """0.08 update - changed licensing to LGPL"""
 """0.07 update - faster shutdown on engine
 pointer encoding of outgoing names
-				 ServiceBrowser now works
+ServiceBrowser now works
-				 new unit tests"""
+new unit tests"""
 """0.06 update - small improvements with unit tests
 added defined exception types
-				 new style objects
+new style objects
-				 fixed hostname/interface problem
+fixed hostname/interface problem
-				 fixed socket timeout problem
+fixed socket timeout problem
-				 fixed addServiceListener() typo bug
+fixed addServiceListener() typo bug
-				 using select() for socket reads
+using select() for socket reads
-				 tested on Debian unstable with Python 2.2.2"""
+tested on Debian unstable with Python 2.2.2"""
 """0.05 update - ensure case insensitivty on domain names
 support for unicast DNS queries"""
 """0.04 update - added some unit tests
 added __ne__ adjuncts where required
-				 ensure names end in '.local.'
+ensure names end in '.local.'
-				 timeout on receiving socket for clean shutdown"""
+timeout on receiving socket for clean shutdown"""
 __author__ = "Paul Scott-Murphy"
 __email__ = "paul at scott dash murphy dot com"
 __version__ = "0.12"
 _REGISTER_TIME = 225
 _LISTENER_TIME = 200
 _BROWSER_TIME = 500
 # Some DNS constants
 _MDNS_ADDR = '224.0.0.251'
 _MDNS_PORT = 5353;
 _DNS_PORT = 53;
 _DNS_TTL = 60 * 60; # one hour default TTL
 _TYPE_ANY =  255
 # Mapping constants to names
 _CLASSES = { _CLASS_IN : "in",
-			 _CLASS_CS : "cs",
+_CLASS_CS : "cs",
-			 _CLASS_CH : "ch",
+_CLASS_CH : "ch",
-			 _CLASS_HS : "hs",
+_CLASS_HS : "hs",
-			 _CLASS_NONE : "none",
+_CLASS_NONE : "none",
-			 _CLASS_ANY : "any" }
+_CLASS_ANY : "any" }
 _TYPES = { _TYPE_A : "a",
-		   _TYPE_NS : "ns",
+_TYPE_NS : "ns",
-		   _TYPE_MD : "md",
+_TYPE_MD : "md",
-		   _TYPE_MF : "mf",
+_TYPE_MF : "mf",
-		   _TYPE_CNAME : "cname",
+_TYPE_CNAME : "cname",
-		   _TYPE_SOA : "soa",
+_TYPE_SOA : "soa",
-		   _TYPE_MB : "mb",
+_TYPE_MB : "mb",
-		   _TYPE_MG : "mg",
+_TYPE_MG : "mg",
-		   _TYPE_MR : "mr",
+_TYPE_MR : "mr",
-		   _TYPE_NULL : "null",
+_TYPE_NULL : "null",
-		   _TYPE_WKS : "wks",
+_TYPE_WKS : "wks",
-		   _TYPE_PTR : "ptr",
+_TYPE_PTR : "ptr",
-		   _TYPE_HINFO : "hinfo",
+_TYPE_HINFO : "hinfo",
-		   _TYPE_MINFO : "minfo",
+_TYPE_MINFO : "minfo",
-		   _TYPE_MX : "mx",
+_TYPE_MX : "mx",
-		   _TYPE_TXT : "txt",
+_TYPE_TXT : "txt",
-		   _TYPE_AAAA : "quada",
+_TYPE_AAAA : "quada",
-		   _TYPE_SRV : "srv",
+_TYPE_SRV : "srv",
-		   _TYPE_ANY : "any" }
+_TYPE_ANY : "any" }
 # utility functions
 def currentTimeMillis():
-	"""Current system time in milliseconds"""
+"""Current system time in milliseconds"""
-	return time.time() * 1000
+return time.time() * 1000
 # Exceptions
 class NonLocalNameException(Exception):
-	pass
+pass
 class NonUniqueNameException(Exception):
-	pass
+pass
 class NamePartTooLongException(Exception):
-	pass
+pass
 class AbstractMethodException(Exception):
-	pass
+pass
 class BadTypeInNameException(Exception):
-	pass
+pass
 # implementation classes
 class DNSEntry(object):
-	"""A DNS entry"""
+"""A DNS entry"""
-	def __init__(self, name, type, clazz):
+def __init__(self, name, type, clazz):
-		self.key = string.lower(name)
+self.key = string.lower(name)
-		self.name = name
+self.name = name
-		self.type = type
+self.type = type
-		self.clazz = clazz & _CLASS_MASK
+self.clazz = clazz & _CLASS_MASK
-		self.unique = (clazz & _CLASS_UNIQUE) != 0
+self.unique = (clazz & _CLASS_UNIQUE) != 0
-	def __eq__(self, other):
+def __eq__(self, other):
-		"""Equality test on name, type, and class"""
+"""Equality test on name, type, and class"""
-		if isinstance(other, DNSEntry):
+if isinstance(other, DNSEntry):
-			return self.name == other.name and self.type == other.type and self.clazz == other.clazz
+return self.name == other.name and self.type == other.type and self.clazz == other.clazz
-		return 0
+return 0
-	def __ne__(self, other):
+def __ne__(self, other):
-		"""Non-equality test"""
+"""Non-equality test"""
-		return not self.__eq__(other)
+return not self.__eq__(other)
-	def getClazz(self, clazz):
+def getClazz(self, clazz):
-		"""Class accessor"""
+"""Class accessor"""
-		try:
+try:
-			return _CLASSES[clazz]
+return _CLASSES[clazz]
-		except:
+except:
-			return "?(%s)" % (clazz)
+return "?(%s)" % (clazz)
-	def getType(self, type):
+def getType(self, type):
-		"""Type accessor"""
+"""Type accessor"""
-		try:
+try:
-			return _TYPES[type]
+return _TYPES[type]
-		except:
+except:
-			return "?(%s)" % (type)
+return "?(%s)" % (type)
-	def toString(self, hdr, other):
+def toString(self, hdr, other):
-		"""String representation with additional information"""
+"""String representation with additional information"""
-		result = "%s[%s,%s" % (hdr, self.getType(self.type), self.getClazz(self.clazz))
+result = "%s[%s,%s" % (hdr, self.getType(self.type), self.getClazz(self.clazz))
-		if self.unique:
+if self.unique:
-			result += "-unique,"
+result += "-unique,"
-		else:
+else:
-			result += ","
+result += ","
-		result += self.name
+result += self.name
-		if other is not None:
+if other is not None:
-			result += ",%s]" % (other)
+result += ",%s]" % (other)
-		else:
+else:
-			result += "]"
+result += "]"
-		return result
+return result
 class DNSQuestion(DNSEntry):
-	"""A DNS question entry"""
+"""A DNS question entry"""
-	def __init__(self, name, type, clazz):
+def __init__(self, name, type, clazz):
-		if not name.endswith(".local."):
+if not name.endswith(".local."):
-			raise NonLocalNameException
+raise NonLocalNameException
-		DNSEntry.__init__(self, name, type, clazz)
+DNSEntry.__init__(self, name, type, clazz)
-	def answeredBy(self, rec):
+def answeredBy(self, rec):
-		"""Returns true if the question is answered by the record"""
+"""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
+return self.clazz == rec.clazz and (self.type == rec.type or self.type == _TYPE_ANY) and self.name == rec.name
-	def __repr__(self):
+def __repr__(self):
-		"""String representation"""
+"""String representation"""
-		return DNSEntry.toString(self, "question", None)
+return DNSEntry.toString(self, "question", None)
 class DNSRecord(DNSEntry):
-	"""A DNS record - like a DNS entry, but has a TTL"""
+"""A DNS record - like a DNS entry, but has a TTL"""
-	def __init__(self, name, type, clazz, ttl):
+def __init__(self, name, type, clazz, ttl):
-		DNSEntry.__init__(self, name, type, clazz)
+DNSEntry.__init__(self, name, type, clazz)
-		self.ttl = ttl
+self.ttl = ttl
-		self.created = currentTimeMillis()
+self.created = currentTimeMillis()
-	def __eq__(self, other):
+def __eq__(self, other):
-		"""Tests equality as per DNSRecord"""
+"""Tests equality as per DNSRecord"""
-		if isinstance(other, DNSRecord):
+if isinstance(other, DNSRecord):
-			return DNSEntry.__eq__(self, other)
+return DNSEntry.__eq__(self, other)
-		return 0
+return 0
-	def suppressedBy(self, msg):
+def suppressedBy(self, msg):
-		"""Returns true if any answer in a message can suffice for the
+"""Returns true if any answer in a message can suffice for the
-		information held in this record."""
+information held in this record."""
-		for record in msg.answers:
+for record in msg.answers:
-			if self.suppressedByAnswer(record):
+if self.suppressedByAnswer(record):
-				return 1
+return 1
-		return 0
+return 0
-	def suppressedByAnswer(self, other):
+def suppressedByAnswer(self, other):
-		"""Returns true if another record has same name, type and class,
+"""Returns true if another record has same name, type and class,
-		and if its TTL is at least half of this record's."""
+and if its TTL is at least half of this record's."""
-		if self == other and other.ttl > (self.ttl / 2):
+if self == other and other.ttl > (self.ttl / 2):
-			return 1
+return 1
-		return 0
+return 0
-	def getExpirationTime(self, percent):
+def getExpirationTime(self, percent):
-		"""Returns the time at which this record will have expired
+"""Returns the time at which this record will have expired
-		by a certain percentage."""
+by a certain percentage."""
-		return self.created + (percent * self.ttl * 10)
+return self.created + (percent * self.ttl * 10)
-	def getRemainingTTL(self, now):
+def getRemainingTTL(self, now):
-		"""Returns the remaining TTL in seconds."""
+"""Returns the remaining TTL in seconds."""
-		return max(0, (self.getExpirationTime(100) - now) / 1000)
+return max(0, (self.getExpirationTime(100) - now) / 1000)
-	def isExpired(self, now):
+def isExpired(self, now):
-		"""Returns true if this record has expired."""
+"""Returns true if this record has expired."""
-		return self.getExpirationTime(100) <= now
+return self.getExpirationTime(100) <= now
-	def isStale(self, now):
+def isStale(self, now):
-		"""Returns true if this record is at least half way expired."""
+"""Returns true if this record is at least half way expired."""
-		return self.getExpirationTime(50) <= now
+return self.getExpirationTime(50) <= now
-	def resetTTL(self, other):
+def resetTTL(self, other):
-		"""Sets this record's TTL and created time to that of
+"""Sets this record's TTL and created time to that of
-		another record."""
+another record."""
-		self.created = other.created
+self.created = other.created
-		self.ttl = other.ttl
+self.ttl = other.ttl
-	def write(self, out):
+def write(self, out):
-		"""Abstract method"""
+"""Abstract method"""
-		raise AbstractMethodException
+raise AbstractMethodException
-	def toString(self, other):
+def toString(self, other):
-		"""String representation with addtional information"""
+"""String representation with addtional information"""
-		arg = "%s/%s,%s" % (self.ttl, self.getRemainingTTL(currentTimeMillis()), other)
+arg = "%s/%s,%s" % (self.ttl, self.getRemainingTTL(currentTimeMillis()), other)
-		return DNSEntry.toString(self, "record", arg)
+return DNSEntry.toString(self, "record", arg)
 class DNSAddress(DNSRecord):
-	"""A DNS address record"""
+"""A DNS address record"""
-	def __init__(self, name, type, clazz, ttl, address):
+def __init__(self, name, type, clazz, ttl, address):
-		DNSRecord.__init__(self, name, type, clazz, ttl)
+DNSRecord.__init__(self, name, type, clazz, ttl)
-		self.address = address
+self.address = address
-	def write(self, out):
+def write(self, out):
-		"""Used in constructing an outgoing packet"""
+"""Used in constructing an outgoing packet"""
-		out.writeString(self.address, len(self.address))
+out.writeString(self.address, len(self.address))
-	def __eq__(self, other):
+def __eq__(self, other):
-		"""Tests equality on address"""
+"""Tests equality on address"""
-		if isinstance(other, DNSAddress):
+if isinstance(other, DNSAddress):
-			return self.address == other.address
+return self.address == other.address
-		return 0
+return 0
-	def __repr__(self):
+def __repr__(self):
-		"""String representation"""
+"""String representation"""
-		try:
+try:
-			return socket.inet_ntoa(self.address)
+return socket.inet_ntoa(self.address)
-		except:
+except:
-			return self.address
+return self.address
 class DNSHinfo(DNSRecord):
-	"""A DNS host information record"""
+"""A DNS host information record"""
-	def __init__(self, name, type, clazz, ttl, cpu, os):
+def __init__(self, name, type, clazz, ttl, cpu, os):
-		DNSRecord.__init__(self, name, type, clazz, ttl)
+DNSRecord.__init__(self, name, type, clazz, ttl)
-		self.cpu = cpu
+self.cpu = cpu
-		self.os = os
+self.os = os
-	def write(self, out):
+def write(self, out):
-		"""Used in constructing an outgoing packet"""
+"""Used in constructing an outgoing packet"""
-		out.writeString(self.cpu, len(self.cpu))
+out.writeString(self.cpu, len(self.cpu))
-		out.writeString(self.os, len(self.os))
+out.writeString(self.os, len(self.os))
-	def __eq__(self, other):
+def __eq__(self, other):
-		"""Tests equality on cpu and os"""
+"""Tests equality on cpu and os"""
-		if isinstance(other, DNSHinfo):
+if isinstance(other, DNSHinfo):
-			return self.cpu == other.cpu and self.os == other.os
+return self.cpu == other.cpu and self.os == other.os
-		return 0
+return 0
-	def __repr__(self):
+def __repr__(self):
-		"""String representation"""
+"""String representation"""
-		return self.cpu + " " + self.os
+return self.cpu + " " + self.os
 class DNSPointer(DNSRecord):
-	"""A DNS pointer record"""
+"""A DNS pointer record"""
-	def __init__(self, name, type, clazz, ttl, alias):
+def __init__(self, name, type, clazz, ttl, alias):
-		DNSRecord.__init__(self, name, type, clazz, ttl)
+DNSRecord.__init__(self, name, type, clazz, ttl)
-		self.alias = alias
+self.alias = alias
-	def write(self, out):
+def write(self, out):
-		"""Used in constructing an outgoing packet"""
+"""Used in constructing an outgoing packet"""
-		out.writeName(self.alias)
+out.writeName(self.alias)
-	def __eq__(self, other):
+def __eq__(self, other):
-		"""Tests equality on alias"""
+"""Tests equality on alias"""
-		if isinstance(other, DNSPointer):
+if isinstance(other, DNSPointer):
-			return self.alias == other.alias
+return self.alias == other.alias
-		return 0
+return 0
-	def __repr__(self):
+def __repr__(self):
-		"""String representation"""
+"""String representation"""
-		return self.toString(self.alias)
+return self.toString(self.alias)
 class DNSText(DNSRecord):
-	"""A DNS text record"""
+"""A DNS text record"""
-	def __init__(self, name, type, clazz, ttl, text):
+def __init__(self, name, type, clazz, ttl, text):
-		DNSRecord.__init__(self, name, type, clazz, ttl)
+DNSRecord.__init__(self, name, type, clazz, ttl)
-		self.text = text
+self.text = text
-	def write(self, out):
+def write(self, out):
-		"""Used in constructing an outgoing packet"""
+"""Used in constructing an outgoing packet"""
-		out.writeString(self.text, len(self.text))
+out.writeString(self.text, len(self.text))
-	def __eq__(self, other):
+def __eq__(self, other):
-		"""Tests equality on text"""
+"""Tests equality on text"""
-		if isinstance(other, DNSText):
+if isinstance(other, DNSText):
-			return self.text == other.text
+return self.text == other.text
-		return 0
+return 0
-	def __repr__(self):
+def __repr__(self):
-		"""String representation"""
+"""String representation"""
-		if len(self.text) > 10:
+if len(self.text) > 10:
-			return self.toString(self.text[:7] + "...")
+return self.toString(self.text[:7] + "...")
-		else:
+else:
-			return self.toString(self.text)
+return self.toString(self.text)
 class DNSService(DNSRecord):
-	"""A DNS service record"""
+"""A DNS service record"""
-	def __init__(self, name, type, clazz, ttl, priority, weight, port, server):
+def __init__(self, name, type, clazz, ttl, priority, weight, port, server):
-		DNSRecord.__init__(self, name, type, clazz, ttl)
+DNSRecord.__init__(self, name, type, clazz, ttl)
-		self.priority = priority
+self.priority = priority
-		self.weight = weight
+self.weight = weight
-		self.port = port
+self.port = port
-		self.server = server
+self.server = server
-	def write(self, out):
+def write(self, out):
-		"""Used in constructing an outgoing packet"""
+"""Used in constructing an outgoing packet"""
-		out.writeShort(self.priority)
+out.writeShort(self.priority)
-		out.writeShort(self.weight)
+out.writeShort(self.weight)
-		out.writeShort(self.port)
+out.writeShort(self.port)
-		out.writeName(self.server)
+out.writeName(self.server)
-	def __eq__(self, other):
+def __eq__(self, other):
-		"""Tests equality on priority, weight, port and server"""
+"""Tests equality on priority, weight, port and server"""
-		if isinstance(other, DNSService):
+if isinstance(other, DNSService):
-			return self.priority == other.priority and self.weight == other.weight and self.port == other.port and self.server == other.server
+return self.priority == other.priority and self.weight == other.weight and self.port == other.port and self.server == other.server
-		return 0
+return 0
-	def __repr__(self):
+def __repr__(self):
-		"""String representation"""
+"""String representation"""
-		return self.toString("%s:%s" % (self.server, self.port))
+return self.toString("%s:%s" % (self.server, self.port))
 class DNSIncoming(object):
-	"""Object representation of an incoming DNS packet"""
+"""Object representation of an incoming DNS packet"""
-	def __init__(self, data):
+def __init__(self, data):
-		"""Constructor from string holding bytes of packet"""
+"""Constructor from string holding bytes of packet"""
-		self.offset = 0
+self.offset = 0
-		self.data = data
+self.data = data
-		self.questions = []
+self.questions = []
-		self.answers = []
+self.answers = []
-		self.numQuestions = 0
+self.numQuestions = 0
-		self.numAnswers = 0
+self.numAnswers = 0
-		self.numAuthorities = 0
+self.numAuthorities = 0
-		self.numAdditionals = 0
+self.numAdditionals = 0
-		self.readHeader()
+self.readHeader()
-		self.readQuestions()
+self.readQuestions()
-		self.readOthers()
+self.readOthers()
-	def readHeader(self):
+def readHeader(self):
-		"""Reads header portion of packet"""
+"""Reads header portion of packet"""
-		format = '!HHHHHH'
+format = '!HHHHHH'
-		length = struct.calcsize(format)
+length = struct.calcsize(format)
-		info = struct.unpack(format, self.data[self.offset:self.offset+length])
+info = struct.unpack(format, self.data[self.offset:self.offset+length])
-		self.offset += length
+self.offset += length
-		self.id = info[0]
+self.id = info[0]
-		self.flags = info[1]
+self.flags = info[1]
-		self.numQuestions = info[2]
+self.numQuestions = info[2]
-		self.numAnswers = info[3]
+self.numAnswers = info[3]
-		self.numAuthorities = info[4]
+self.numAuthorities = info[4]
-		self.numAdditionals = info[5]
+self.numAdditionals = info[5]
-	def readQuestions(self):
+def readQuestions(self):
-		"""Reads questions section of packet"""
+"""Reads questions section of packet"""
-		format = '!HH'
+format = '!HH'
-		length = struct.calcsize(format)
+length = struct.calcsize(format)
-		for i in range(0, self.numQuestions):
+for i in range(0, self.numQuestions):
-			name = self.readName()
+name = self.readName()
-			info = struct.unpack(format, self.data[self.offset:self.offset+length])
+info = struct.unpack(format, self.data[self.offset:self.offset+length])
-			self.offset += length
+self.offset += length
-			question = DNSQuestion(name, info[0], info[1])
+question = DNSQuestion(name, info[0], info[1])
-			self.questions.append(question)
+self.questions.append(question)
-	def readInt(self):
+def readInt(self):
-		"""Reads an integer from the packet"""
+"""Reads an integer from the packet"""
-		format = '!I'
+format = '!I'
-		length = struct.calcsize(format)
+length = struct.calcsize(format)
-		info = struct.unpack(format, self.data[self.offset:self.offset+length])
+info = struct.unpack(format, self.data[self.offset:self.offset+length])
-		self.offset += length
+self.offset += length
-		return info[0]
+return info[0]
-	def readCharacterString(self):
+def readCharacterString(self):
-		"""Reads a character string from the packet"""
+"""Reads a character string from the packet"""
-		length = ord(self.data[self.offset])
+length = ord(self.data[self.offset])
-		self.offset += 1
+self.offset += 1
-		return self.readString(length)
+return self.readString(length)
-	def readString(self, len):
+def readString(self, len):
-		"""Reads a string of a given length from the packet"""
+"""Reads a string of a given length from the packet"""
-		format = '!' + str(len) + 's'
+format = '!' + str(len) + 's'
-		length =  struct.calcsize(format)
+length =  struct.calcsize(format)
-		info = struct.unpack(format, self.data[self.offset:self.offset+length])
+info = struct.unpack(format, self.data[self.offset:self.offset+length])
-		self.offset += length
+self.offset += length
-		return info[0]
+return info[0]
-	def readUnsignedShort(self):
+def readUnsignedShort(self):
-		"""Reads an unsigned short from the packet"""
+"""Reads an unsigned short from the packet"""
-		format = '!H'
+format = '!H'
-		length = struct.calcsize(format)
+length = struct.calcsize(format)
-		info = struct.unpack(format, self.data[self.offset:self.offset+length])
+info = struct.unpack(format, self.data[self.offset:self.offset+length])
-		self.offset += length
+self.offset += length
-		return info[0]
+return info[0]
-	def readOthers(self):
+def readOthers(self):
-		"""Reads the answers, authorities and additionals section of the packet"""
+"""Reads the answers, authorities and additionals section of the packet"""
-		format = '!HHiH'
+format = '!HHiH'
-		length = struct.calcsize(format)
+length = struct.calcsize(format)
-		n = self.numAnswers + self.numAuthorities + self.numAdditionals
+n = self.numAnswers + self.numAuthorities + self.numAdditionals
-		for i in range(0, n):
+for i in range(0, n):
-			domain = self.readName()
+domain = self.readName()
-			info = struct.unpack(format, self.data[self.offset:self.offset+length])
+info = struct.unpack(format, self.data[self.offset:self.offset+length])
-			self.offset += length
+self.offset += length
-			rec = None
+rec = None
-			if info[0] == _TYPE_A:
+if info[0] == _TYPE_A:
-				rec = DNSAddress(domain, info[0], info[1], info[2], self.readString(4))
+rec = DNSAddress(domain, info[0], info[1], info[2], self.readString(4))
-			elif info[0] == _TYPE_CNAME or info[0] == _TYPE_PTR:
+elif info[0] == _TYPE_CNAME or info[0] == _TYPE_PTR:
-				rec = DNSPointer(domain, info[0], info[1], info[2], self.readName())
+rec = DNSPointer(domain, info[0], info[1], info[2], self.readName())
-			elif info[0] == _TYPE_TXT:
+elif info[0] == _TYPE_TXT:
-				rec = DNSText(domain, info[0], info[1], info[2], self.readString(info[3]))
+rec = DNSText(domain, info[0], info[1], info[2], self.readString(info[3]))
-			elif info[0] == _TYPE_SRV:
+elif info[0] == _TYPE_SRV:
-				rec = DNSService(domain, info[0], info[1], info[2], self.readUnsignedShort(), self.readUnsignedShort(), self.readUnsignedShort(), self.readName())
+rec = DNSService(domain, info[0], info[1], info[2], self.readUnsignedShort(), self.readUnsignedShort(), self.readUnsignedShort(), self.readName())
-			elif info[0] == _TYPE_HINFO:
+elif info[0] == _TYPE_HINFO:
-				rec = DNSHinfo(domain, info[0], info[1], info[2], self.readCharacterString(), self.readCharacterString())
+rec = DNSHinfo(domain, info[0], info[1], info[2], self.readCharacterString(), self.readCharacterString())
-			elif info[0] == _TYPE_AAAA:
+elif info[0] == _TYPE_AAAA:
-				rec = DNSAddress(domain, info[0], info[1], info[2], self.readString(16))
+rec = DNSAddress(domain, info[0], info[1], info[2], self.readString(16))
-			else:
+else:
-				# Try to ignore types we don't know about
+# Try to ignore types we don't know about
-				# this may mean the rest of the name is
+# this may mean the rest of the name is
-				# unable to be parsed, and may show errors
+# unable to be parsed, and may show errors
-				# so this is left for debugging.  New types
+# so this is left for debugging.  New types
-				# encountered need to be parsed properly.
+# encountered need to be parsed properly.
-				#
+#
-				#print "UNKNOWN TYPE = " + str(info[0])
+#print "UNKNOWN TYPE = " + str(info[0])
-				#raise BadTypeInNameException
+#raise BadTypeInNameException
-				pass
+pass
-			if rec is not None:
+if rec is not None:
-				self.answers.append(rec)
+self.answers.append(rec)
-	def isQuery(self):
+def isQuery(self):
-		"""Returns true if this is a query"""
+"""Returns true if this is a query"""
-		return (self.flags & _FLAGS_QR_MASK) == _FLAGS_QR_QUERY
+return (self.flags & _FLAGS_QR_MASK) == _FLAGS_QR_QUERY
-	def isResponse(self):
+def isResponse(self):
-		"""Returns true if this is a response"""
+"""Returns true if this is a response"""
-		return (self.flags & _FLAGS_QR_MASK) == _FLAGS_QR_RESPONSE
+return (self.flags & _FLAGS_QR_MASK) == _FLAGS_QR_RESPONSE
-	def readUTF(self, offset, len):
+def readUTF(self, offset, len):
-		"""Reads a UTF-8 string of a given length from the packet"""
+"""Reads a UTF-8 string of a given length from the packet"""
-		result = self.data[offset:offset+len].decode('utf-8')
+result = self.data[offset:offset+len].decode('utf-8')
-		return result
+return result
-	def readName(self):
+def readName(self):
-		"""Reads a domain name from the packet"""
+"""Reads a domain name from the packet"""
-		result = ''
+result = ''
-		off = self.offset
+off = self.offset
-		next = -1
+next = -1
-		first = off
+first = off
-		while 1:
+while 1:
-			len = ord(self.data[off])
+len = ord(self.data[off])
-			off += 1
+off += 1
-			if len == 0:
+if len == 0:
-				break
+break
-			t = len & 0xC0
+t = len & 0xC0
-			if t == 0x00:
+if t == 0x00:
-				result = ''.join((result, self.readUTF(off, len) + '.'))
+result = ''.join((result, self.readUTF(off, len) + '.'))
-				off += len
+off += len
-			elif t == 0xC0:
+elif t == 0xC0:
-				if next < 0:
+if next < 0:
-					next = off + 1
+next = off + 1
-				off = ((len & 0x3F) << 8) | ord(self.data[off])
+off = ((len & 0x3F) << 8) | ord(self.data[off])
-				if off >= first:
+if off >= first:
-					raise "Bad domain name (circular) at " + str(off)
+raise "Bad domain name (circular) at " + str(off)
-				first = off
+first = off
-			else:
+else:
-				raise "Bad domain name at " + str(off)
+raise "Bad domain name at " + str(off)
-		if next >= 0:
+if next >= 0:
-			self.offset = next
+self.offset = next
-		else:
+else:
-			self.offset = off
+self.offset = off
-		return result
+return result
 class DNSOutgoing(object):
-	"""Object representation of an outgoing packet"""
+"""Object representation of an outgoing packet"""
-	def __init__(self, flags, multicast = 1):
+def __init__(self, flags, multicast = 1):
-		self.finished = 0
+self.finished = 0
-		self.id = 0
+self.id = 0
-		self.multicast = multicast
+self.multicast = multicast
-		self.flags = flags
+self.flags = flags
-		self.names = {}
+self.names = {}
-		self.data = []
+self.data = []
-		self.size = 12
+self.size = 12
-		self.questions = []
+self.questions = []
-		self.answers = []
+self.answers = []
-		self.authorities = []
+self.authorities = []
-		self.additionals = []
+self.additionals = []
-	def addQuestion(self, record):
+def addQuestion(self, record):
-		"""Adds a question"""
+"""Adds a question"""
-		self.questions.append(record)
+self.questions.append(record)
-	def addAnswer(self, inp, record):
+def addAnswer(self, inp, record):
-		"""Adds an answer"""
+"""Adds an answer"""
-		if not record.suppressedBy(inp):
+if not record.suppressedBy(inp):
-			self.addAnswerAtTime(record, 0)
+self.addAnswerAtTime(record, 0)
-	def addAnswerAtTime(self, record, now):
+def addAnswerAtTime(self, record, now):
-		"""Adds an answer if if does not expire by a certain time"""
+"""Adds an answer if if does not expire by a certain time"""
-		if record is not None:
+if record is not None:
-			if now == 0 or not record.isExpired(now):
+if now == 0 or not record.isExpired(now):
-				self.answers.append((record, now))
+self.answers.append((record, now))
-	def addAuthorativeAnswer(self, record):
+def addAuthorativeAnswer(self, record):
-		"""Adds an authoritative answer"""
+"""Adds an authoritative answer"""
-		self.authorities.append(record)
+self.authorities.append(record)
-	def addAdditionalAnswer(self, record):
+def addAdditionalAnswer(self, record):
-		"""Adds an additional answer"""
+"""Adds an additional answer"""
-		self.additionals.append(record)
+self.additionals.append(record)
-	def writeByte(self, value):
+def writeByte(self, value):
-		"""Writes a single byte to the packet"""
+"""Writes a single byte to the packet"""
-		format = '!c'
+format = '!c'
-		self.data.append(struct.pack(format, chr(value)))
+self.data.append(struct.pack(format, chr(value)))
-		self.size += 1
+self.size += 1
-	def insertShort(self, index, value):
+def insertShort(self, index, value):
-		"""Inserts an unsigned short in a certain position in the packet"""
+"""Inserts an unsigned short in a certain position in the packet"""
-		format = '!H'
+format = '!H'
-		self.data.insert(index, struct.pack(format, value))
+self.data.insert(index, struct.pack(format, value))
-		self.size += 2
+self.size += 2
-	def writeShort(self, value):
+def writeShort(self, value):
-		"""Writes an unsigned short to the packet"""
+"""Writes an unsigned short to the packet"""
-		format = '!H'
+format = '!H'
-		self.data.append(struct.pack(format, value))
+self.data.append(struct.pack(format, value))
-		self.size += 2
+self.size += 2
-	def writeInt(self, value):
+def writeInt(self, value):
-		"""Writes an unsigned integer to the packet"""
+"""Writes an unsigned integer to the packet"""
-		format = '!I'
+format = '!I'
-		self.data.append(struct.pack(format, int(value)))
+self.data.append(struct.pack(format, int(value)))
-		self.size += 4
+self.size += 4
-	def writeString(self, value, length):
+def writeString(self, value, length):
-		"""Writes a string to the packet"""
+"""Writes a string to the packet"""
-		format = '!' + str(length) + 's'
+format = '!' + str(length) + 's'
-		self.data.append(struct.pack(format, value))
+self.data.append(struct.pack(format, value))
-		self.size += length
+self.size += length
-	def writeUTF(self, s):
+def writeUTF(self, s):
-		"""Writes a UTF-8 string of a given length to the packet"""
+"""Writes a UTF-8 string of a given length to the packet"""
-		utfstr = s.encode('utf-8')
+utfstr = s.encode('utf-8')
-		length = len(utfstr)
+length = len(utfstr)
-		if length > 64:
+if length > 64:
-			raise NamePartTooLongException
+raise NamePartTooLongException
-		self.writeByte(length)
+self.writeByte(length)
-		self.writeString(utfstr, length)
+self.writeString(utfstr, length)
-	def writeName(self, name):
+def writeName(self, name):
-		"""Writes a domain name to the packet"""
+"""Writes a domain name to the packet"""
-		try:
+try:
-			# Find existing instance of this name in packet
+# Find existing instance of this name in packet
-			#
+#
-			index = self.names[name]
+index = self.names[name]
-		except KeyError:
+except KeyError:
-			# No record of this name already, so write it
+# No record of this name already, so write it
-			# out as normal, recording the location of the name
+# out as normal, recording the location of the name
-			# for future pointers to it.
+# for future pointers to it.
-			#
+#
-			self.names[name] = self.size
+self.names[name] = self.size
-			parts = name.split('.')
+parts = name.split('.')
-			if parts[-1] == '':
+if parts[-1] == '':
-				parts = parts[:-1]
+parts = parts[:-1]
-			for part in parts:
+for part in parts:
-				self.writeUTF(part)
+self.writeUTF(part)
-			self.writeByte(0)
+self.writeByte(0)
-			return
+return
-		# An index was found, so write a pointer to it
+# An index was found, so write a pointer to it
-		#
+#
-		self.writeByte((index >> 8) | 0xC0)
+self.writeByte((index >> 8) | 0xC0)
-		self.writeByte(index)
+self.writeByte(index)
-	def writeQuestion(self, question):
+def writeQuestion(self, question):
-		"""Writes a question to the packet"""
+"""Writes a question to the packet"""
-		self.writeName(question.name)
+self.writeName(question.name)
-		self.writeShort(question.type)
+self.writeShort(question.type)
-		self.writeShort(question.clazz)
+self.writeShort(question.clazz)
-	def writeRecord(self, record, now):
+def writeRecord(self, record, now):
-		"""Writes a record (answer, authoritative answer, additional) to
+"""Writes a record (answer, authoritative answer, additional) to
-		the packet"""
+the packet"""
-		self.writeName(record.name)
+self.writeName(record.name)
-		self.writeShort(record.type)
+self.writeShort(record.type)
-		if record.unique and self.multicast:
+if record.unique and self.multicast:
-			self.writeShort(record.clazz | _CLASS_UNIQUE)
+self.writeShort(record.clazz | _CLASS_UNIQUE)
-		else:
+else:
-			self.writeShort(record.clazz)
+self.writeShort(record.clazz)
-		if now == 0:
+if now == 0:
-			self.writeInt(record.ttl)
+self.writeInt(record.ttl)
-		else:
+else:
-			self.writeInt(record.getRemainingTTL(now))
+self.writeInt(record.getRemainingTTL(now))
-		index = len(self.data)
+index = len(self.data)
-		# Adjust size for the short we will write before this record
+# Adjust size for the short we will write before this record
-		#
+#
-		self.size += 2
+self.size += 2
-		record.write(self)
+record.write(self)
-		self.size -= 2
+self.size -= 2
-		length = len(''.join(self.data[index:]))
+length = len(''.join(self.data[index:]))
-		self.insertShort(index, length) # Here is the short we adjusted for
+self.insertShort(index, length) # Here is the short we adjusted for
-	def packet(self):
+def packet(self):
-		"""Returns a string containing the packet's bytes
+"""Returns a string containing the packet's bytes
-		No further parts should be added to the packet once this
+No further parts should be added to the packet once this
-		is done."""
+is done."""
-		if not self.finished:
+if not self.finished:
-			self.finished = 1
+self.finished = 1
-			for question in self.questions:
+for question in self.questions:
-				self.writeQuestion(question)
+self.writeQuestion(question)
-			for answer, time in self.answers:
+for answer, time in self.answers:
-				self.writeRecord(answer, time)
+self.writeRecord(answer, time)
-			for authority in self.authorities:
+for authority in self.authorities:
-				self.writeRecord(authority, 0)
+self.writeRecord(authority, 0)
-			for additional in self.additionals:
+for additional in self.additionals:
-				self.writeRecord(additional, 0)
+self.writeRecord(additional, 0)
-			self.insertShort(0, len(self.additionals))
+self.insertShort(0, len(self.additionals))
-			self.insertShort(0, len(self.authorities))
+self.insertShort(0, len(self.authorities))
-			self.insertShort(0, len(self.answers))
+self.insertShort(0, len(self.answers))
-			self.insertShort(0, len(self.questions))
+self.insertShort(0, len(self.questions))
-			self.insertShort(0, self.flags)
+self.insertShort(0, self.flags)
-			if self.multicast:
+if self.multicast:
-				self.insertShort(0, 0)
+self.insertShort(0, 0)
-			else:
+else:
-				self.insertShort(0, self.id)
+self.insertShort(0, self.id)
-		return ''.join(self.data)
+return ''.join(self.data)
 class DNSCache(object):
-	"""A cache of DNS entries"""
+"""A cache of DNS entries"""
-	def __init__(self):
+def __init__(self):
-		self.cache = {}
+self.cache = {}
-	def add(self, entry):
+def add(self, entry):
-		"""Adds an entry"""
+"""Adds an entry"""
-		try:
+try:
-			list = self.cache[entry.key]
+list = self.cache[entry.key]
-		except:
+except:
-			list = self.cache[entry.key] = []
+list = self.cache[entry.key] = []
-		list.append(entry)
+list.append(entry)
-	def remove(self, entry):
+def remove(self, entry):
-		"""Removes an entry"""
+"""Removes an entry"""
-		try:
+try:
-			list = self.cache[entry.key]
+list = self.cache[entry.key]
-			list.remove(entry)
+list.remove(entry)
-		except:
+except:
-			pass
+pass
-	def get(self, entry):
+def get(self, entry):
-		"""Gets an entry by key.  Will return None if there is no
+"""Gets an entry by key.  Will return None if there is no
-		matching entry."""
+matching entry."""
-		try:
+try:
-			list = self.cache[entry.key]
+list = self.cache[entry.key]
-			return list[list.index(entry)]
+return list[list.index(entry)]
-		except:
+except:
-			return None
+return None
-	def getByDetails(self, name, type, clazz):
+def getByDetails(self, name, type, clazz):
-		"""Gets an entry by details.  Will return None if there is
+"""Gets an entry by details.  Will return None if there is
-		no matching entry."""
+no matching entry."""
-		entry = DNSEntry(name, type, clazz)
+entry = DNSEntry(name, type, clazz)
-		return self.get(entry)
+return self.get(entry)
-	def entriesWithName(self, name):
+def entriesWithName(self, name):
-		"""Returns a list of entries whose key matches the name."""
+"""Returns a list of entries whose key matches the name."""
-		try:
+try:
-			return self.cache[name]
+return self.cache[name]
-		except:
+except:
-			return []
+return []
-	def entries(self):
+def entries(self):
-		"""Returns a list of all entries"""
+"""Returns a list of all entries"""
-		def add(x, y): return x+y
+def add(x, y): return x+y
-		try:
+try:
-			return reduce(add, self.cache.values())
+return reduce(add, self.cache.values())
-		except:
+except:
-			return []
+return []
 class Engine(threading.Thread):
-	"""An engine wraps read access to sockets, allowing objects that
+"""An engine wraps read access to sockets, allowing objects that
-	need to receive data from sockets to be called back when the
+need to receive data from sockets to be called back when the
-	sockets are ready.
+sockets are ready.
-	A reader needs a handle_read() method, which is called when the socket
+A reader needs a handle_read() method, which is called when the socket
-	it is interested in is ready for reading.
+it is interested in is ready for reading.
-	Writers are not implemented here, because we only send short
+Writers are not implemented here, because we only send short
-	packets.
+packets.
-	"""
+"""
-	def __init__(self, zeroconf):
+def __init__(self, zeroconf):
-		threading.Thread.__init__(self)
+threading.Thread.__init__(self)
-		self.zeroconf = zeroconf
+self.zeroconf = zeroconf
-		self.readers = {} # maps socket to reader
+self.readers = {} # maps socket to reader
-		self.timeout = 5
+self.timeout = 5
-		self.condition = threading.Condition()
+self.condition = threading.Condition()
-		self.start()
+self.start()
-	def run(self):
+def run(self):
-		while not globals()['_GLOBAL_DONE']:
+while not globals()['_GLOBAL_DONE']:
-			rs = self.getReaders()
+rs = self.getReaders()
-			if len(rs) == 0:
+if len(rs) == 0:
-				# No sockets to manage, but we wait for the timeout
+# No sockets to manage, but we wait for the timeout
-				# or addition of a socket
+# or addition of a socket
-				#
+#
-				self.condition.acquire()
+self.condition.acquire()
-				self.condition.wait(self.timeout)
+self.condition.wait(self.timeout)
-				self.condition.release()
+self.condition.release()
-			else:
+else:
-				try:
+try:
-					rr, wr, er = select.select(rs, [], [], self.timeout)
+rr, wr, er = select.select(rs, [], [], self.timeout)
-					for socket in rr:
+for socket in rr:
-						try:
+try:
-							self.readers[socket].handle_read()
+self.readers[socket].handle_read()
-						except:
+except:
-							traceback.print_exc()
+traceback.print_exc()
-				except:
+except:
-					pass
+pass
-	def getReaders(self):
+def getReaders(self):
-		result = []
+result = []
-		self.condition.acquire()
+self.condition.acquire()
-		result = self.readers.keys()
+result = self.readers.keys()
-		self.condition.release()
+self.condition.release()
-		return result
+return result
-	def addReader(self, reader, socket):
+def addReader(self, reader, socket):
-		self.condition.acquire()
+self.condition.acquire()
-		self.readers[socket] = reader
+self.readers[socket] = reader
-		self.condition.notify()
+self.condition.notify()
-		self.condition.release()
+self.condition.release()
-	def delReader(self, socket):
+def delReader(self, socket):
-		self.condition.acquire()
+self.condition.acquire()
-		del(self.readers[socket])
+del(self.readers[socket])
-		self.condition.notify()
+self.condition.notify()
-		self.condition.release()
+self.condition.release()
-	def notify(self):
+def notify(self):
-		self.condition.acquire()
+self.condition.acquire()
-		self.condition.notify()
+self.condition.notify()
-		self.condition.release()
+self.condition.release()
 class Listener(object):
-	"""A Listener is used by this module to listen on the multicast
+"""A Listener is used by this module to listen on the multicast
-	group to which DNS messages are sent, allowing the implementation
+group to which DNS messages are sent, allowing the implementation
-	to cache information as it arrives.
+to cache information as it arrives.
-	It requires registration with an Engine object in order to have
+It requires registration with an Engine object in order to have
-	the read() method called when a socket is availble for reading."""
+the read() method called when a socket is availble for reading."""
-	def __init__(self, zeroconf):
+def __init__(self, zeroconf):
-		self.zeroconf = zeroconf
+self.zeroconf = zeroconf
-		self.zeroconf.engine.addReader(self, self.zeroconf.socket)
+self.zeroconf.engine.addReader(self, self.zeroconf.socket)
-	def handle_read(self):
+def handle_read(self):
-		data, (addr, port) = self.zeroconf.socket.recvfrom(_MAX_MSG_ABSOLUTE)
+data, (addr, port) = self.zeroconf.socket.recvfrom(_MAX_MSG_ABSOLUTE)
-		self.data = data
+self.data = data
-		msg = DNSIncoming(data)
+msg = DNSIncoming(data)
-		if msg.isQuery():
+if msg.isQuery():
-			# Always multicast responses
+# Always multicast responses
-			#
+#
-			if port == _MDNS_PORT:
+if port == _MDNS_PORT:
-				self.zeroconf.handleQuery(msg, _MDNS_ADDR, _MDNS_PORT)
+self.zeroconf.handleQuery(msg, _MDNS_ADDR, _MDNS_PORT)
-			# If it's not a multicast query, reply via unicast
+# If it's not a multicast query, reply via unicast
-			# and multicast
+# and multicast
-			#
+#
-			elif port == _DNS_PORT:
+elif port == _DNS_PORT:
-				self.zeroconf.handleQuery(msg, addr, port)
+self.zeroconf.handleQuery(msg, addr, port)
-				self.zeroconf.handleQuery(msg, _MDNS_ADDR, _MDNS_PORT)
+self.zeroconf.handleQuery(msg, _MDNS_ADDR, _MDNS_PORT)
-		else:
+else:
-			self.zeroconf.handleResponse(msg)
+self.zeroconf.handleResponse(msg)
 class Reaper(threading.Thread):
-	"""A Reaper is used by this module to remove cache entries that
+"""A Reaper is used by this module to remove cache entries that
-	have expired."""
+have expired."""
-	def __init__(self, zeroconf):
+def __init__(self, zeroconf):
-		threading.Thread.__init__(self)
+threading.Thread.__init__(self)
-		self.zeroconf = zeroconf
+self.zeroconf = zeroconf
-		self.start()
+self.start()
-	def run(self):
+def run(self):
-		while 1:
+while 1:
-			self.zeroconf.wait(10 * 1000)
+self.zeroconf.wait(10 * 1000)
-			if globals()['_GLOBAL_DONE']:
+if globals()['_GLOBAL_DONE']:
-				return
+return
-			now = currentTimeMillis()
+now = currentTimeMillis()
-			for record in self.zeroconf.cache.entries():
+for record in self.zeroconf.cache.entries():
-				if record.isExpired(now):
+if record.isExpired(now):
-					self.zeroconf.updateRecord(now, record)
+self.zeroconf.updateRecord(now, record)
-					self.zeroconf.cache.remove(record)
+self.zeroconf.cache.remove(record)
 class ServiceBrowser(threading.Thread):
-	"""Used to browse for a service of a specific type.
+"""Used to browse for a service of a specific type.
-	The listener object will have its addService() and
+The listener object will have its addService() and
-	removeService() methods called when this browser
+removeService() methods called when this browser
-	discovers changes in the services availability."""
+discovers changes in the services availability."""
-	def __init__(self, zeroconf, type, listener):
+def __init__(self, zeroconf, type, listener):
-		"""Creates a browser for a specific type"""
+"""Creates a browser for a specific type"""
-		threading.Thread.__init__(self)
+threading.Thread.__init__(self)
-		self.zeroconf = zeroconf
+self.zeroconf = zeroconf
-		self.type = type
+self.type = type
-		self.listener = listener
+self.listener = listener
-		self.services = {}
+self.services = {}
-		self.nextTime = currentTimeMillis()
+self.nextTime = currentTimeMillis()
-		self.delay = _BROWSER_TIME
+self.delay = _BROWSER_TIME
-		self.list = []
+self.list = []
-		self.done = 0
+self.done = 0
-		self.zeroconf.addListener(self, DNSQuestion(self.type, _TYPE_PTR, _CLASS_IN))
+self.zeroconf.addListener(self, DNSQuestion(self.type, _TYPE_PTR, _CLASS_IN))
-		self.start()
+self.start()
-	def updateRecord(self, zeroconf, now, record):
+def updateRecord(self, zeroconf, now, record):
-		"""Callback invoked by Zeroconf when new information arrives.
+"""Callback invoked by Zeroconf when new information arrives.
-		Updates information required by browser in the Zeroconf cache."""
+Updates information required by browser in the Zeroconf cache."""
-		if record.type == _TYPE_PTR and record.name == self.type:
+if record.type == _TYPE_PTR and record.name == self.type:
-			expired = record.isExpired(now)
+expired = record.isExpired(now)
-			try:
+try:
-				oldrecord = self.services[record.alias.lower()]
+oldrecord = self.services[record.alias.lower()]
-				if not expired:
+if not expired:
-					oldrecord.resetTTL(record)
+oldrecord.resetTTL(record)
-				else:
+else:
-					del(self.services[record.alias.lower()])
+del(self.services[record.alias.lower()])
-					callback = lambda x: self.listener.removeService(x, self.type, record.alias)
+callback = lambda x: self.listener.removeService(x, self.type, record.alias)
-					self.list.append(callback)
+self.list.append(callback)
-					return
+return
-			except:
+except:
-				if not expired:
+if not expired:
-					self.services[record.alias.lower()] = record
+self.services[record.alias.lower()] = record
-					callback = lambda x: self.listener.addService(x, self.type, record.alias)
+callback = lambda x: self.listener.addService(x, self.type, record.alias)
-					self.list.append(callback)
+self.list.append(callback)
-			expires = record.getExpirationTime(75)
+expires = record.getExpirationTime(75)
-			if expires < self.nextTime:
+if expires < self.nextTime:
-				self.nextTime = expires
+self.nextTime = expires
-	def cancel(self):
+def cancel(self):
-		self.done = 1
+self.done = 1
-		self.zeroconf.notifyAll()
+self.zeroconf.notifyAll()
-	def run(self):
+def run(self):
-		while 1:
+while 1:
-			event = None
+event = None
-			now = currentTimeMillis()
+now = currentTimeMillis()
-			if len(self.list) == 0 and self.nextTime > now:
+if len(self.list) == 0 and self.nextTime > now:
-				self.zeroconf.wait(self.nextTime - now)
+self.zeroconf.wait(self.nextTime - now)
-			if globals()['_GLOBAL_DONE'] or self.done:
+if globals()['_GLOBAL_DONE'] or self.done:
-				return
+return
-			now = currentTimeMillis()
+now = currentTimeMillis()
-			if self.nextTime <= now:
+if self.nextTime <= now:
-				out = DNSOutgoing(_FLAGS_QR_QUERY)
+out = DNSOutgoing(_FLAGS_QR_QUERY)
-				out.addQuestion(DNSQuestion(self.type, _TYPE_PTR, _CLASS_IN))
+out.addQuestion(DNSQuestion(self.type, _TYPE_PTR, _CLASS_IN))
-				for record in self.services.values():
+for record in self.services.values():
-					if not record.isExpired(now):
+if not record.isExpired(now):
-						out.addAnswerAtTime(record, now)
+out.addAnswerAtTime(record, now)
-				self.zeroconf.send(out)
+self.zeroconf.send(out)
-				self.nextTime = now + self.delay
+self.nextTime = now + self.delay
-				self.delay = min(20 * 1000, self.delay * 2)
+self.delay = min(20 * 1000, self.delay * 2)
-			if len(self.list) > 0:
+if len(self.list) > 0:
-				event = self.list.pop(0)
+event = self.list.pop(0)
-			if event is not None:
+if event is not None:
-				event(self.zeroconf)
+event(self.zeroconf)
 class ServiceInfo(object):
-	"""Service information"""
+"""Service information"""
-	def __init__(self, type, name, address=None, port=None, weight=0, priority=0, properties=None, server=None):
+def __init__(self, type, name, address=None, port=None, weight=0, priority=0, properties=None, server=None):
-		"""Create a service description.
+"""Create a service description.
-		type: fully qualified service type name
+type: fully qualified service type name
-		name: fully qualified service name
+name: fully qualified service name
-		address: IP address as unsigned short, network byte order
+address: IP address as unsigned short, network byte order
-		port: port that the service runs on
+port: port that the service runs on
-		weight: weight of the service
+weight: weight of the service
-		priority: priority of the service
+priority: priority of the service
-		properties: dictionary of properties (or a string holding the bytes for the text field)
+properties: dictionary of properties (or a string holding the bytes for the text field)
-		server: fully qualified name for service host (defaults to name)"""
+server: fully qualified name for service host (defaults to name)"""
-		if not name.endswith(type):
+if not name.endswith(type):
-			raise BadTypeInNameException
+raise BadTypeInNameException
-		self.type = type
+self.type = type
-		self.name = name
+self.name = name
-		self.address = address
+self.address = address
-		self.port = port
+self.port = port
-		self.weight = weight
+self.weight = weight
-		self.priority = priority
+self.priority = priority
-		if server:
+if server:
-			self.server = server
+self.server = server
-		else:
+else:
-			self.server = name
+self.server = name
-		self.setProperties(properties)
+self.setProperties(properties)
-	def setProperties(self, properties):
+def setProperties(self, properties):
-		"""Sets properties and text of this info from a dictionary"""
+"""Sets properties and text of this info from a dictionary"""
-		if isinstance(properties, dict):
+if isinstance(properties, dict):
-			self.properties = properties
+self.properties = properties
-			list = []
+list = []
-			result = ''
+result = ''
-			for key in properties:
+for key in properties:
-				value = properties[key]
+value = properties[key]
-				if value is None:
+if value is None:
-					suffix = ''.encode('utf-8')
+suffix = ''.encode('utf-8')
-				elif isinstance(value, str):
+elif isinstance(value, str):
-					suffix = value.encode('utf-8')
+suffix = value.encode('utf-8')
-				elif isinstance(value, int):
+elif isinstance(value, int):
-					if value:
+if value:
-						suffix = 'true'
+suffix = 'true'
-					else:
+else:
-						suffix = 'false'
+suffix = 'false'
-				else:
+else:
-					suffix = ''.encode('utf-8')
+suffix = ''.encode('utf-8')
-				list.append('='.join((key, suffix)))
+list.append('='.join((key, suffix)))
-			for item in list:
+for item in list:
-				result = ''.join((result, struct.pack('!c', chr(len(item))), item))
+result = ''.join((result, struct.pack('!c', chr(len(item))), item))
-			self.text = result
+self.text = result
-		else:
+else:
-			self.text = properties
+self.text = properties
-	def setText(self, text):
+def setText(self, text):
-		"""Sets properties and text given a text field"""
+"""Sets properties and text given a text field"""
-		self.text = text
+self.text = text
-		try:
+try:
-			result = {}
+result = {}
-			end = len(text)
+end = len(text)
-			index = 0
+index = 0
-			strs = []
+strs = []
-			while index < end:
+while index < end:
-				length = ord(text[index])
+length = ord(text[index])
-				index += 1
+index += 1
-				strs.append(text[index:index+length])
+strs.append(text[index:index+length])
-				index += length
+index += length
-			for s in strs:
+for s in strs:
-				eindex = s.find('=')
+eindex = s.find('=')
-				if eindex == -1:
+if eindex == -1:
-					# No equals sign at all
+# No equals sign at all
-					key = s
+key = s
-					value = 0
+value = 0
-				else:
+else:
-					key = s[:eindex]
+key = s[:eindex]
-					value = s[eindex+1:]
+value = s[eindex+1:]
-					if value == 'true':
+if value == 'true':
-						value = 1
+value = 1
-					elif value == 'false' or not value:
+elif value == 'false' or not value:
-						value = 0
+value = 0
-				# Only update non-existent properties
+# Only update non-existent properties
-				if key and result.get(key) == None:
+if key and result.get(key) == None:
-					result[key] = value
+result[key] = value
-			self.properties = result
+self.properties = result
-		except:
+except:
-			traceback.print_exc()
+traceback.print_exc()
-			self.properties = None
+self.properties = None
-	def getType(self):
+def getType(self):
-		"""Type accessor"""
+"""Type accessor"""
-		return self.type
+return self.type
-	def getName(self):
+def getName(self):
-		"""Name accessor"""
+"""Name accessor"""
-		if self.type is not None and self.name.endswith("." + self.type):
+if self.type is not None and self.name.endswith("." + self.type):
-			return self.name[:len(self.name) - len(self.type) - 1]
+return self.name[:len(self.name) - len(self.type) - 1]
-		return self.name
+return self.name
-	def getAddress(self):
+def getAddress(self):
-		"""Address accessor"""
+"""Address accessor"""
-		return self.address
+return self.address
-	def getPort(self):
+def getPort(self):
-		"""Port accessor"""
+"""Port accessor"""
-		return self.port
+return self.port
-	def getPriority(self):
+def getPriority(self):
-		"""Pirority accessor"""
+"""Pirority accessor"""
-		return self.priority
+return self.priority
-	def getWeight(self):
+def getWeight(self):
-		"""Weight accessor"""
+"""Weight accessor"""
-		return self.weight
+return self.weight
-	def getProperties(self):
+def getProperties(self):
-		"""Properties accessor"""
+"""Properties accessor"""
-		return self.properties
+return self.properties
-	def getText(self):
+def getText(self):
-		"""Text accessor"""
+"""Text accessor"""
-		return self.text
+return self.text
-	def getServer(self):
+def getServer(self):
-		"""Server accessor"""
+"""Server accessor"""
-		return self.server
+return self.server
-	def updateRecord(self, zeroconf, now, record):
+def updateRecord(self, zeroconf, now, record):
-		"""Updates service information from a DNS record"""
+"""Updates service information from a DNS record"""
-		if record is not None and not record.isExpired(now):
+if record is not None and not record.isExpired(now):
-			if record.type == _TYPE_A:
+if record.type == _TYPE_A:
-				if record.name == self.name:
+if record.name == self.name:
-					self.address = record.address
+self.address = record.address
-			elif record.type == _TYPE_SRV:
+elif record.type == _TYPE_SRV:
-				if record.name == self.name:
+if record.name == self.name:
-					self.server = record.server
+self.server = record.server
-					self.port = record.port
+self.port = record.port
-					self.weight = record.weight
+self.weight = record.weight
-					self.priority = record.priority
+self.priority = record.priority
-					self.address = None
+self.address = None
-					self.updateRecord(zeroconf, now, zeroconf.cache.getByDetails(self.server, _TYPE_A, _CLASS_IN))
+self.updateRecord(zeroconf, now, zeroconf.cache.getByDetails(self.server, _TYPE_A, _CLASS_IN))
-			elif record.type == _TYPE_TXT:
+elif record.type == _TYPE_TXT:
-				if record.name == self.name:
+if record.name == self.name:
-					self.setText(record.text)
+self.setText(record.text)
-	def request(self, zeroconf, timeout):
+def request(self, zeroconf, timeout):
-		"""Returns true if the service could be discovered on the
+"""Returns true if the service could be discovered on the
-		network, and updates this object with details discovered.
+network, and updates this object with details discovered.
-		"""
+"""
-		now = currentTimeMillis()
+now = currentTimeMillis()
-		delay = _LISTENER_TIME
+delay = _LISTENER_TIME
-		next = now + delay
+next = now + delay
-		last = now + timeout
+last = now + timeout
-		result = 0
+result = 0
-		try:
+try:
-			zeroconf.addListener(self, DNSQuestion(self.name, _TYPE_ANY, _CLASS_IN))
+zeroconf.addListener(self, DNSQuestion(self.name, _TYPE_ANY, _CLASS_IN))
-			while self.server is None or self.address is None or self.text is None:
+while self.server is None or self.address is None or self.text is None:
-				if last <= now:
+if last <= now:
-					return 0
+return 0
-				if next <= now:
+if next <= now:
-					out = DNSOutgoing(_FLAGS_QR_QUERY)
+out = DNSOutgoing(_FLAGS_QR_QUERY)
-					out.addQuestion(DNSQuestion(self.name, _TYPE_SRV, _CLASS_IN))
+out.addQuestion(DNSQuestion(self.name, _TYPE_SRV, _CLASS_IN))
-					out.addAnswerAtTime(zeroconf.cache.getByDetails(self.name, _TYPE_SRV, _CLASS_IN), now)
+out.addAnswerAtTime(zeroconf.cache.getByDetails(self.name, _TYPE_SRV, _CLASS_IN), now)
-					out.addQuestion(DNSQuestion(self.name, _TYPE_TXT, _CLASS_IN))
+out.addQuestion(DNSQuestion(self.name, _TYPE_TXT, _CLASS_IN))
-					out.addAnswerAtTime(zeroconf.cache.getByDetails(self.name, _TYPE_TXT, _CLASS_IN), now)
+out.addAnswerAtTime(zeroconf.cache.getByDetails(self.name, _TYPE_TXT, _CLASS_IN), now)
-					if self.server is not None:
+if self.server is not None:
-						out.addQuestion(DNSQuestion(self.server, _TYPE_A, _CLASS_IN))
+out.addQuestion(DNSQuestion(self.server, _TYPE_A, _CLASS_IN))
-						out.addAnswerAtTime(zeroconf.cache.getByDetails(self.server, _TYPE_A, _CLASS_IN), now)
+out.addAnswerAtTime(zeroconf.cache.getByDetails(self.server, _TYPE_A, _CLASS_IN), now)
-					zeroconf.send(out)
+zeroconf.send(out)
-					next = now + delay
+next = now + delay
-					delay = delay * 2
+delay = delay * 2
-				zeroconf.wait(min(next, last) - now)
+zeroconf.wait(min(next, last) - now)
-				now = currentTimeMillis()
+now = currentTimeMillis()
-			result = 1
+result = 1
-		finally:
+finally:
-			zeroconf.removeListener(self)
+zeroconf.removeListener(self)
-		return result
+return result
-	def __eq__(self, other):
+def __eq__(self, other):
-		"""Tests equality of service name"""
+"""Tests equality of service name"""
-		if isinstance(other, ServiceInfo):
+if isinstance(other, ServiceInfo):
-			return other.name == self.name
+return other.name == self.name
-		return 0
+return 0
-	def __ne__(self, other):
+def __ne__(self, other):
-		"""Non-equality test"""
+"""Non-equality test"""
-		return not self.__eq__(other)
+return not self.__eq__(other)
-	def __repr__(self):
+def __repr__(self):
-		"""String representation"""
+"""String representation"""
-		result = "service[%s,%s:%s," % (self.name, socket.inet_ntoa(self.getAddress()), self.port)
+result = "service[%s,%s:%s," % (self.name, socket.inet_ntoa(self.getAddress()), self.port)
-		if self.text is None:
+if self.text is None:
-			result += "None"
+result += "None"
-		else:
+else:
-			if len(self.text) < 20:
+if len(self.text) < 20:
-				result += self.text
+result += self.text
-			else:
+else:
-				result += self.text[:17] + "..."
+result += self.text[:17] + "..."
-		result += "]"
+result += "]"
-		return result
+return result
 class Zeroconf(object):
-	"""Implementation of Zeroconf Multicast DNS Service Discovery
+"""Implementation of Zeroconf Multicast DNS Service Discovery
-	Supports registration, unregistration, queries and browsing.
+Supports registration, unregistration, queries and browsing.
-	"""
+"""
-	def __init__(self, bindaddress=None):
+def __init__(self, bindaddress=None):
-		"""Creates an instance of the Zeroconf class, establishing
+"""Creates an instance of the Zeroconf class, establishing
-		multicast communications, listening and reaping threads."""
+multicast communications, listening and reaping threads."""
-		globals()['_GLOBAL_DONE'] = 0
+globals()['_GLOBAL_DONE'] = 0
-		if bindaddress is None:
+self.intf = bindaddress
-			self.intf = socket.gethostbyname(socket.gethostname())
+self.group = ('', _MDNS_PORT)
-		else:
+self.socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
-			self.intf = bindaddress
+try:
-		self.group = ('', _MDNS_PORT)
+self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
-		self.socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEPORT, 1)
-		try:
+except:
-			self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+# SO_REUSEADDR should be equivalent to SO_REUSEPORT for
-			self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEPORT, 1)
+# multicast UDP sockets (p 731, "TCP/IP Illustrated,
-		except:
+# Volume 2"), but some BSD-derived systems require
-			# SO_REUSEADDR should be equivalent to SO_REUSEPORT for
+# SO_REUSEPORT to be specified explicity.  Also, not all
-			# multicast UDP sockets (p 731, "TCP/IP Illustrated,
+# versions of Python have SO_REUSEPORT available.  So
-			# Volume 2"), but some BSD-derived systems require
+# if you're on a BSD-based system, and haven't upgraded
-			# SO_REUSEPORT to be specified explicity.  Also, not all
+# to Python 2.3 yet, you may find this library doesn't
-			# versions of Python have SO_REUSEPORT available.  So
+# work as expected.
-			# if you're on a BSD-based system, and haven't upgraded
+#
-			# to Python 2.3 yet, you may find this library doesn't
+pass
-			# work as expected.
+self.socket.setsockopt(socket.SOL_IP, socket.IP_MULTICAST_TTL, 255)
-			#
+self.socket.setsockopt(socket.SOL_IP, socket.IP_MULTICAST_LOOP, 1)
-			pass
+try:
-		self.socket.setsockopt(socket.SOL_IP, socket.IP_MULTICAST_TTL, 255)
+self.socket.bind(self.group)
-		self.socket.setsockopt(socket.SOL_IP, socket.IP_MULTICAST_LOOP, 1)
+except:
-		try:
+# Some versions of linux raise an exception even though
-			self.socket.bind(self.group)
+# the SO_REUSE* options have been set, so ignore it
-		except:
+#
-			# Some versions of linux raise an exception even though
+pass
-			# the SO_REUSE* options have been set, so ignore it
-			#
+if self.intf is not None:
-			pass
+self.socket.setsockopt(socket.SOL_IP, socket.IP_MULTICAST_IF, socket.inet_aton(self.intf) + socket.inet_aton('0.0.0.0'))
-		self.socket.setsockopt(socket.SOL_IP, socket.IP_MULTICAST_IF, socket.inet_aton(self.intf) + socket.inet_aton('0.0.0.0'))
+self.socket.setsockopt(socket.SOL_IP, socket.IP_ADD_MEMBERSHIP, socket.inet_aton(_MDNS_ADDR) + socket.inet_aton('0.0.0.0'))
-		self.socket.setsockopt(socket.SOL_IP, socket.IP_ADD_MEMBERSHIP, socket.inet_aton(_MDNS_ADDR) + socket.inet_aton('0.0.0.0'))
+self.listeners = []
-		self.listeners = []
+self.browsers = []
-		self.browsers = []
+self.services = {}
-		self.services = {}
+self.cache = DNSCache()
-		self.cache = DNSCache()
+self.condition = threading.Condition()
-		self.condition = threading.Condition()
+self.engine = Engine(self)
-		self.engine = Engine(self)
+self.listener = Listener(self)
-		self.listener = Listener(self)
+self.reaper = Reaper(self)
-		self.reaper = Reaper(self)
+def isLoopback(self):
-	def isLoopback(self):
+if self.intf is not None:
-		return self.intf.startswith("127.0.0.1")
+return self.intf.startswith("127.0.0.1")
+return False
-	def isLinklocal(self):
-		return self.intf.startswith("169.254.")
+def isLinklocal(self):
+if self.intf is not None:
-	def wait(self, timeout):
+return self.intf.startswith("169.254.")
-		"""Calling thread waits for a given number of milliseconds or
+return False
-		until notified."""
-		self.condition.acquire()
+def wait(self, timeout):
-		self.condition.wait(timeout/1000)
+"""Calling thread waits for a given number of milliseconds or
-		self.condition.release()
+until notified."""
+self.condition.acquire()
-	def notifyAll(self):
+self.condition.wait(timeout/1000)
-		"""Notifies all waiting threads"""
+self.condition.release()
-		self.condition.acquire()
-		self.condition.notifyAll()
+def notifyAll(self):
-		self.condition.release()
+"""Notifies all waiting threads"""
+self.condition.acquire()
-	def getServiceInfo(self, type, name, timeout=3000):
+self.condition.notifyAll()
-		"""Returns network's service information for a particular
+self.condition.release()
-		name and type, or None if no service matches by the timeout,
-		which defaults to 3 seconds."""
+def getServiceInfo(self, type, name, timeout=3000):
-		info = ServiceInfo(type, name)
+"""Returns network's service information for a particular
-		if info.request(self, timeout):
+name and type, or None if no service matches by the timeout,
-			return info
+which defaults to 3 seconds."""
-		return None
+info = ServiceInfo(type, name)
+if info.request(self, timeout):
-	def addServiceListener(self, type, listener):
+return info
-		"""Adds a listener for a particular service type.  This object
+return None
-		will then have its updateRecord method called when information
-		arrives for that type."""
+def addServiceListener(self, type, listener):
-		self.removeServiceListener(listener)
+"""Adds a listener for a particular service type.  This object
-		self.browsers.append(ServiceBrowser(self, type, listener))
+will then have its updateRecord method called when information
+arrives for that type."""
-	def removeServiceListener(self, listener):
+self.removeServiceListener(listener)
-		"""Removes a listener from the set that is currently listening."""
+self.browsers.append(ServiceBrowser(self, type, listener))
-		for browser in self.browsers:
-			if browser.listener == listener:
+def removeServiceListener(self, listener):
-				browser.cancel()
+"""Removes a listener from the set that is currently listening."""
-				del(browser)
+for browser in self.browsers:
+if browser.listener == listener:
-	def registerService(self, info, ttl=_DNS_TTL):
+browser.cancel()
-		"""Registers service information to the network with a default TTL
+del(browser)
-		of 60 seconds.  Zeroconf will then respond to requests for
-		information for that service.  The name of the service may be
+def registerService(self, info, ttl=_DNS_TTL):
-		changed if needed to make it unique on the network."""
+"""Registers service information to the network with a default TTL
-		self.checkService(info)
+of 60 seconds.  Zeroconf will then respond to requests for
-		self.services[info.name.lower()] = info
+information for that service.  The name of the service may be
-		now = currentTimeMillis()
+changed if needed to make it unique on the network."""
-		nextTime = now
+self.checkService(info)
-		i = 0
+self.services[info.name.lower()] = info
-		while i < 3:
+now = currentTimeMillis()
-			if now < nextTime:
+nextTime = now
-				self.wait(nextTime - now)
+i = 0
-				now = currentTimeMillis()
+while i < 3:
-				continue
+if now < nextTime:
-			out = DNSOutgoing(_FLAGS_QR_RESPONSE | _FLAGS_AA)
+self.wait(nextTime - now)
-			out.addAnswerAtTime(DNSPointer(info.type, _TYPE_PTR, _CLASS_IN, ttl, info.name), 0)
+now = currentTimeMillis()
-			out.addAnswerAtTime(DNSService(info.name, _TYPE_SRV, _CLASS_IN, ttl, info.priority, info.weight, info.port, info.server), 0)
+continue
-			out.addAnswerAtTime(DNSText(info.name, _TYPE_TXT, _CLASS_IN, ttl, info.text), 0)
+out = DNSOutgoing(_FLAGS_QR_RESPONSE | _FLAGS_AA)
-			if info.address:
+out.addAnswerAtTime(DNSPointer(info.type, _TYPE_PTR, _CLASS_IN, ttl, info.name), 0)
-				out.addAnswerAtTime(DNSAddress(info.server, _TYPE_A, _CLASS_IN, ttl, info.address), 0)
+out.addAnswerAtTime(DNSService(info.name, _TYPE_SRV, _CLASS_IN, ttl, info.priority, info.weight, info.port, info.server), 0)
-			self.send(out)
+out.addAnswerAtTime(DNSText(info.name, _TYPE_TXT, _CLASS_IN, ttl, info.text), 0)
-			i += 1
+if info.address:
-			nextTime += _REGISTER_TIME
+out.addAnswerAtTime(DNSAddress(info.server, _TYPE_A, _CLASS_IN, ttl, info.address), 0)
+self.send(out)
-	def unregisterService(self, info):
+i += 1
-		"""Unregister a service."""
+nextTime += _REGISTER_TIME
-		try:
-			del(self.services[info.name.lower()])
+def unregisterService(self, info):
-		except:
+"""Unregister a service."""
-			pass
+try:
-		now = currentTimeMillis()
+del(self.services[info.name.lower()])
-		nextTime = now
+except:
-		i = 0
+pass
-		while i < 3:
+now = currentTimeMillis()
-			if now < nextTime:
+nextTime = now
-				self.wait(nextTime - now)
+i = 0
-				now = currentTimeMillis()
+while i < 3:
-				continue
+if now < nextTime:
-			out = DNSOutgoing(_FLAGS_QR_RESPONSE | _FLAGS_AA)
+self.wait(nextTime - now)
-			out.addAnswerAtTime(DNSPointer(info.type, _TYPE_PTR, _CLASS_IN, 0, info.name), 0)
+now = currentTimeMillis()
-			out.addAnswerAtTime(DNSService(info.name, _TYPE_SRV, _CLASS_IN, 0, info.priority, info.weight, info.port, info.name), 0)
+continue
-			out.addAnswerAtTime(DNSText(info.name, _TYPE_TXT, _CLASS_IN, 0, info.text), 0)
+out = DNSOutgoing(_FLAGS_QR_RESPONSE | _FLAGS_AA)
-			if info.address:
+out.addAnswerAtTime(DNSPointer(info.type, _TYPE_PTR, _CLASS_IN, 0, info.name), 0)
-				out.addAnswerAtTime(DNSAddress(info.server, _TYPE_A, _CLASS_IN, 0, info.address), 0)
+out.addAnswerAtTime(DNSService(info.name, _TYPE_SRV, _CLASS_IN, 0, info.priority, info.weight, info.port, info.name), 0)
-			self.send(out)
+out.addAnswerAtTime(DNSText(info.name, _TYPE_TXT, _CLASS_IN, 0, info.text), 0)
-			i += 1
+if info.address:
-			nextTime += _UNREGISTER_TIME
+out.addAnswerAtTime(DNSAddress(info.server, _TYPE_A, _CLASS_IN, 0, info.address), 0)
+self.send(out)
-	def unregisterAllServices(self):
+i += 1
-		"""Unregister all registered services."""
+nextTime += _UNREGISTER_TIME
-		if len(self.services) > 0:
-			now = currentTimeMillis()
+def unregisterAllServices(self):
-			nextTime = now
+"""Unregister all registered services."""
-			i = 0
+if len(self.services) > 0:
-			while i < 3:
+now = currentTimeMillis()
-				if now < nextTime:
+nextTime = now
-					self.wait(nextTime - now)
+i = 0
-					now = currentTimeMillis()
+while i < 3:
-					continue
+if now < nextTime:
-				out = DNSOutgoing(_FLAGS_QR_RESPONSE | _FLAGS_AA)
+self.wait(nextTime - now)
-				for info in self.services.values():
+now = currentTimeMillis()
-					out.addAnswerAtTime(DNSPointer(info.type, _TYPE_PTR, _CLASS_IN, 0, info.name), 0)
+continue
-					out.addAnswerAtTime(DNSService(info.name, _TYPE_SRV, _CLASS_IN, 0, info.priority, info.weight, info.port, info.server), 0)
+out = DNSOutgoing(_FLAGS_QR_RESPONSE | _FLAGS_AA)
-					out.addAnswerAtTime(DNSText(info.name, _TYPE_TXT, _CLASS_IN, 0, info.text), 0)
+for info in self.services.values():
-					if info.address:
+out.addAnswerAtTime(DNSPointer(info.type, _TYPE_PTR, _CLASS_IN, 0, info.name), 0)
-						out.addAnswerAtTime(DNSAddress(info.server, _TYPE_A, _CLASS_IN, 0, info.address), 0)
+out.addAnswerAtTime(DNSService(info.name, _TYPE_SRV, _CLASS_IN, 0, info.priority, info.weight, info.port, info.server), 0)
-				self.send(out)
+out.addAnswerAtTime(DNSText(info.name, _TYPE_TXT, _CLASS_IN, 0, info.text), 0)
-				i += 1
+if info.address:
-				nextTime += _UNREGISTER_TIME
+out.addAnswerAtTime(DNSAddress(info.server, _TYPE_A, _CLASS_IN, 0, info.address), 0)
+self.send(out)
-	def checkService(self, info):
+i += 1
-		"""Checks the network for a unique service name, modifying the
+nextTime += _UNREGISTER_TIME
-		ServiceInfo passed in if it is not unique."""
-		now = currentTimeMillis()
+def checkService(self, info):
-		nextTime = now
+"""Checks the network for a unique service name, modifying the
-		i = 0
+ServiceInfo passed in if it is not unique."""
-		while i < 3:
+now = currentTimeMillis()
-			for record in self.cache.entriesWithName(info.type):
+nextTime = now
-				if record.type == _TYPE_PTR and not record.isExpired(now) and record.alias == info.name:
+i = 0
-					if (info.name.find('.') < 0):
+while i < 3:
-						info.name = info.name + ".[" + info.address + ":" + info.port + "]." + info.type
+for record in self.cache.entriesWithName(info.type):
-						self.checkService(info)
+if record.type == _TYPE_PTR and not record.isExpired(now) and record.alias == info.name:
-						return
+if (info.name.find('.') < 0):
-					raise NonUniqueNameException
+info.name = info.name + ".[" + info.address + ":" + info.port + "]." + info.type
-			if now < nextTime:
+self.checkService(info)
-				self.wait(nextTime - now)
+return
-				now = currentTimeMillis()
+raise NonUniqueNameException
-				continue
+if now < nextTime:
-			out = DNSOutgoing(_FLAGS_QR_QUERY | _FLAGS_AA)
+self.wait(nextTime - now)
-			self.debug = out
+now = currentTimeMillis()
-			out.addQuestion(DNSQuestion(info.type, _TYPE_PTR, _CLASS_IN))
+continue
-			out.addAuthorativeAnswer(DNSPointer(info.type, _TYPE_PTR, _CLASS_IN, _DNS_TTL, info.name))
+out = DNSOutgoing(_FLAGS_QR_QUERY | _FLAGS_AA)
-			self.send(out)
+self.debug = out
-			i += 1
+out.addQuestion(DNSQuestion(info.type, _TYPE_PTR, _CLASS_IN))
-			nextTime += _CHECK_TIME
+out.addAuthorativeAnswer(DNSPointer(info.type, _TYPE_PTR, _CLASS_IN, _DNS_TTL, info.name))
+self.send(out)
-	def addListener(self, listener, question):
+i += 1
-		"""Adds a listener for a given question.  The listener will have
+nextTime += _CHECK_TIME
-		its updateRecord method called when information is available to
-		answer the question."""
+def addListener(self, listener, question):
-		now = currentTimeMillis()
+"""Adds a listener for a given question.  The listener will have
-		self.listeners.append(listener)
+its updateRecord method called when information is available to
-		if question is not None:
+answer the question."""
-			for record in self.cache.entriesWithName(question.name):
+now = currentTimeMillis()
-				if question.answeredBy(record) and not record.isExpired(now):
+self.listeners.append(listener)
-					listener.updateRecord(self, now, record)
+if question is not None:
-		self.notifyAll()
+for record in self.cache.entriesWithName(question.name):
+if question.answeredBy(record) and not record.isExpired(now):
-	def removeListener(self, listener):
+listener.updateRecord(self, now, record)
-		"""Removes a listener."""
+self.notifyAll()
-		try:
-			self.listeners.remove(listener)
+def removeListener(self, listener):
-			self.notifyAll()
+"""Removes a listener."""
-		except:
+try:
-			pass
+self.listeners.remove(listener)
+self.notifyAll()
-	def updateRecord(self, now, rec):
+except:
-		"""Used to notify listeners of new information that has updated
+pass
-		a record."""
-		for listener in self.listeners:
+def updateRecord(self, now, rec):
-			listener.updateRecord(self, now, rec)
+"""Used to notify listeners of new information that has updated
-		self.notifyAll()
+a record."""
+for listener in self.listeners:
-	def handleResponse(self, msg):
+listener.updateRecord(self, now, rec)
-		"""Deal with incoming response packets.  All answers
+self.notifyAll()
-		are held in the cache, and listeners are notified."""
-		now = currentTimeMillis()
+def handleResponse(self, msg):
-		for record in msg.answers:
+"""Deal with incoming response packets.  All answers
-			expired = record.isExpired(now)
+are held in the cache, and listeners are notified."""
-			if record in self.cache.entries():
+now = currentTimeMillis()
-				if expired:
+for record in msg.answers:
-					self.cache.remove(record)
+expired = record.isExpired(now)
-				else:
+if record in self.cache.entries():
-					entry = self.cache.get(record)
+if expired:
-					if entry is not None:
+self.cache.remove(record)
-						entry.resetTTL(record)
+else:
-						record = entry
+entry = self.cache.get(record)
-			else:
+if entry is not None:
-				self.cache.add(record)
+entry.resetTTL(record)
+record = entry
-			self.updateRecord(now, record)
+else:
+self.cache.add(record)
-	def handleQuery(self, msg, addr, port):
-		"""Deal with incoming query packets.  Provides a response if
+self.updateRecord(now, record)
-		possible."""
-		out = None
+def handleQuery(self, msg, addr, port):
+"""Deal with incoming query packets.  Provides a response if
-		# Support unicast client responses
+possible."""
-		#
+out = None
-		if port != _MDNS_PORT:
-			out = DNSOutgoing(_FLAGS_QR_RESPONSE | _FLAGS_AA, 0)
+# Support unicast client responses
-			for question in msg.questions:
+#
-				out.addQuestion(question)
+if port != _MDNS_PORT:
+out = DNSOutgoing(_FLAGS_QR_RESPONSE | _FLAGS_AA, 0)
-		for question in msg.questions:
+for question in msg.questions:
-			if question.type == _TYPE_PTR:
+out.addQuestion(question)
-				for service in self.services.values():
-					if question.name == service.type:
+for question in msg.questions:
-						if out is None:
+if question.type == _TYPE_PTR:
-							out = DNSOutgoing(_FLAGS_QR_RESPONSE | _FLAGS_AA)
+for service in self.services.values():
-						out.addAnswer(msg, DNSPointer(service.type, _TYPE_PTR, _CLASS_IN, _DNS_TTL, service.name))
+if question.name == service.type:
-			else:
+if out is None:
-				try:
+out = DNSOutgoing(_FLAGS_QR_RESPONSE | _FLAGS_AA)
-					if out is None:
+out.addAnswer(msg, DNSPointer(service.type, _TYPE_PTR, _CLASS_IN, _DNS_TTL, service.name))
-						out = DNSOutgoing(_FLAGS_QR_RESPONSE | _FLAGS_AA)
+else:
+try:
-					# Answer A record queries for any service addresses we know
+if out is None:
-					if question.type == _TYPE_A or question.type == _TYPE_ANY:
+out = DNSOutgoing(_FLAGS_QR_RESPONSE | _FLAGS_AA)
-						for service in self.services.values():
-							if service.server == question.name.lower():
+# Answer A record queries for any service addresses we know
-								out.addAnswer(msg, DNSAddress(question.name, _TYPE_A, _CLASS_IN | _CLASS_UNIQUE, _DNS_TTL, service.address))
+if question.type == _TYPE_A or question.type == _TYPE_ANY:
+for service in self.services.values():
-					service = self.services.get(question.name.lower(), None)
+if service.server == question.name.lower():
-					if not service: continue
+out.addAnswer(msg, DNSAddress(question.name, _TYPE_A, _CLASS_IN | _CLASS_UNIQUE, _DNS_TTL, service.address))
-					if question.type == _TYPE_SRV or question.type == _TYPE_ANY:
+service = self.services.get(question.name.lower(), None)
-						out.addAnswer(msg, DNSService(question.name, _TYPE_SRV, _CLASS_IN | _CLASS_UNIQUE, _DNS_TTL, service.priority, service.weight, service.port, service.server))
+if not service: continue
-					if question.type == _TYPE_TXT or question.type == _TYPE_ANY:
-						out.addAnswer(msg, DNSText(question.name, _TYPE_TXT, _CLASS_IN | _CLASS_UNIQUE, _DNS_TTL, service.text))
+if question.type == _TYPE_SRV or question.type == _TYPE_ANY:
-					if question.type == _TYPE_SRV:
+out.addAnswer(msg, DNSService(question.name, _TYPE_SRV, _CLASS_IN | _CLASS_UNIQUE, _DNS_TTL, service.priority, service.weight, service.port, service.server))
-						out.addAdditionalAnswer(DNSAddress(service.server, _TYPE_A, _CLASS_IN | _CLASS_UNIQUE, _DNS_TTL, service.address))
+if question.type == _TYPE_TXT or question.type == _TYPE_ANY:
-				except:
+out.addAnswer(msg, DNSText(question.name, _TYPE_TXT, _CLASS_IN | _CLASS_UNIQUE, _DNS_TTL, service.text))
-					traceback.print_exc()
+if question.type == _TYPE_SRV:
+out.addAdditionalAnswer(DNSAddress(service.server, _TYPE_A, _CLASS_IN | _CLASS_UNIQUE, _DNS_TTL, service.address))
-		if out is not None and out.answers:
+except:
-			out.id = msg.id
+traceback.print_exc()
-			self.send(out, addr, port)
+if out is not None and out.answers:
-	def send(self, out, addr = _MDNS_ADDR, port = _MDNS_PORT):
+out.id = msg.id
-		"""Sends an outgoing packet."""
+self.send(out, addr, port)
-		# This is a quick test to see if we can parse the packets we generate
-		#temp = DNSIncoming(out.packet())
+def send(self, out, addr = _MDNS_ADDR, port = _MDNS_PORT):
-		try:
+"""Sends an outgoing packet."""
-			bytes_sent = self.socket.sendto(out.packet(), 0, (addr, port))
+# This is a quick test to see if we can parse the packets we generate
-		except:
+#temp = DNSIncoming(out.packet())
-			# Ignore this, it may be a temporary loss of network connection
+try:
-			pass
+bytes_sent = self.socket.sendto(out.packet(), 0, (addr, port))
+except:
-	def close(self):
+# Ignore this, it may be a temporary loss of network connection
-		"""Ends the background threads, and prevent this instance from
+pass
-		servicing further queries."""
-		if globals()['_GLOBAL_DONE'] == 0:
+def close(self):
-			globals()['_GLOBAL_DONE'] = 1
+"""Ends the background threads, and prevent this instance from
-			self.notifyAll()
+servicing further queries."""
-			self.engine.notify()
+if globals()['_GLOBAL_DONE'] == 0:
-			self.unregisterAllServices()
+globals()['_GLOBAL_DONE'] = 1
-			self.socket.setsockopt(socket.SOL_IP, socket.IP_DROP_MEMBERSHIP, socket.inet_aton(_MDNS_ADDR) + socket.inet_aton('0.0.0.0'))
+self.notifyAll()
-			self.socket.close()
+self.engine.notify()
+self.unregisterAllServices()
+self.socket.setsockopt(socket.SOL_IP, socket.IP_DROP_MEMBERSHIP, socket.inet_aton(_MDNS_ADDR) + socket.inet_aton('0.0.0.0'))
+self.socket.close()
 # Test a few module features, including service registration, service
 # query (for Zoe), and service unregistration.
 if __name__ == '__main__':
-	print "Multicast DNS Service Discovery for Python, version", __version__
+print "Multicast DNS Service Discovery for Python, version", __version__
-	r = Zeroconf()
+r = Zeroconf()
-	print "1. Testing registration of a service..."
+print "1. Testing registration of a service..."
-	desc = {'version':'0.10','a':'test value', 'b':'another value'}
+desc = {'version':'0.10','a':'test value', 'b':'another value'}
-	info = ServiceInfo("_http._tcp.local.", "My Service Name._http._tcp.local.", socket.inet_aton("127.0.0.1"), 1234, 0, 0, desc)
+info = ServiceInfo("_http._tcp.local.", "My Service Name._http._tcp.local.", socket.inet_aton("127.0.0.1"), 1234, 0, 0, desc)
-	print "   Registering service..."
+print "   Registering service..."
-	r.registerService(info)
+r.registerService(info)
-	print "   Registration done."
+print "   Registration done."
-	print "2. Testing query of service information..."
+print "2. Testing query of service information..."
-	print "   Getting ZOE service:", str(r.getServiceInfo("_http._tcp.local.", "ZOE._http._tcp.local."))
+print "   Getting ZOE service:", str(r.getServiceInfo("_http._tcp.local.", "ZOE._http._tcp.local."))
-	print "   Query done."
+print "   Query done."
-	print "3. Testing query of own service..."
+print "3. Testing query of own service..."
-	print "   Getting self:", str(r.getServiceInfo("_http._tcp.local.", "My Service Name._http._tcp.local."))
+print "   Getting self:", str(r.getServiceInfo("_http._tcp.local.", "My Service Name._http._tcp.local."))
-	print "   Query done."
+print "   Query done."
-	print "4. Testing unregister of service information..."
+print "4. Testing unregister of service information..."
-	r.unregisterService(info)
+r.unregisterService(info)
-	print "   Unregister done."
+print "   Unregister done."
-	r.close()
+r.close()

changeset 223	1c0d3aaacf3d
parent 203	cb9901076a21
child 361	331d698e1118
child 373	a7f26d9f214f