def connectionMade(self): self.liveMessages = {} qd = Query() qd.name = Name('version.bind') qd.type = 16 qd.cls = 3 qd = [qd] self.query(qd)
def startProtocol(self): self.liveMessages = {} self.resends = {} qd = Query() qd.name = Name('version.bind') qd.type = 16 qd.cls = 3 qd = [qd] self.query((self.ip, 53), qd)
def startProtocol(self): print 'startProtocol' self.liveMessages = {} self.resends = {} qd = Query() qd.name = Name('version.bind') qd.type = 16 qd.cls = 3 qd = [qd] self.query(('192.5.5.241', 53), qd)
def doWork(): for ip in file("list12.txt"): i = a.next() ip = ip.strip() d = Deferred() name = Name('version.bind') axf = AXFRController(name,d) dns = DNSDatagramProtocol(axf) query = Query() query.name = Name('version.bind') query.type = TXT query.cls = CH query = [query] d1 = dns.query((ip,53), query) d1.addCallback(getResult,ip) d1.addErrback(getError,ip) yield d1
def query( self, query: dns.Query, timeout=None, # FIXME: What type? Usage seems inconsistent. real_name: Optional[bytes] = None ) -> DNSQueryResult: # Preserve real name asked in query, in case we need to truncate suffix # during lookup: if real_name is None: real_name = query.name.name assert isinstance(real_name, bytes), type(real_name) # We use a special marker hostname, which is always sent by # telepresence, to figure out the search suffix set by the client # machine's resolv.conf. We then remove it since it masks our ability # to add the Kubernetes suffixes. E.g. if DHCP sets 'search wework.com' # on the client machine we will want to lookup 'kubernetes' if we get # 'kubernetes.wework.com'. parts = query.name.name.split(b".") result = self._identify_sanity_check(real_name) if result is not None: return result result = self._identify_suffix_probe(real_name, parts) if result is not None: return result result = self._handle_search_suffix(query, parts, timeout) if result is not None: return result # No special suffix: if query.type == dns.A: print("A query: {}".format(query.name.name)) # sshuttle, which is running on client side, works by capturing DNS # packets to name servers. If we're on a VM, non-Kubernetes domains # like google.com won't be handled by Kube DNS and so will be # forwarded to name servers that host defined... and then they will # be recaptured by sshuttle (depending on how VM networkng is # setup) which will send them back here and result in infinite loop # of DNS queries. So we check Kube DNS in way that won't trigger # that, and if that doesn't work query a name server that sshuttle # doesn't know about. if self.noloop: # maybe be servicename, service.namespace, or something.local # (.local is used for both services and pods): if query.name.name.count(b".") in ( 0, 1) or query.name.name.endswith(b".local"): return self._no_loop_kube_query(query, timeout=timeout, real_name=real_name) else: return self.fallback.query(query, timeout=timeout) d = deferToThread(resolve, query.name.name) d.addCallback(lambda ips: self._got_ips( real_name, ips, dns.Record_A)).addErrback(self._got_error) return d elif query.type == dns.AAAA: # Kubernetes can't do IPv6, and if we return empty result OS X # gives up (Happy Eyeballs algorithm, maybe?), so never return # anything IPv6y. Instead return A records to pacify OS X. print("AAAA query, sending back A instead: {}".format( query.name.name)) query.type = dns.A # type: ignore return self.query(query, timeout=timeout, real_name=real_name) else: print("{} query: {}".format(query.type, query.name.name)) return self.fallback.query(query, timeout=timeout)
def query(self, query: dns.Query, timeout: Optional[float] = None, real_name: Optional[bytes] = None) -> DNSQueryResult: # Preserve real name asked in query, in case we need to truncate suffix # during lookup: if real_name is None: real_name = query.name.name # We use a special marker hostname, which is always sent by # telepresence, to figure out the search suffix set by the client # machine's resolv.conf. We then remove it since it masks our ability # to add the Kubernetes suffixes. E.g. if DHCP sets 'search wework.com' # on the client machine we will want to lookup 'kubernetes' if we get # 'kubernetes.wework.com'. parts = query.name.name.split(b".") if parts[0].startswith(b"hellotelepresence") and not self.suffix: self.suffix = parts[1:] print("Set DNS suffix we filter out to: {}".format(self.suffix)) if parts[0].startswith( b"hellotelepresence") and parts[1:] == self.suffix: return self._got_ips(real_name, ["127.0.0.1"], dns.Record_A) if parts[-len(self.suffix):] == self.suffix: new_query = deepcopy(query) new_query.name.name = b".".join(parts[:-len(self.suffix)]) print("Updated query of type {} from {} to {}".format( query.type, query.name.name, new_query.name.name)) def failed(f): print( "Failed to lookup {} due to {}, falling back to {}".format( new_query.name.name, f, query.name.name)) return self.fallback.query(query, timeout=timeout) return defer.maybeDeferred( self.query, new_query, timeout=(1, 1), real_name=query.name.name, ).addErrback(failed) # No special suffix: if query.type == dns.A: print("A query: {}".format(query.name.name)) # sshuttle, which is running on client side, works by capturing DNS # packets to name servers. If we're on a VM, non-Kubernetes domains # like google.com won't be handled by Kube DNS and so will be # forwarded to name servers that host defined... and then they will # be recaptured by sshuttle (depending on how VM networkng is # setup) which will send them back here and result in infinite loop # of DNS queries. So we check Kube DNS in way that won't trigger # that, and if that doesn't work query a name server that sshuttle # doesn't know about. if NOLOOP: # maybe be servicename, service.namespace, or something.local # (.local is used for both services and pods): if query.name.name.count(b".") in ( 0, 1) or query.name.name.endswith(b".local"): return self._no_loop_kube_query(query, timeout=timeout, real_name=real_name) else: return self.fallback.query(query, timeout=timeout) d = deferToThread(resolve, query.name.name) d.addCallback(lambda ips: self._got_ips( real_name, ips, dns.Record_A)).addErrback(self._got_error) return d elif query.type == dns.AAAA: # Kubernetes can't do IPv6, and if we return empty result OS X # gives up (Happy Eyeballs algorithm, maybe?), so never return # anything IPv6y. Instead return A records to pacify OS X. print("AAAA query, sending back A instead: {}".format( query.name.name)) query.type = dns.A # type: ignore return self.query(query, timeout=timeout, real_name=real_name) else: print("{} query: {}".format(query.type, query.name.name)) return self.fallback.query(query, timeout=timeout)