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