beremiz: comparison util/Zeroconf.py

equal deleted inserted replaced

-:d51af006fa6b
+:64d8f52bc8c8
 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
 removed all use of word 'Rendezvous' - this is an API change"""
 _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
 # implementation classes
 class DNSEntry(object):
 """A DNS entry"""
 def __init__(self, name, type, clazz):
 self.key = string.lower(name)
 self.name = name
 self.type = type
 self.clazz = clazz & _CLASS_MASK
 result += "]"
 return result
 class DNSQuestion(DNSEntry):
 """A DNS question entry"""
 def __init__(self, name, type, clazz):
 if not name.endswith(".local."):
 raise NonLocalNameException
 DNSEntry.__init__(self, name, type, clazz)
 return DNSEntry.toString(self, "question", None)
 class DNSRecord(DNSEntry):
 """A DNS record - like a DNS entry, but has a TTL"""
 def __init__(self, name, type, clazz, ttl):
 DNSEntry.__init__(self, name, type, clazz)
 self.ttl = ttl
 self.created = currentTimeMillis()
 arg = "%s/%s,%s" % (self.ttl, self.getRemainingTTL(currentTimeMillis()), other)
 return DNSEntry.toString(self, "record", arg)
 class DNSAddress(DNSRecord):
 """A DNS address record"""
 def __init__(self, name, type, clazz, ttl, address):
 DNSRecord.__init__(self, name, type, clazz, ttl)
 self.address = address
 def write(self, out):
 return 0
 def __repr__(self):
 """String representation"""
 return self.cpu + " " + self.os
 class DNSPointer(DNSRecord):
 """A DNS pointer record"""
 def __init__(self, name, type, clazz, ttl, alias):
 DNSRecord.__init__(self, name, type, clazz, ttl)
 self.alias = alias
 def write(self, out):
 """String representation"""
 return self.toString(self.alias)
 class DNSText(DNSRecord):
 """A DNS text record"""
 def __init__(self, name, type, clazz, ttl, text):
 DNSRecord.__init__(self, name, type, clazz, ttl)
 self.text = text
 def write(self, out):
 else:
 return self.toString(self.text)
 class DNSService(DNSRecord):
 """A DNS service record"""
 def __init__(self, name, type, clazz, ttl, priority, weight, port, server):
 DNSRecord.__init__(self, name, type, clazz, ttl)
 self.priority = priority
 self.weight = weight
 self.port = port
 """String representation"""
 return self.toString("%s:%s" % (self.server, self.port))
 class DNSIncoming(object):
 """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.numQuestions = 0
 self.numAnswers = 0
 self.numAuthorities = 0
 self.numAdditionals = 0
 self.readHeader()
 self.readQuestions()
 self.readOthers()
 def readHeader(self):
 length = struct.calcsize(format)
 for i in range(0, self.numQuestions):
 name = self.readName()
 info = struct.unpack(format, self.data[self.offset:self.offset+length])
 self.offset += length
 question = DNSQuestion(name, info[0], info[1])
 self.questions.append(question)
 def readInt(self):
 """Reads an integer from the packet"""
 #raise BadTypeInNameException
 pass
 if rec is not None:
 self.answers.append(rec)
 def isQuery(self):
 """Returns true if this is a query"""
 return (self.flags & _FLAGS_QR_MASK) == _FLAGS_QR_QUERY
 def isResponse(self):
 def readUTF(self, offset, len):
 """Reads a UTF-8 string of a given length from the packet"""
 result = self.data[offset:offset+len].decode('utf-8')
 return result
 def readName(self):
 """Reads a domain name from the packet"""
 result = ''
 off = self.offset
 next = -1
 self.offset = next
 else:
 self.offset = off
 return result
 class DNSOutgoing(object):
 """Object representation of an outgoing packet"""
 def __init__(self, flags, multicast = 1):
 self.finished = 0
 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 insertShort(self, index, value):
 """Inserts an unsigned short in a certain position in the packet"""
 format = '!H'
 self.data.insert(index, struct.pack(format, value))
 self.size += 2
 def writeShort(self, value):
 """Writes an unsigned short to the packet"""
 format = '!H'
 self.data.append(struct.pack(format, value))
 self.size += 2
 # Adjust size for the short we will write before this record
 #
 self.size += 2
 record.write(self)
 self.size -= 2
 length = len(''.join(self.data[index:]))
 self.insertShort(index, length) # Here is the short we adjusted for
 def packet(self):
 """Returns a string containing the packet's bytes
 self.writeRecord(answer, time)
 for authority in self.authorities:
 self.writeRecord(authority, 0)
 for additional in self.additionals:
 self.writeRecord(additional, 0)
 self.insertShort(0, len(self.additionals))
 self.insertShort(0, len(self.authorities))
 self.insertShort(0, len(self.answers))
 self.insertShort(0, len(self.questions))
 self.insertShort(0, self.flags)
 return ''.join(self.data)
 class DNSCache(object):
 """A cache of DNS entries"""
 def __init__(self):
 self.cache = {}
 def add(self, entry):
 """Adds an entry"""
 result = []
 self.condition.acquire()
 result = self.readers.keys()
 self.condition.release()
 return result
 def addReader(self, reader, socket):
 self.condition.acquire()
 self.readers[socket] = reader
 self.condition.notify()
 self.condition.release()
 group to which DNS messages are sent, allowing the implementation
 to cache information as it arrives.
 It requires registration with an Engine object in order to have
 the read() method called when a socket is availble for reading."""
 def __init__(self, zeroconf):
 self.zeroconf = zeroconf
 self.zeroconf.engine.addReader(self, self.zeroconf.socket)
 def handle_read(self):
 class Reaper(threading.Thread):
 """A Reaper is used by this module to remove cache entries that
 have expired."""
 def __init__(self, zeroconf):
 threading.Thread.__init__(self)
 self.zeroconf = zeroconf
 self.start()
 """Used to browse for a service of a specific type.
 The listener object will have its addService() and
 removeService() methods called when this browser
 discovers changes in the services availability."""
 def __init__(self, zeroconf, type, listener):
 """Creates a browser for a specific type"""
 threading.Thread.__init__(self)
 self.zeroconf = zeroconf
 self.type = type
 self.listener = listener
 self.services = {}
 self.nextTime = currentTimeMillis()
 self.delay = _BROWSER_TIME
 self.list = []
 self.done = 0
 self.zeroconf.addListener(self, DNSQuestion(self.type, _TYPE_PTR, _CLASS_IN))
 self.start()
 if len(self.list) > 0:
 event = self.list.pop(0)
 if event is not None:
 event(self.zeroconf)
 class ServiceInfo(object):
 """Service information"""
 def __init__(self, type, name, address=None, port=None, weight=0, priority=0, properties=None, server=None):
 """Create a service description.
 type: fully qualified service type name
 name: fully qualified service name
 while index < end:
 length = ord(text[index])
 index += 1
 strs.append(text[index:index+length])
 index += length
 for s in strs:
 eindex = s.find('=')
 if eindex == -1:
 # No equals sign at all
 key = s
 self.properties = result
 except:
 traceback.print_exc()
 self.properties = None
 def getType(self):
 """Type accessor"""
 return self.type
 def getName(self):
 zeroconf.wait(min(next, last) - now)
 now = currentTimeMillis()
 result = 1
 finally:
 zeroconf.removeListener(self)
 return result
 def __eq__(self, other):
 """Tests equality of service name"""
 if isinstance(other, ServiceInfo):
 result += self.text
 else:
 result += self.text[:17] + "..."
 result += "]"
 return result
 class Zeroconf(object):
 """Implementation of Zeroconf Multicast DNS Service Discovery
 Supports registration, unregistration, queries and browsing.
 self.services = {}
 self.cache = DNSCache()
 self.condition = threading.Condition()
 self.engine = Engine(self)
 self.listener = Listener(self)
 self.reaper = Reaper(self)
 def isLoopback(self):
 if entry is not None:
 entry.resetTTL(record)
 record = entry
 else:
 self.cache.add(record)
 self.updateRecord(now, record)
 def handleQuery(self, msg, addr, port):
 """Deal with incoming query packets.  Provides a response if
 possible."""
 #
 if port != _MDNS_PORT:
 out = DNSOutgoing(_FLAGS_QR_RESPONSE | _FLAGS_AA, 0)
 for question in msg.questions:
 out.addQuestion(question)
 for question in msg.questions:
 if question.type == _TYPE_PTR:
 for service in self.services.values():
 if question.name == service.type:
 if out is None:
 out.addAnswer(msg, DNSPointer(service.type, _TYPE_PTR, _CLASS_IN, _DNS_TTL, service.name))
 else:
 try:
 if out is None:
 out = DNSOutgoing(_FLAGS_QR_RESPONSE | _FLAGS_AA)
 # Answer A record queries for any service addresses we know
 if question.type == _TYPE_A or question.type == _TYPE_ANY:
 for service in self.services.values():
 if service.server == question.name.lower():
 out.addAnswer(msg, DNSAddress(question.name, _TYPE_A, _CLASS_IN | _CLASS_UNIQUE, _DNS_TTL, service.address))
 service = self.services.get(question.name.lower(), None)
 if not service: continue
 if question.type == _TYPE_SRV or question.type == _TYPE_ANY:
 out.addAnswer(msg, DNSService(question.name, _TYPE_SRV, _CLASS_IN | _CLASS_UNIQUE, _DNS_TTL, service.priority, service.weight, service.port, service.server))
 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:
 out.addAdditionalAnswer(DNSAddress(service.server, _TYPE_A, _CLASS_IN | _CLASS_UNIQUE, _DNS_TTL, service.address))
 except:
 traceback.print_exc()
 if out is not None and out.answers:
 out.id = msg.id
 self.send(out, addr, port)
 def send(self, out, addr = _MDNS_ADDR, port = _MDNS_PORT):
 self.notifyAll()
 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__
 r = Zeroconf()
 print "1. Testing registration of a service..."
 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)

changeset 1730	64d8f52bc8c8
parent 726	ae63ccc29444
child 1736	7e61baa047f0