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)