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
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
116 def decode_dns_answer(payload)
117   begin
118     message = Resolv::DNS::Message.decode(payload)
119   rescue Resolv::DNS::DecodeError => e
120     return :decode_error, e
121   end
122 
123   # no domain was found
124   return :no_domain_found if message.rcode == Resolv::DNS::RCode::NXDomain
125 
126   return :message_truncated if message.tc == 1
127 
128   return :dns_error, message.rcode if message.rcode != Resolv::DNS::RCode::NoError
129 
130   addresses = []
131 
132   message.each_answer do |question, _, value|
133     case value
134     when Resolv::DNS::Resource::IN::CNAME
135       addresses << {
136         "name" => question.to_s,
137         "TTL" => value.ttl,
138         "alias" => value.name.to_s,
139       }
140     when Resolv::DNS::Resource::IN::A,
141          Resolv::DNS::Resource::IN::AAAA
142       addresses << {
143         "name" => question.to_s,
144         "TTL" => value.ttl,
145         "data" => value.address.to_s,
146       }
147     end
148   end
149 
150   [:ok, addresses]
151 end

    # File lib/httpx/resolver.rb
109 def encode_dns_query(hostname, type: Resolv::DNS::Resource::IN::A, message_id: generate_id)
110   Resolv::DNS::Message.new(message_id).tap do |query|
111     query.rd = 1
112     query.add_question(hostname, type)
113   end.encode
114 end

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

    # File lib/httpx/resolver.rb
157 def id_synchronize(&block)
158   @identifier_mutex.synchronize(&block)
159 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
 87 def lookup(hostname, lookups, ttl)
 88   return unless lookups.key?(hostname)
 89 
 90   entries = lookups[hostname] = lookups[hostname].select do |address|
 91     address["TTL"] > ttl
 92   end
 93 
 94   ips = entries.flat_map do |address|
 95     if address.key?("alias")
 96       lookup(address["alias"], lookups, ttl)
 97     else
 98       IPAddr.new(address["data"])
 99     end
100   end.compact
101 
102   ips unless ips.empty?
103 end

    # File lib/httpx/resolver.rb
153 def lookup_synchronize
154   @lookup_mutex.synchronize { yield(@lookups) }
155 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