1package eu.siacs.conversations.utils;
2
3import android.content.ContentValues;
4import android.database.Cursor;
5import android.util.Log;
6import androidx.annotation.NonNull;
7import com.google.common.base.MoreObjects;
8import com.google.common.base.Objects;
9import com.google.common.base.Strings;
10import com.google.common.collect.Collections2;
11import com.google.common.collect.ImmutableList;
12import com.google.common.collect.Lists;
13import com.google.common.collect.Ordering;
14import com.google.common.net.InetAddresses;
15import com.google.common.primitives.Ints;
16import com.google.common.util.concurrent.Futures;
17import com.google.common.util.concurrent.ListenableFuture;
18import com.google.common.util.concurrent.MoreExecutors;
19import de.gultsch.minidns.AndroidDNSClient;
20import de.gultsch.minidns.ResolverResult;
21import eu.siacs.conversations.Config;
22import eu.siacs.conversations.Conversations;
23import eu.siacs.conversations.xmpp.Jid;
24import java.net.Inet4Address;
25import java.net.InetAddress;
26import java.net.UnknownHostException;
27import java.util.Arrays;
28import java.util.Collection;
29import java.util.Collections;
30import java.util.Comparator;
31import java.util.List;
32import java.util.concurrent.ExecutionException;
33import java.util.concurrent.ExecutorService;
34import java.util.concurrent.Executors;
35import org.minidns.dnsmessage.Question;
36import org.minidns.dnsname.DnsName;
37import org.minidns.dnsname.InvalidDnsNameException;
38import org.minidns.dnsqueryresult.DnsQueryResult;
39import org.minidns.record.A;
40import org.minidns.record.AAAA;
41import org.minidns.record.CNAME;
42import org.minidns.record.Data;
43import org.minidns.record.InternetAddressRR;
44import org.minidns.record.Record;
45import org.minidns.record.SRV;
46
47public class Resolver {
48
49 private static final Comparator<Result> RESULT_COMPARATOR =
50 (left, right) -> {
51 if (left.priority == right.priority) {
52 if (left.directTls == right.directTls) {
53 if (left.ip == null && right.ip == null) {
54 return 0;
55 } else if (left.ip != null && right.ip != null) {
56 if (left.ip instanceof Inet4Address
57 && right.ip instanceof Inet4Address) {
58 return 0;
59 } else {
60 return left.ip instanceof Inet4Address ? -1 : 1;
61 }
62 } else {
63 return left.ip != null ? -1 : 1;
64 }
65 } else {
66 return left.directTls ? -1 : 1;
67 }
68 } else {
69 return left.priority - right.priority;
70 }
71 };
72
73 private static final ExecutorService DNS_QUERY_EXECUTOR = Executors.newFixedThreadPool(12);
74
75 public static final int XMPP_PORT_STARTTLS = 5222;
76 private static final int XMPP_PORT_DIRECT_TLS = 5223;
77
78 private static final String DIRECT_TLS_SERVICE = "_xmpps-client";
79 private static final String STARTTLS_SERVICE = "_xmpp-client";
80
81 public static List<Result> fromHardCoded(final String hostname, final int port) {
82 final Result result = new Result();
83 result.hostname = DnsName.from(hostname);
84 result.port = port;
85 result.directTls = useDirectTls(port);
86 result.authenticated = true;
87 return Collections.singletonList(result);
88 }
89
90 public static void checkDomain(final Jid jid) {
91 DnsName.from(jid.getDomain());
92 }
93
94 public static boolean invalidHostname(final String hostname) {
95 try {
96 DnsName.from(hostname);
97 return false;
98 } catch (final InvalidDnsNameException | IllegalArgumentException e) {
99 return true;
100 }
101 }
102
103 public static void clearCache() {}
104
105 public static boolean useDirectTls(final int port) {
106 return port == 443 || port == XMPP_PORT_DIRECT_TLS;
107 }
108
109 public static List<Result> resolve(final String domain) {
110 final List<Result> ipResults = fromIpAddress(domain);
111 if (!ipResults.isEmpty()) {
112 return ipResults;
113 }
114
115 final var startTls = resolveSrvAsFuture(domain, false);
116 final var directTls = resolveSrvAsFuture(domain, true);
117
118 final var combined = merge(ImmutableList.of(startTls, directTls));
119
120 final var combinedWithFallback =
121 Futures.transformAsync(
122 combined,
123 results -> {
124 if (results.isEmpty()) {
125 return resolveNoSrvAsFuture(DnsName.from(domain), true);
126 } else {
127 return Futures.immediateFuture(results);
128 }
129 },
130 MoreExecutors.directExecutor());
131 final var orderedFuture =
132 Futures.transform(
133 combinedWithFallback,
134 all -> Ordering.from(RESULT_COMPARATOR).immutableSortedCopy(all),
135 MoreExecutors.directExecutor());
136 try {
137 final var ordered = orderedFuture.get();
138 Log.d(Config.LOGTAG, "Resolver (" + ordered.size() + "): " + ordered);
139 return ordered;
140 } catch (final ExecutionException e) {
141 Log.d(Config.LOGTAG, "error resolving DNS", e);
142 return Collections.emptyList();
143 } catch (final InterruptedException e) {
144 Log.d(Config.LOGTAG, "DNS resolution interrupted");
145 return Collections.emptyList();
146 }
147 }
148
149 private static List<Result> fromIpAddress(final String domain) {
150 if (IP.matches(domain)) {
151 final InetAddress inetAddress;
152 try {
153 inetAddress = InetAddresses.forString(domain);
154 } catch (final IllegalArgumentException e) {
155 return Collections.emptyList();
156 }
157 return Result.createWithDefaultPorts(null, inetAddress);
158 } else {
159 return Collections.emptyList();
160 }
161 }
162
163 private static ListenableFuture<List<Result>> resolveSrvAsFuture(
164 final String domain, final boolean directTls) {
165 final DnsName dnsName =
166 DnsName.from(
167 (directTls ? DIRECT_TLS_SERVICE : STARTTLS_SERVICE) + "._tcp." + domain);
168 final var resultFuture = resolveAsFuture(dnsName, SRV.class);
169 return Futures.transformAsync(
170 resultFuture,
171 result -> resolveIpsAsFuture(result, directTls),
172 MoreExecutors.directExecutor());
173 }
174
175 @NonNull
176 private static ListenableFuture<List<Result>> resolveIpsAsFuture(
177 final ResolverResult<SRV> srvResolverResult, final boolean directTls) {
178 final ImmutableList.Builder<ListenableFuture<List<Result>>> futuresBuilder =
179 new ImmutableList.Builder<>();
180 for (final SRV record : srvResolverResult.getAnswersOrEmptySet()) {
181 if (record.target.length() == 0 && record.priority == 0) {
182 continue;
183 }
184 final var ipv4sRaw =
185 resolveIpsAsFuture(
186 record, A.class, srvResolverResult.isAuthenticData(), directTls);
187 final var ipv4s =
188 Futures.transform(
189 ipv4sRaw,
190 results -> {
191 if (results.isEmpty()) {
192 final Result resolverResult =
193 Result.fromRecord(record, directTls);
194 resolverResult.authenticated =
195 srvResolverResult.isAuthenticData();
196 return Collections.singletonList(resolverResult);
197 } else {
198 return results;
199 }
200 },
201 MoreExecutors.directExecutor());
202 final var ipv6s =
203 resolveIpsAsFuture(
204 record, AAAA.class, srvResolverResult.isAuthenticData(), directTls);
205 futuresBuilder.add(ipv4s);
206 futuresBuilder.add(ipv6s);
207 }
208 final ImmutableList<ListenableFuture<List<Result>>> futures = futuresBuilder.build();
209 return merge(futures);
210 }
211
212 private static ListenableFuture<List<Result>> merge(
213 final Collection<ListenableFuture<List<Result>>> futures) {
214 return Futures.transform(
215 Futures.successfulAsList(futures),
216 lists -> {
217 final var builder = new ImmutableList.Builder<Result>();
218 for (final Collection<Result> list : lists) {
219 if (list == null) {
220 continue;
221 }
222 builder.addAll(list);
223 }
224 return builder.build();
225 },
226 MoreExecutors.directExecutor());
227 }
228
229 private static <D extends InternetAddressRR<?>>
230 ListenableFuture<List<Result>> resolveIpsAsFuture(
231 final SRV srv, Class<D> type, boolean authenticated, boolean directTls) {
232 final var resultFuture = resolveAsFuture(srv.target, type);
233 return Futures.transform(
234 resultFuture,
235 result -> {
236 final var builder = new ImmutableList.Builder<Result>();
237 for (D record : result.getAnswersOrEmptySet()) {
238 Result resolverResult = Result.fromRecord(srv, directTls);
239 resolverResult.authenticated =
240 result.isAuthenticData()
241 && authenticated; // TODO technically it does not matter if
242 // the IP
243 // was authenticated
244 resolverResult.ip = record.getInetAddress();
245 builder.add(resolverResult);
246 }
247 return builder.build();
248 },
249 MoreExecutors.directExecutor());
250 }
251
252 private static ListenableFuture<List<Result>> resolveNoSrvAsFuture(
253 final DnsName dnsName, boolean cName) {
254 final ImmutableList.Builder<ListenableFuture<List<Result>>> futuresBuilder =
255 new ImmutableList.Builder<>();
256 ListenableFuture<List<Result>> aRecordResults =
257 Futures.transform(
258 resolveAsFuture(dnsName, A.class),
259 result ->
260 Result.createDefaults(
261 dnsName,
262 Collections2.transform(
263 result.getAnswersOrEmptySet(),
264 InternetAddressRR::getInetAddress)),
265 MoreExecutors.directExecutor());
266 futuresBuilder.add(aRecordResults);
267 ListenableFuture<List<Result>> aaaaRecordResults =
268 Futures.transform(
269 resolveAsFuture(dnsName, AAAA.class),
270 result ->
271 Result.createDefaults(
272 dnsName,
273 Collections2.transform(
274 result.getAnswersOrEmptySet(),
275 InternetAddressRR::getInetAddress)),
276 MoreExecutors.directExecutor());
277 futuresBuilder.add(aaaaRecordResults);
278 if (cName) {
279 ListenableFuture<List<Result>> cNameRecordResults =
280 Futures.transformAsync(
281 resolveAsFuture(dnsName, CNAME.class),
282 result -> {
283 Collection<ListenableFuture<List<Result>>> test =
284 Lists.transform(
285 ImmutableList.copyOf(result.getAnswersOrEmptySet()),
286 cname -> resolveNoSrvAsFuture(cname.target, false));
287 return merge(test);
288 },
289 MoreExecutors.directExecutor());
290 futuresBuilder.add(cNameRecordResults);
291 }
292 final ImmutableList<ListenableFuture<List<Result>>> futures = futuresBuilder.build();
293 final var noSrvFallbacks = merge(futures);
294 return Futures.transform(
295 noSrvFallbacks,
296 results -> {
297 if (results.isEmpty()) {
298 return Result.createDefaults(dnsName);
299 } else {
300 return results;
301 }
302 },
303 MoreExecutors.directExecutor());
304 }
305
306 private static <D extends Data> ListenableFuture<ResolverResult<D>> resolveAsFuture(
307 final DnsName dnsName, final Class<D> type) {
308 return Futures.submit(
309 () -> {
310 final Question question = new Question(dnsName, Record.TYPE.getType(type));
311 final AndroidDNSClient androidDNSClient =
312 new AndroidDNSClient(Conversations.getContext());
313 final DnsQueryResult dnsQueryResult = androidDNSClient.query(question);
314 return new ResolverResult<>(question, dnsQueryResult, null);
315 },
316 DNS_QUERY_EXECUTOR);
317 }
318
319 public static class Result {
320 public static final String DOMAIN = "domain";
321 public static final String IP = "ip";
322 public static final String HOSTNAME = "hostname";
323 public static final String PORT = "port";
324 public static final String PRIORITY = "priority";
325 public static final String DIRECT_TLS = "directTls";
326 public static final String AUTHENTICATED = "authenticated";
327 private InetAddress ip;
328 private DnsName hostname;
329 private int port = XMPP_PORT_STARTTLS;
330 private boolean directTls = false;
331 private boolean authenticated = false;
332 private int priority;
333
334 static Result fromRecord(final SRV srv, final boolean directTls) {
335 final Result result = new Result();
336 result.port = srv.port;
337 result.hostname = srv.target;
338 result.directTls = directTls;
339 result.priority = srv.priority;
340 return result;
341 }
342
343 static List<Result> createWithDefaultPorts(final DnsName hostname, final InetAddress ip) {
344 return Lists.transform(
345 Arrays.asList(XMPP_PORT_STARTTLS, XMPP_PORT_DIRECT_TLS),
346 p -> createDefault(hostname, ip, p));
347 }
348
349 static Result createDefault(final DnsName hostname, final InetAddress ip, final int port) {
350 Result result = new Result();
351 result.port = port;
352 result.hostname = hostname;
353 result.ip = ip;
354 result.directTls = useDirectTls(port);
355 return result;
356 }
357
358 static List<Result> createDefaults(
359 final DnsName hostname, final Collection<InetAddress> inetAddresses) {
360 final ImmutableList.Builder<Result> builder = new ImmutableList.Builder<>();
361 for (final InetAddress inetAddress : inetAddresses) {
362 builder.addAll(createWithDefaultPorts(hostname, inetAddress));
363 }
364 return builder.build();
365 }
366
367 static List<Result> createDefaults(final DnsName hostname) {
368 return createWithDefaultPorts(hostname, null);
369 }
370
371 public static Result fromCursor(final Cursor cursor) {
372 final Result result = new Result();
373 try {
374 result.ip =
375 InetAddress.getByAddress(cursor.getBlob(cursor.getColumnIndexOrThrow(IP)));
376 } catch (final UnknownHostException e) {
377 result.ip = null;
378 }
379 final String hostname = cursor.getString(cursor.getColumnIndexOrThrow(HOSTNAME));
380 result.hostname = hostname == null ? null : DnsName.from(hostname);
381 result.port = cursor.getInt(cursor.getColumnIndexOrThrow(PORT));
382 result.priority = cursor.getInt(cursor.getColumnIndexOrThrow(PRIORITY));
383 result.authenticated = cursor.getInt(cursor.getColumnIndexOrThrow(AUTHENTICATED)) > 0;
384 result.directTls = cursor.getInt(cursor.getColumnIndexOrThrow(DIRECT_TLS)) > 0;
385 return result;
386 }
387
388 @Override
389 public boolean equals(Object o) {
390 if (this == o) return true;
391 if (o == null || getClass() != o.getClass()) return false;
392 Result result = (Result) o;
393 return port == result.port
394 && directTls == result.directTls
395 && authenticated == result.authenticated
396 && priority == result.priority
397 && Objects.equal(ip, result.ip)
398 && Objects.equal(hostname, result.hostname);
399 }
400
401 @Override
402 public int hashCode() {
403 return Objects.hashCode(ip, hostname, port, directTls, authenticated, priority);
404 }
405
406 public InetAddress getIp() {
407 return ip;
408 }
409
410 public int getPort() {
411 return port;
412 }
413
414 public DnsName getHostname() {
415 return hostname;
416 }
417
418 public boolean isDirectTls() {
419 return directTls;
420 }
421
422 public boolean isAuthenticated() {
423 return authenticated;
424 }
425
426 @Override
427 @NonNull
428 public String toString() {
429 return MoreObjects.toStringHelper(this)
430 .add("ip", ip)
431 .add("hostname", hostname)
432 .add("port", port)
433 .add("directTls", directTls)
434 .add("authenticated", authenticated)
435 .add("priority", priority)
436 .toString();
437 }
438
439 public String asDestination() {
440 return ip != null ? InetAddresses.toAddrString(ip) : hostname.toString();
441 }
442
443 public ContentValues toContentValues() {
444 final ContentValues contentValues = new ContentValues();
445 contentValues.put(IP, ip == null ? null : ip.getAddress());
446 contentValues.put(HOSTNAME, hostname == null ? null : hostname.toString());
447 contentValues.put(PORT, port);
448 contentValues.put(PRIORITY, priority);
449 contentValues.put(DIRECT_TLS, directTls ? 1 : 0);
450 contentValues.put(AUTHENTICATED, authenticated ? 1 : 0);
451 return contentValues;
452 }
453
454 public Result seeOtherHost(final String seeOtherHost) {
455 final String hostname = seeOtherHost.trim();
456 if (hostname.isEmpty()) {
457 return null;
458 }
459 final Result result = new Result();
460 result.directTls = this.directTls;
461 final int portSegmentStart = hostname.lastIndexOf(':');
462 if (hostname.charAt(hostname.length() - 1) != ']'
463 && portSegmentStart >= 0
464 && hostname.length() >= portSegmentStart + 1) {
465 final String hostPart = hostname.substring(0, portSegmentStart);
466 final String portPart = hostname.substring(portSegmentStart + 1);
467 final Integer port = Ints.tryParse(portPart);
468 if (port == null || Strings.isNullOrEmpty(hostPart)) {
469 return null;
470 }
471 final String host = eu.siacs.conversations.utils.IP.unwrapIPv6(hostPart);
472 result.port = port;
473 if (InetAddresses.isInetAddress(host)) {
474 final InetAddress inetAddress;
475 try {
476 inetAddress = InetAddresses.forString(host);
477 } catch (final IllegalArgumentException e) {
478 return null;
479 }
480 result.ip = inetAddress;
481 } else {
482 if (hostPart.trim().isEmpty()) {
483 return null;
484 }
485 try {
486 result.hostname = DnsName.from(hostPart.trim());
487 } catch (final Exception e) {
488 return null;
489 }
490 }
491 } else {
492 final String host = eu.siacs.conversations.utils.IP.unwrapIPv6(hostname);
493 if (InetAddresses.isInetAddress(host)) {
494 final InetAddress inetAddress;
495 try {
496 inetAddress = InetAddresses.forString(host);
497 } catch (final IllegalArgumentException e) {
498 return null;
499 }
500 result.ip = inetAddress;
501 } else {
502 try {
503 result.hostname = DnsName.from(hostname);
504 } catch (final Exception e) {
505 return null;
506 }
507 }
508 result.port = port;
509 }
510 return result;
511 }
512 }
513}