module HTTPX::Resolver

   # File lib/httpx/resolver.rb
54 def cached_lookup(hostname)
55   now = Utils.now
56   lookup_synchronize do |lookups|
57     lookup(hostname, lookups, now)
58   end
59 end

   # File lib/httpx/resolver.rb
86 def cached_lookup_evict(hostname, ip)
87   ip = ip.to_s
88 
89   lookup_synchronize do |lookups|
90     entries = lookups[hostname]
91 
92     return unless entries
93 
94     lookups.delete_if { |entry| entry["data"] == ip }
95   end
96 end

   # File lib/httpx/resolver.rb
61 def cached_lookup_set(hostname, family, entries)
62   now = Utils.now
63   entries.each do |entry|
64     entry["TTL"] += now
65   end
66   lookup_synchronize do |lookups|
67     case family
68     when Socket::AF_INET6
69       lookups[hostname].concat(entries)
70     when Socket::AF_INET
71       lookups[hostname].unshift(*entries)
72     end
73     entries.each do |entry|
74       next unless entry["name"] != hostname
75 
76       case family
77       when Socket::AF_INET6
78         lookups[entry["name"]] << entry
79       when Socket::AF_INET
80         lookups[entry["name"]].unshift(entry)
81       end
82     end
83   end
84 end

    # File lib/httpx/resolver.rb
128 def decode_dns_answer(payload)
129   begin
130     message = Resolv::DNS::Message.decode(payload)
131   rescue Resolv::DNS::DecodeError => e
132     return :decode_error, e
133   end
134 
135   # no domain was found
136   return :no_domain_found if message.rcode == Resolv::DNS::RCode::NXDomain
137 
138   return :message_truncated if message.tc == 1
139 
140   return :dns_error, message.rcode if message.rcode != Resolv::DNS::RCode::NoError
141 
142   addresses = []
143 
144   message.each_answer do |question, _, value|
145     case value
146     when Resolv::DNS::Resource::IN::CNAME
147       addresses << {
148         "name" => question.to_s,
149         "TTL" => value.ttl,
150         "alias" => value.name.to_s,
151       }
152     when Resolv::DNS::Resource::IN::A,
153          Resolv::DNS::Resource::IN::AAAA
154       addresses << {
155         "name" => question.to_s,
156         "TTL" => value.ttl,
157         "data" => value.address.to_s,
158       }
159     end
160   end
161 
162   [:ok, addresses]
163 end

    # File lib/httpx/resolver.rb
121 def encode_dns_query(hostname, type: Resolv::DNS::Resource::IN::A, message_id: generate_id)
122   Resolv::DNS::Message.new(message_id).tap do |query|
123     query.rd = 1
124     query.add_question(hostname, type)
125   end.encode
126 end

    # File lib/httpx/resolver.rb
117 def generate_id
118   id_synchronize { @identifier = (@identifier + 1) & 0xFFFF }
119 end

    # File lib/httpx/resolver.rb
169 def id_synchronize(&block)
170   @identifier_mutex.synchronize(&block)
171 end

   # File lib/httpx/resolver.rb
41 def ip_resolve(hostname)
42   [IPAddr.new(hostname)]
43 rescue ArgumentError
44 end

    # File lib/httpx/resolver.rb
 99 def lookup(hostname, lookups, ttl)
100   return unless lookups.key?(hostname)
101 
102   entries = lookups[hostname] = lookups[hostname].select do |address|
103     address["TTL"] > ttl
104   end
105 
106   ips = entries.flat_map do |address|
107     if (als = address["alias"])
108       lookup(als, lookups, ttl)
109     else
110       IPAddr.new(address["data"])
111     end
112   end.compact
113 
114   ips unless ips.empty?
115 end

    # File lib/httpx/resolver.rb
165 def lookup_synchronize
166   @lookup_mutex.synchronize { yield(@lookups) }
167 end

   # File lib/httpx/resolver.rb
37 def nolookup_resolve(hostname)
38   ip_resolve(hostname) || cached_lookup(hostname) || system_resolve(hostname)
39 end

   # File lib/httpx/resolver.rb
25 def resolver_for(resolver_type)
26   case resolver_type
27   when :native then Native
28   when :system then System
29   when :https then HTTPS
30   else
31     return resolver_type if resolver_type.is_a?(Class) && resolver_type < Resolver
32 
33     raise Error, "unsupported resolver type (#{resolver_type})"
34   end
35 end

   # File lib/httpx/resolver.rb
46 def system_resolve(hostname)
47   ips = @system_resolver.getaddresses(hostname)
48   return if ips.empty?
49 
50   ips.map { |ip| IPAddr.new(ip) }
51 rescue IOError
52 end