Luke Huang | 00b15f3 | 2019-01-04 19:56:29 +0800 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2019 The Android Open Source Project |
| 3 | * |
| 4 | * Licensed under the Apache License, Version 2.0 (the "License"); |
| 5 | * you may not use this file except in compliance with the License. |
| 6 | * You may obtain a copy of the License at |
| 7 | * |
| 8 | * http://www.apache.org/licenses/LICENSE-2.0 |
| 9 | * |
| 10 | * Unless required by applicable law or agreed to in writing, software |
| 11 | * distributed under the License is distributed on an "AS IS" BASIS, |
| 12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 13 | * See the License for the specific language governing permissions and |
| 14 | * limitations under the License. |
| 15 | */ |
| 16 | |
| 17 | package android.net; |
| 18 | |
Luke Huang | 7466ac8d | 2019-05-23 06:14:28 -0700 | [diff] [blame] | 19 | import static android.net.NetworkUtils.getDnsNetId; |
Luke Huang | c09f2d6 | 2019-03-08 14:48:59 +0800 | [diff] [blame] | 20 | import static android.net.NetworkUtils.resNetworkCancel; |
Luke Huang | 00b15f3 | 2019-01-04 19:56:29 +0800 | [diff] [blame] | 21 | import static android.net.NetworkUtils.resNetworkQuery; |
| 22 | import static android.net.NetworkUtils.resNetworkResult; |
| 23 | import static android.net.NetworkUtils.resNetworkSend; |
Luke Huang | 7466ac8d | 2019-05-23 06:14:28 -0700 | [diff] [blame] | 24 | import static android.net.util.DnsUtils.haveIpv4; |
| 25 | import static android.net.util.DnsUtils.haveIpv6; |
| 26 | import static android.net.util.DnsUtils.rfc6724Sort; |
Luke Huang | 00b15f3 | 2019-01-04 19:56:29 +0800 | [diff] [blame] | 27 | import static android.os.MessageQueue.OnFileDescriptorEventListener.EVENT_ERROR; |
| 28 | import static android.os.MessageQueue.OnFileDescriptorEventListener.EVENT_INPUT; |
Luke Huang | 7466ac8d | 2019-05-23 06:14:28 -0700 | [diff] [blame] | 29 | import static android.system.OsConstants.ENONET; |
Luke Huang | 00b15f3 | 2019-01-04 19:56:29 +0800 | [diff] [blame] | 30 | |
Luke Huang | e4c7913 | 2019-03-07 19:01:26 +0800 | [diff] [blame] | 31 | import android.annotation.CallbackExecutor; |
Luke Huang | 00b15f3 | 2019-01-04 19:56:29 +0800 | [diff] [blame] | 32 | import android.annotation.IntDef; |
| 33 | import android.annotation.NonNull; |
| 34 | import android.annotation.Nullable; |
Luke Huang | c09f2d6 | 2019-03-08 14:48:59 +0800 | [diff] [blame] | 35 | import android.os.CancellationSignal; |
Luke Huang | e4c7913 | 2019-03-07 19:01:26 +0800 | [diff] [blame] | 36 | import android.os.Looper; |
Luke Huang | 00b15f3 | 2019-01-04 19:56:29 +0800 | [diff] [blame] | 37 | import android.system.ErrnoException; |
| 38 | import android.util.Log; |
| 39 | |
| 40 | import java.io.FileDescriptor; |
| 41 | import java.lang.annotation.Retention; |
| 42 | import java.lang.annotation.RetentionPolicy; |
| 43 | import java.net.InetAddress; |
| 44 | import java.net.UnknownHostException; |
| 45 | import java.util.ArrayList; |
| 46 | import java.util.List; |
Luke Huang | e4c7913 | 2019-03-07 19:01:26 +0800 | [diff] [blame] | 47 | import java.util.concurrent.Executor; |
Luke Huang | 00b15f3 | 2019-01-04 19:56:29 +0800 | [diff] [blame] | 48 | |
| 49 | /** |
| 50 | * Dns resolver class for asynchronous dns querying |
| 51 | * |
Luke Huang | 33bfef3 | 2019-01-23 21:53:13 +0800 | [diff] [blame] | 52 | * Note that if a client sends a query with more than 1 record in the question section but |
| 53 | * the remote dns server does not support this, it may not respond at all, leading to a timeout. |
| 54 | * |
Luke Huang | 00b15f3 | 2019-01-04 19:56:29 +0800 | [diff] [blame] | 55 | */ |
| 56 | public final class DnsResolver { |
| 57 | private static final String TAG = "DnsResolver"; |
| 58 | private static final int FD_EVENTS = EVENT_INPUT | EVENT_ERROR; |
| 59 | private static final int MAXPACKET = 8 * 1024; |
Luke Huang | 5bf7aa2 | 2019-03-29 18:01:11 +0800 | [diff] [blame] | 60 | private static final int SLEEP_TIME_MS = 2; |
Luke Huang | 00b15f3 | 2019-01-04 19:56:29 +0800 | [diff] [blame] | 61 | |
| 62 | @IntDef(prefix = { "CLASS_" }, value = { |
| 63 | CLASS_IN |
| 64 | }) |
| 65 | @Retention(RetentionPolicy.SOURCE) |
| 66 | @interface QueryClass {} |
| 67 | public static final int CLASS_IN = 1; |
| 68 | |
| 69 | @IntDef(prefix = { "TYPE_" }, value = { |
| 70 | TYPE_A, |
| 71 | TYPE_AAAA |
| 72 | }) |
| 73 | @Retention(RetentionPolicy.SOURCE) |
| 74 | @interface QueryType {} |
| 75 | public static final int TYPE_A = 1; |
| 76 | public static final int TYPE_AAAA = 28; |
| 77 | |
| 78 | @IntDef(prefix = { "FLAG_" }, value = { |
| 79 | FLAG_EMPTY, |
| 80 | FLAG_NO_RETRY, |
| 81 | FLAG_NO_CACHE_STORE, |
| 82 | FLAG_NO_CACHE_LOOKUP |
| 83 | }) |
| 84 | @Retention(RetentionPolicy.SOURCE) |
| 85 | @interface QueryFlag {} |
| 86 | public static final int FLAG_EMPTY = 0; |
| 87 | public static final int FLAG_NO_RETRY = 1 << 0; |
| 88 | public static final int FLAG_NO_CACHE_STORE = 1 << 1; |
| 89 | public static final int FLAG_NO_CACHE_LOOKUP = 1 << 2; |
| 90 | |
Luke Huang | ec21447 | 2019-04-11 17:54:41 -0700 | [diff] [blame] | 91 | @IntDef(prefix = { "ERROR_" }, value = { |
| 92 | ERROR_PARSE, |
| 93 | ERROR_SYSTEM |
| 94 | }) |
| 95 | @Retention(RetentionPolicy.SOURCE) |
| 96 | @interface DnsError {} |
| 97 | /** |
| 98 | * Indicates that there was an error parsing the response the query. |
| 99 | * The cause of this error is available via getCause() and is a ParseException. |
| 100 | */ |
| 101 | public static final int ERROR_PARSE = 0; |
| 102 | /** |
| 103 | * Indicates that there was an error sending the query. |
| 104 | * The cause of this error is available via getCause() and is an ErrnoException. |
| 105 | */ |
| 106 | public static final int ERROR_SYSTEM = 1; |
| 107 | |
Luke Huang | 00b15f3 | 2019-01-04 19:56:29 +0800 | [diff] [blame] | 108 | private static final int NETID_UNSET = 0; |
| 109 | |
| 110 | private static final DnsResolver sInstance = new DnsResolver(); |
| 111 | |
| 112 | /** |
Luke Huang | 00b15f3 | 2019-01-04 19:56:29 +0800 | [diff] [blame] | 113 | * Get instance for DnsResolver |
| 114 | */ |
Luke Huang | 304491d | 2019-03-04 17:08:03 +0800 | [diff] [blame] | 115 | public static @NonNull DnsResolver getInstance() { |
Luke Huang | 00b15f3 | 2019-01-04 19:56:29 +0800 | [diff] [blame] | 116 | return sInstance; |
| 117 | } |
| 118 | |
| 119 | private DnsResolver() {} |
| 120 | |
| 121 | /** |
Luke Huang | ec21447 | 2019-04-11 17:54:41 -0700 | [diff] [blame] | 122 | * Base interface for answer callbacks |
Luke Huang | 304491d | 2019-03-04 17:08:03 +0800 | [diff] [blame] | 123 | * |
Luke Huang | ec21447 | 2019-04-11 17:54:41 -0700 | [diff] [blame] | 124 | * @param <T> The type of the answer |
Luke Huang | 304491d | 2019-03-04 17:08:03 +0800 | [diff] [blame] | 125 | */ |
Luke Huang | ec21447 | 2019-04-11 17:54:41 -0700 | [diff] [blame] | 126 | public interface Callback<T> { |
Luke Huang | 304491d | 2019-03-04 17:08:03 +0800 | [diff] [blame] | 127 | /** |
| 128 | * Success response to |
Luke Huang | ec21447 | 2019-04-11 17:54:41 -0700 | [diff] [blame] | 129 | * {@link android.net.DnsResolver#query query()} or |
| 130 | * {@link android.net.DnsResolver#rawQuery rawQuery()}. |
Luke Huang | 304491d | 2019-03-04 17:08:03 +0800 | [diff] [blame] | 131 | * |
| 132 | * Invoked when the answer to a query was successfully parsed. |
| 133 | * |
Luke Huang | ec21447 | 2019-04-11 17:54:41 -0700 | [diff] [blame] | 134 | * @param answer <T> answer to the query. |
| 135 | * @param rcode The response code in the DNS response. |
Luke Huang | 304491d | 2019-03-04 17:08:03 +0800 | [diff] [blame] | 136 | * |
| 137 | * {@see android.net.DnsResolver#query query()} |
| 138 | */ |
Luke Huang | ec21447 | 2019-04-11 17:54:41 -0700 | [diff] [blame] | 139 | void onAnswer(@NonNull T answer, int rcode); |
Luke Huang | 304491d | 2019-03-04 17:08:03 +0800 | [diff] [blame] | 140 | /** |
| 141 | * Error response to |
Luke Huang | ec21447 | 2019-04-11 17:54:41 -0700 | [diff] [blame] | 142 | * {@link android.net.DnsResolver#query query()} or |
| 143 | * {@link android.net.DnsResolver#rawQuery rawQuery()}. |
Luke Huang | 304491d | 2019-03-04 17:08:03 +0800 | [diff] [blame] | 144 | * |
| 145 | * Invoked when there is no valid answer to |
| 146 | * {@link android.net.DnsResolver#query query()} |
Luke Huang | ec21447 | 2019-04-11 17:54:41 -0700 | [diff] [blame] | 147 | * {@link android.net.DnsResolver#rawQuery rawQuery()}. |
Luke Huang | 304491d | 2019-03-04 17:08:03 +0800 | [diff] [blame] | 148 | * |
Luke Huang | ec21447 | 2019-04-11 17:54:41 -0700 | [diff] [blame] | 149 | * @param error a {@link DnsException} object with additional |
Luke Huang | 304491d | 2019-03-04 17:08:03 +0800 | [diff] [blame] | 150 | * detail regarding the failure |
| 151 | */ |
Luke Huang | ec21447 | 2019-04-11 17:54:41 -0700 | [diff] [blame] | 152 | void onError(@NonNull DnsException error); |
Luke Huang | 304491d | 2019-03-04 17:08:03 +0800 | [diff] [blame] | 153 | } |
| 154 | |
| 155 | /** |
Luke Huang | ec21447 | 2019-04-11 17:54:41 -0700 | [diff] [blame] | 156 | * Class to represent DNS error |
Luke Huang | 304491d | 2019-03-04 17:08:03 +0800 | [diff] [blame] | 157 | */ |
Luke Huang | ec21447 | 2019-04-11 17:54:41 -0700 | [diff] [blame] | 158 | public static class DnsException extends Exception { |
| 159 | /** |
| 160 | * DNS error code as one of the ERROR_* constants |
| 161 | */ |
| 162 | @DnsError public final int code; |
Luke Huang | 304491d | 2019-03-04 17:08:03 +0800 | [diff] [blame] | 163 | |
Luke Huang | ec21447 | 2019-04-11 17:54:41 -0700 | [diff] [blame] | 164 | DnsException(@DnsError int code, @Nullable Throwable cause) { |
| 165 | super(cause); |
| 166 | this.code = code; |
Luke Huang | 304491d | 2019-03-04 17:08:03 +0800 | [diff] [blame] | 167 | } |
| 168 | } |
| 169 | |
| 170 | /** |
Luke Huang | e4c7913 | 2019-03-07 19:01:26 +0800 | [diff] [blame] | 171 | * Send a raw DNS query. |
Luke Huang | ec21447 | 2019-04-11 17:54:41 -0700 | [diff] [blame] | 172 | * The answer will be provided asynchronously through the provided {@link Callback}. |
Luke Huang | 00b15f3 | 2019-01-04 19:56:29 +0800 | [diff] [blame] | 173 | * |
Luke Huang | e9b2bba | 2019-03-28 13:56:31 +0800 | [diff] [blame] | 174 | * @param network {@link Network} specifying which network to query on. |
Luke Huang | 00b15f3 | 2019-01-04 19:56:29 +0800 | [diff] [blame] | 175 | * {@code null} for query on default network. |
Luke Huang | e9b2bba | 2019-03-28 13:56:31 +0800 | [diff] [blame] | 176 | * @param query blob message to query |
Luke Huang | 00b15f3 | 2019-01-04 19:56:29 +0800 | [diff] [blame] | 177 | * @param flags flags as a combination of the FLAGS_* constants |
Luke Huang | e4c7913 | 2019-03-07 19:01:26 +0800 | [diff] [blame] | 178 | * @param executor The {@link Executor} that the callback should be executed on. |
Luke Huang | c09f2d6 | 2019-03-08 14:48:59 +0800 | [diff] [blame] | 179 | * @param cancellationSignal used by the caller to signal if the query should be |
| 180 | * cancelled. May be {@code null}. |
Luke Huang | ec21447 | 2019-04-11 17:54:41 -0700 | [diff] [blame] | 181 | * @param callback a {@link Callback} which will be called to notify the caller |
Luke Huang | c09f2d6 | 2019-03-08 14:48:59 +0800 | [diff] [blame] | 182 | * of the result of dns query. |
Luke Huang | 00b15f3 | 2019-01-04 19:56:29 +0800 | [diff] [blame] | 183 | */ |
Luke Huang | ec21447 | 2019-04-11 17:54:41 -0700 | [diff] [blame] | 184 | public void rawQuery(@Nullable Network network, @NonNull byte[] query, @QueryFlag int flags, |
Luke Huang | c09f2d6 | 2019-03-08 14:48:59 +0800 | [diff] [blame] | 185 | @NonNull @CallbackExecutor Executor executor, |
| 186 | @Nullable CancellationSignal cancellationSignal, |
Luke Huang | ec21447 | 2019-04-11 17:54:41 -0700 | [diff] [blame] | 187 | @NonNull Callback<? super byte[]> callback) { |
Luke Huang | c09f2d6 | 2019-03-08 14:48:59 +0800 | [diff] [blame] | 188 | if (cancellationSignal != null && cancellationSignal.isCanceled()) { |
| 189 | return; |
| 190 | } |
Luke Huang | 5386f49 | 2019-03-26 15:50:10 +0800 | [diff] [blame] | 191 | final Object lock = new Object(); |
Luke Huang | 304491d | 2019-03-04 17:08:03 +0800 | [diff] [blame] | 192 | final FileDescriptor queryfd; |
| 193 | try { |
Luke Huang | 7466ac8d | 2019-05-23 06:14:28 -0700 | [diff] [blame] | 194 | queryfd = resNetworkSend((network != null) |
| 195 | ? network.getNetIdForResolv() : NETID_UNSET, query, query.length, flags); |
Luke Huang | 304491d | 2019-03-04 17:08:03 +0800 | [diff] [blame] | 196 | } catch (ErrnoException e) { |
Luke Huang | ec21447 | 2019-04-11 17:54:41 -0700 | [diff] [blame] | 197 | executor.execute(() -> callback.onError(new DnsException(ERROR_SYSTEM, e))); |
Luke Huang | 304491d | 2019-03-04 17:08:03 +0800 | [diff] [blame] | 198 | return; |
| 199 | } |
| 200 | |
Luke Huang | 5bf7aa2 | 2019-03-29 18:01:11 +0800 | [diff] [blame] | 201 | synchronized (lock) { |
| 202 | registerFDListener(executor, queryfd, callback, cancellationSignal, lock); |
| 203 | if (cancellationSignal == null) return; |
| 204 | addCancellationSignal(cancellationSignal, queryfd, lock); |
| 205 | } |
Luke Huang | 00b15f3 | 2019-01-04 19:56:29 +0800 | [diff] [blame] | 206 | } |
| 207 | |
| 208 | /** |
Luke Huang | e4c7913 | 2019-03-07 19:01:26 +0800 | [diff] [blame] | 209 | * Send a DNS query with the specified name, class and query type. |
Luke Huang | ec21447 | 2019-04-11 17:54:41 -0700 | [diff] [blame] | 210 | * The answer will be provided asynchronously through the provided {@link Callback}. |
Luke Huang | 00b15f3 | 2019-01-04 19:56:29 +0800 | [diff] [blame] | 211 | * |
Luke Huang | e9b2bba | 2019-03-28 13:56:31 +0800 | [diff] [blame] | 212 | * @param network {@link Network} specifying which network to query on. |
Luke Huang | 00b15f3 | 2019-01-04 19:56:29 +0800 | [diff] [blame] | 213 | * {@code null} for query on default network. |
Luke Huang | e9b2bba | 2019-03-28 13:56:31 +0800 | [diff] [blame] | 214 | * @param domain domain name to query |
Luke Huang | 00b15f3 | 2019-01-04 19:56:29 +0800 | [diff] [blame] | 215 | * @param nsClass dns class as one of the CLASS_* constants |
| 216 | * @param nsType dns resource record (RR) type as one of the TYPE_* constants |
| 217 | * @param flags flags as a combination of the FLAGS_* constants |
Luke Huang | e4c7913 | 2019-03-07 19:01:26 +0800 | [diff] [blame] | 218 | * @param executor The {@link Executor} that the callback should be executed on. |
Luke Huang | c09f2d6 | 2019-03-08 14:48:59 +0800 | [diff] [blame] | 219 | * @param cancellationSignal used by the caller to signal if the query should be |
| 220 | * cancelled. May be {@code null}. |
Luke Huang | ec21447 | 2019-04-11 17:54:41 -0700 | [diff] [blame] | 221 | * @param callback a {@link Callback} which will be called to notify the caller |
Luke Huang | c09f2d6 | 2019-03-08 14:48:59 +0800 | [diff] [blame] | 222 | * of the result of dns query. |
Luke Huang | 00b15f3 | 2019-01-04 19:56:29 +0800 | [diff] [blame] | 223 | */ |
Luke Huang | ec21447 | 2019-04-11 17:54:41 -0700 | [diff] [blame] | 224 | public void rawQuery(@Nullable Network network, @NonNull String domain, |
Luke Huang | 304491d | 2019-03-04 17:08:03 +0800 | [diff] [blame] | 225 | @QueryClass int nsClass, @QueryType int nsType, @QueryFlag int flags, |
Luke Huang | c09f2d6 | 2019-03-08 14:48:59 +0800 | [diff] [blame] | 226 | @NonNull @CallbackExecutor Executor executor, |
| 227 | @Nullable CancellationSignal cancellationSignal, |
Luke Huang | ec21447 | 2019-04-11 17:54:41 -0700 | [diff] [blame] | 228 | @NonNull Callback<? super byte[]> callback) { |
Luke Huang | c09f2d6 | 2019-03-08 14:48:59 +0800 | [diff] [blame] | 229 | if (cancellationSignal != null && cancellationSignal.isCanceled()) { |
| 230 | return; |
| 231 | } |
Luke Huang | 5386f49 | 2019-03-26 15:50:10 +0800 | [diff] [blame] | 232 | final Object lock = new Object(); |
Luke Huang | 304491d | 2019-03-04 17:08:03 +0800 | [diff] [blame] | 233 | final FileDescriptor queryfd; |
| 234 | try { |
Luke Huang | 7466ac8d | 2019-05-23 06:14:28 -0700 | [diff] [blame] | 235 | queryfd = resNetworkQuery((network != null) |
| 236 | ? network.getNetIdForResolv() : NETID_UNSET, domain, nsClass, nsType, flags); |
Luke Huang | 304491d | 2019-03-04 17:08:03 +0800 | [diff] [blame] | 237 | } catch (ErrnoException e) { |
Luke Huang | ec21447 | 2019-04-11 17:54:41 -0700 | [diff] [blame] | 238 | executor.execute(() -> callback.onError(new DnsException(ERROR_SYSTEM, e))); |
Luke Huang | 304491d | 2019-03-04 17:08:03 +0800 | [diff] [blame] | 239 | return; |
| 240 | } |
Luke Huang | 5bf7aa2 | 2019-03-29 18:01:11 +0800 | [diff] [blame] | 241 | synchronized (lock) { |
| 242 | registerFDListener(executor, queryfd, callback, cancellationSignal, lock); |
| 243 | if (cancellationSignal == null) return; |
| 244 | addCancellationSignal(cancellationSignal, queryfd, lock); |
| 245 | } |
Luke Huang | e9b2bba | 2019-03-28 13:56:31 +0800 | [diff] [blame] | 246 | } |
| 247 | |
Luke Huang | ec21447 | 2019-04-11 17:54:41 -0700 | [diff] [blame] | 248 | private class InetAddressAnswerAccumulator implements Callback<byte[]> { |
Luke Huang | e9b2bba | 2019-03-28 13:56:31 +0800 | [diff] [blame] | 249 | private final List<InetAddress> mAllAnswers; |
Luke Huang | 7466ac8d | 2019-05-23 06:14:28 -0700 | [diff] [blame] | 250 | private final Network mNetwork; |
Luke Huang | ec21447 | 2019-04-11 17:54:41 -0700 | [diff] [blame] | 251 | private int mRcode; |
| 252 | private DnsException mDnsException; |
| 253 | private final Callback<? super List<InetAddress>> mUserCallback; |
Luke Huang | e9b2bba | 2019-03-28 13:56:31 +0800 | [diff] [blame] | 254 | private final int mTargetAnswerCount; |
| 255 | private int mReceivedAnswerCount = 0; |
| 256 | |
Luke Huang | 7466ac8d | 2019-05-23 06:14:28 -0700 | [diff] [blame] | 257 | InetAddressAnswerAccumulator(@NonNull Network network, int size, |
Luke Huang | ec21447 | 2019-04-11 17:54:41 -0700 | [diff] [blame] | 258 | @NonNull Callback<? super List<InetAddress>> callback) { |
Luke Huang | 7466ac8d | 2019-05-23 06:14:28 -0700 | [diff] [blame] | 259 | mNetwork = network; |
Luke Huang | e9b2bba | 2019-03-28 13:56:31 +0800 | [diff] [blame] | 260 | mTargetAnswerCount = size; |
| 261 | mAllAnswers = new ArrayList<>(); |
| 262 | mUserCallback = callback; |
| 263 | } |
| 264 | |
Luke Huang | ec21447 | 2019-04-11 17:54:41 -0700 | [diff] [blame] | 265 | private boolean maybeReportError() { |
| 266 | if (mRcode != 0) { |
| 267 | mUserCallback.onAnswer(mAllAnswers, mRcode); |
Luke Huang | e9b2bba | 2019-03-28 13:56:31 +0800 | [diff] [blame] | 268 | return true; |
| 269 | } |
Luke Huang | ec21447 | 2019-04-11 17:54:41 -0700 | [diff] [blame] | 270 | if (mDnsException != null) { |
| 271 | mUserCallback.onError(mDnsException); |
Luke Huang | e9b2bba | 2019-03-28 13:56:31 +0800 | [diff] [blame] | 272 | return true; |
| 273 | } |
| 274 | return false; |
| 275 | } |
| 276 | |
| 277 | private void maybeReportAnswer() { |
| 278 | if (++mReceivedAnswerCount != mTargetAnswerCount) return; |
Luke Huang | ec21447 | 2019-04-11 17:54:41 -0700 | [diff] [blame] | 279 | if (mAllAnswers.isEmpty() && maybeReportError()) return; |
Luke Huang | 7466ac8d | 2019-05-23 06:14:28 -0700 | [diff] [blame] | 280 | mUserCallback.onAnswer(rfc6724Sort(mNetwork, mAllAnswers), mRcode); |
Luke Huang | e9b2bba | 2019-03-28 13:56:31 +0800 | [diff] [blame] | 281 | } |
| 282 | |
| 283 | @Override |
Luke Huang | ec21447 | 2019-04-11 17:54:41 -0700 | [diff] [blame] | 284 | public void onAnswer(@NonNull byte[] answer, int rcode) { |
| 285 | // If at least one query succeeded, return an rcode of 0. |
| 286 | // Otherwise, arbitrarily return the first rcode received. |
| 287 | if (mReceivedAnswerCount == 0 || rcode == 0) { |
| 288 | mRcode = rcode; |
| 289 | } |
| 290 | try { |
| 291 | mAllAnswers.addAll(new DnsAddressAnswer(answer).getAddresses()); |
| 292 | } catch (ParseException e) { |
| 293 | mDnsException = new DnsException(ERROR_PARSE, e); |
| 294 | } |
Luke Huang | e9b2bba | 2019-03-28 13:56:31 +0800 | [diff] [blame] | 295 | maybeReportAnswer(); |
| 296 | } |
| 297 | |
| 298 | @Override |
Luke Huang | ec21447 | 2019-04-11 17:54:41 -0700 | [diff] [blame] | 299 | public void onError(@NonNull DnsException error) { |
| 300 | mDnsException = error; |
Luke Huang | e9b2bba | 2019-03-28 13:56:31 +0800 | [diff] [blame] | 301 | maybeReportAnswer(); |
| 302 | } |
| 303 | } |
| 304 | |
| 305 | /** |
Luke Huang | ec21447 | 2019-04-11 17:54:41 -0700 | [diff] [blame] | 306 | * Send a DNS query with the specified name on a network with both IPv4 and IPv6, |
Luke Huang | 7466ac8d | 2019-05-23 06:14:28 -0700 | [diff] [blame] | 307 | * get back a set of InetAddresses with rfc6724 sorting style asynchronously. |
Luke Huang | ec21447 | 2019-04-11 17:54:41 -0700 | [diff] [blame] | 308 | * |
| 309 | * This method will examine the connection ability on given network, and query IPv4 |
| 310 | * and IPv6 if connection is available. |
| 311 | * |
| 312 | * If at least one query succeeded with valid answer, rcode will be 0 |
| 313 | * |
| 314 | * The answer will be provided asynchronously through the provided {@link Callback}. |
Luke Huang | e9b2bba | 2019-03-28 13:56:31 +0800 | [diff] [blame] | 315 | * |
| 316 | * @param network {@link Network} specifying which network to query on. |
| 317 | * {@code null} for query on default network. |
| 318 | * @param domain domain name to query |
| 319 | * @param flags flags as a combination of the FLAGS_* constants |
| 320 | * @param executor The {@link Executor} that the callback should be executed on. |
| 321 | * @param cancellationSignal used by the caller to signal if the query should be |
| 322 | * cancelled. May be {@code null}. |
Luke Huang | ec21447 | 2019-04-11 17:54:41 -0700 | [diff] [blame] | 323 | * @param callback a {@link Callback} which will be called to notify the |
Luke Huang | e9b2bba | 2019-03-28 13:56:31 +0800 | [diff] [blame] | 324 | * caller of the result of dns query. |
| 325 | */ |
| 326 | public void query(@Nullable Network network, @NonNull String domain, @QueryFlag int flags, |
| 327 | @NonNull @CallbackExecutor Executor executor, |
| 328 | @Nullable CancellationSignal cancellationSignal, |
Luke Huang | ec21447 | 2019-04-11 17:54:41 -0700 | [diff] [blame] | 329 | @NonNull Callback<? super List<InetAddress>> callback) { |
Luke Huang | e9b2bba | 2019-03-28 13:56:31 +0800 | [diff] [blame] | 330 | if (cancellationSignal != null && cancellationSignal.isCanceled()) { |
| 331 | return; |
| 332 | } |
| 333 | final Object lock = new Object(); |
Luke Huang | 7466ac8d | 2019-05-23 06:14:28 -0700 | [diff] [blame] | 334 | final Network queryNetwork; |
| 335 | try { |
| 336 | queryNetwork = (network != null) ? network : new Network(getDnsNetId()); |
| 337 | } catch (ErrnoException e) { |
| 338 | executor.execute(() -> callback.onError(new DnsException(ERROR_SYSTEM, e))); |
| 339 | return; |
| 340 | } |
| 341 | final boolean queryIpv6 = haveIpv6(queryNetwork); |
| 342 | final boolean queryIpv4 = haveIpv4(queryNetwork); |
| 343 | |
| 344 | // This can only happen if queryIpv4 and queryIpv6 are both false. |
| 345 | // This almost certainly means that queryNetwork does not exist or no longer exists. |
| 346 | if (!queryIpv6 && !queryIpv4) { |
| 347 | executor.execute(() -> callback.onError( |
| 348 | new DnsException(ERROR_SYSTEM, new ErrnoException("resNetworkQuery", ENONET)))); |
| 349 | return; |
| 350 | } |
Luke Huang | e9b2bba | 2019-03-28 13:56:31 +0800 | [diff] [blame] | 351 | |
| 352 | final FileDescriptor v4fd; |
| 353 | final FileDescriptor v6fd; |
| 354 | |
| 355 | int queryCount = 0; |
| 356 | |
| 357 | if (queryIpv6) { |
| 358 | try { |
Luke Huang | 7466ac8d | 2019-05-23 06:14:28 -0700 | [diff] [blame] | 359 | v6fd = resNetworkQuery(queryNetwork.getNetIdForResolv(), domain, CLASS_IN, |
| 360 | TYPE_AAAA, flags); |
Luke Huang | e9b2bba | 2019-03-28 13:56:31 +0800 | [diff] [blame] | 361 | } catch (ErrnoException e) { |
Luke Huang | ec21447 | 2019-04-11 17:54:41 -0700 | [diff] [blame] | 362 | executor.execute(() -> callback.onError(new DnsException(ERROR_SYSTEM, e))); |
Luke Huang | e9b2bba | 2019-03-28 13:56:31 +0800 | [diff] [blame] | 363 | return; |
| 364 | } |
| 365 | queryCount++; |
| 366 | } else v6fd = null; |
| 367 | |
Luke Huang | e9b2bba | 2019-03-28 13:56:31 +0800 | [diff] [blame] | 368 | // Avoiding gateways drop packets if queries are sent too close together |
| 369 | try { |
Luke Huang | 5bf7aa2 | 2019-03-29 18:01:11 +0800 | [diff] [blame] | 370 | Thread.sleep(SLEEP_TIME_MS); |
Luke Huang | ec21447 | 2019-04-11 17:54:41 -0700 | [diff] [blame] | 371 | } catch (InterruptedException ex) { |
| 372 | Thread.currentThread().interrupt(); |
| 373 | } |
Luke Huang | e9b2bba | 2019-03-28 13:56:31 +0800 | [diff] [blame] | 374 | |
| 375 | if (queryIpv4) { |
| 376 | try { |
Luke Huang | 7466ac8d | 2019-05-23 06:14:28 -0700 | [diff] [blame] | 377 | v4fd = resNetworkQuery(queryNetwork.getNetIdForResolv(), domain, CLASS_IN, TYPE_A, |
| 378 | flags); |
Luke Huang | e9b2bba | 2019-03-28 13:56:31 +0800 | [diff] [blame] | 379 | } catch (ErrnoException e) { |
| 380 | if (queryIpv6) resNetworkCancel(v6fd); // Closes fd, marks it invalid. |
Luke Huang | ec21447 | 2019-04-11 17:54:41 -0700 | [diff] [blame] | 381 | executor.execute(() -> callback.onError(new DnsException(ERROR_SYSTEM, e))); |
Luke Huang | e9b2bba | 2019-03-28 13:56:31 +0800 | [diff] [blame] | 382 | return; |
| 383 | } |
| 384 | queryCount++; |
| 385 | } else v4fd = null; |
| 386 | |
| 387 | final InetAddressAnswerAccumulator accumulator = |
Luke Huang | 7466ac8d | 2019-05-23 06:14:28 -0700 | [diff] [blame] | 388 | new InetAddressAnswerAccumulator(queryNetwork, queryCount, callback); |
Luke Huang | e9b2bba | 2019-03-28 13:56:31 +0800 | [diff] [blame] | 389 | |
Luke Huang | 5bf7aa2 | 2019-03-29 18:01:11 +0800 | [diff] [blame] | 390 | synchronized (lock) { |
| 391 | if (queryIpv6) { |
| 392 | registerFDListener(executor, v6fd, accumulator, cancellationSignal, lock); |
Luke Huang | e9b2bba | 2019-03-28 13:56:31 +0800 | [diff] [blame] | 393 | } |
Luke Huang | 5bf7aa2 | 2019-03-29 18:01:11 +0800 | [diff] [blame] | 394 | if (queryIpv4) { |
| 395 | registerFDListener(executor, v4fd, accumulator, cancellationSignal, lock); |
| 396 | } |
| 397 | if (cancellationSignal == null) return; |
| 398 | cancellationSignal.setOnCancelListener(() -> { |
| 399 | synchronized (lock) { |
| 400 | if (queryIpv4) cancelQuery(v4fd); |
| 401 | if (queryIpv6) cancelQuery(v6fd); |
| 402 | } |
| 403 | }); |
| 404 | } |
Luke Huang | 00b15f3 | 2019-01-04 19:56:29 +0800 | [diff] [blame] | 405 | } |
| 406 | |
Luke Huang | ec21447 | 2019-04-11 17:54:41 -0700 | [diff] [blame] | 407 | /** |
| 408 | * Send a DNS query with the specified name and query type, get back a set of |
Luke Huang | 7466ac8d | 2019-05-23 06:14:28 -0700 | [diff] [blame] | 409 | * InetAddresses with rfc6724 sorting style asynchronously. |
Luke Huang | ec21447 | 2019-04-11 17:54:41 -0700 | [diff] [blame] | 410 | * |
| 411 | * The answer will be provided asynchronously through the provided {@link Callback}. |
| 412 | * |
| 413 | * @param network {@link Network} specifying which network to query on. |
| 414 | * {@code null} for query on default network. |
| 415 | * @param domain domain name to query |
| 416 | * @param nsType dns resource record (RR) type as one of the TYPE_* constants |
| 417 | * @param flags flags as a combination of the FLAGS_* constants |
| 418 | * @param executor The {@link Executor} that the callback should be executed on. |
| 419 | * @param cancellationSignal used by the caller to signal if the query should be |
| 420 | * cancelled. May be {@code null}. |
| 421 | * @param callback a {@link Callback} which will be called to notify the caller |
| 422 | * of the result of dns query. |
| 423 | */ |
| 424 | public void query(@Nullable Network network, @NonNull String domain, |
| 425 | @QueryType int nsType, @QueryFlag int flags, |
| 426 | @NonNull @CallbackExecutor Executor executor, |
| 427 | @Nullable CancellationSignal cancellationSignal, |
| 428 | @NonNull Callback<? super List<InetAddress>> callback) { |
| 429 | if (cancellationSignal != null && cancellationSignal.isCanceled()) { |
| 430 | return; |
| 431 | } |
| 432 | final Object lock = new Object(); |
| 433 | final FileDescriptor queryfd; |
Luke Huang | 7466ac8d | 2019-05-23 06:14:28 -0700 | [diff] [blame] | 434 | final Network queryNetwork; |
Luke Huang | ec21447 | 2019-04-11 17:54:41 -0700 | [diff] [blame] | 435 | try { |
Luke Huang | 7466ac8d | 2019-05-23 06:14:28 -0700 | [diff] [blame] | 436 | queryNetwork = (network != null) ? network : new Network(getDnsNetId()); |
| 437 | queryfd = resNetworkQuery(queryNetwork.getNetIdForResolv(), domain, CLASS_IN, nsType, |
| 438 | flags); |
Luke Huang | ec21447 | 2019-04-11 17:54:41 -0700 | [diff] [blame] | 439 | } catch (ErrnoException e) { |
| 440 | executor.execute(() -> callback.onError(new DnsException(ERROR_SYSTEM, e))); |
| 441 | return; |
| 442 | } |
| 443 | final InetAddressAnswerAccumulator accumulator = |
Luke Huang | 7466ac8d | 2019-05-23 06:14:28 -0700 | [diff] [blame] | 444 | new InetAddressAnswerAccumulator(queryNetwork, 1, callback); |
Luke Huang | ec21447 | 2019-04-11 17:54:41 -0700 | [diff] [blame] | 445 | synchronized (lock) { |
| 446 | registerFDListener(executor, queryfd, accumulator, cancellationSignal, lock); |
| 447 | if (cancellationSignal == null) return; |
| 448 | addCancellationSignal(cancellationSignal, queryfd, lock); |
| 449 | } |
| 450 | } |
| 451 | |
| 452 | /** |
| 453 | * Class to retrieve DNS response |
| 454 | * |
| 455 | * @hide |
| 456 | */ |
| 457 | public static final class DnsResponse { |
| 458 | public final @NonNull byte[] answerbuf; |
| 459 | public final int rcode; |
| 460 | public DnsResponse(@NonNull byte[] answerbuf, int rcode) { |
| 461 | this.answerbuf = answerbuf; |
| 462 | this.rcode = rcode; |
| 463 | } |
| 464 | } |
| 465 | |
| 466 | private void registerFDListener(@NonNull Executor executor, |
| 467 | @NonNull FileDescriptor queryfd, @NonNull Callback<? super byte[]> answerCallback, |
Luke Huang | 5386f49 | 2019-03-26 15:50:10 +0800 | [diff] [blame] | 468 | @Nullable CancellationSignal cancellationSignal, @NonNull Object lock) { |
Luke Huang | e4c7913 | 2019-03-07 19:01:26 +0800 | [diff] [blame] | 469 | Looper.getMainLooper().getQueue().addOnFileDescriptorEventListener( |
Luke Huang | 00b15f3 | 2019-01-04 19:56:29 +0800 | [diff] [blame] | 470 | queryfd, |
| 471 | FD_EVENTS, |
| 472 | (fd, events) -> { |
Luke Huang | e4c7913 | 2019-03-07 19:01:26 +0800 | [diff] [blame] | 473 | executor.execute(() -> { |
Luke Huang | ec21447 | 2019-04-11 17:54:41 -0700 | [diff] [blame] | 474 | DnsResponse resp = null; |
| 475 | ErrnoException exception = null; |
Luke Huang | 5386f49 | 2019-03-26 15:50:10 +0800 | [diff] [blame] | 476 | synchronized (lock) { |
| 477 | if (cancellationSignal != null && cancellationSignal.isCanceled()) { |
| 478 | return; |
| 479 | } |
Luke Huang | 5386f49 | 2019-03-26 15:50:10 +0800 | [diff] [blame] | 480 | try { |
Luke Huang | ec21447 | 2019-04-11 17:54:41 -0700 | [diff] [blame] | 481 | resp = resNetworkResult(fd); // Closes fd, marks it invalid. |
Luke Huang | 5386f49 | 2019-03-26 15:50:10 +0800 | [diff] [blame] | 482 | } catch (ErrnoException e) { |
| 483 | Log.e(TAG, "resNetworkResult:" + e.toString()); |
Luke Huang | ec21447 | 2019-04-11 17:54:41 -0700 | [diff] [blame] | 484 | exception = e; |
Luke Huang | 5386f49 | 2019-03-26 15:50:10 +0800 | [diff] [blame] | 485 | } |
Luke Huang | e4c7913 | 2019-03-07 19:01:26 +0800 | [diff] [blame] | 486 | } |
Luke Huang | ec21447 | 2019-04-11 17:54:41 -0700 | [diff] [blame] | 487 | if (exception != null) { |
| 488 | answerCallback.onError(new DnsException(ERROR_SYSTEM, exception)); |
| 489 | return; |
| 490 | } |
| 491 | answerCallback.onAnswer(resp.answerbuf, resp.rcode); |
Luke Huang | e4c7913 | 2019-03-07 19:01:26 +0800 | [diff] [blame] | 492 | }); |
Luke Huang | 00b15f3 | 2019-01-04 19:56:29 +0800 | [diff] [blame] | 493 | // Unregister this fd listener |
| 494 | return 0; |
| 495 | }); |
| 496 | } |
| 497 | |
Luke Huang | e9b2bba | 2019-03-28 13:56:31 +0800 | [diff] [blame] | 498 | private void cancelQuery(@NonNull FileDescriptor queryfd) { |
| 499 | if (!queryfd.valid()) return; |
| 500 | Looper.getMainLooper().getQueue().removeOnFileDescriptorEventListener(queryfd); |
| 501 | resNetworkCancel(queryfd); // Closes fd, marks it invalid. |
| 502 | } |
| 503 | |
Luke Huang | 5bf7aa2 | 2019-03-29 18:01:11 +0800 | [diff] [blame] | 504 | private void addCancellationSignal(@NonNull CancellationSignal cancellationSignal, |
Luke Huang | 5386f49 | 2019-03-26 15:50:10 +0800 | [diff] [blame] | 505 | @NonNull FileDescriptor queryfd, @NonNull Object lock) { |
Luke Huang | 5386f49 | 2019-03-26 15:50:10 +0800 | [diff] [blame] | 506 | cancellationSignal.setOnCancelListener(() -> { |
| 507 | synchronized (lock) { |
Luke Huang | e9b2bba | 2019-03-28 13:56:31 +0800 | [diff] [blame] | 508 | cancelQuery(queryfd); |
Luke Huang | 5386f49 | 2019-03-26 15:50:10 +0800 | [diff] [blame] | 509 | } |
| 510 | }); |
Luke Huang | c09f2d6 | 2019-03-08 14:48:59 +0800 | [diff] [blame] | 511 | } |
| 512 | |
Luke Huang | 304491d | 2019-03-04 17:08:03 +0800 | [diff] [blame] | 513 | private static class DnsAddressAnswer extends DnsPacket { |
Luke Huang | 00b15f3 | 2019-01-04 19:56:29 +0800 | [diff] [blame] | 514 | private static final String TAG = "DnsResolver.DnsAddressAnswer"; |
| 515 | private static final boolean DBG = false; |
| 516 | |
| 517 | private final int mQueryType; |
| 518 | |
| 519 | DnsAddressAnswer(@NonNull byte[] data) throws ParseException { |
| 520 | super(data); |
| 521 | if ((mHeader.flags & (1 << 15)) == 0) { |
| 522 | throw new ParseException("Not an answer packet"); |
| 523 | } |
Luke Huang | 33bfef3 | 2019-01-23 21:53:13 +0800 | [diff] [blame] | 524 | if (mHeader.getRecordCount(QDSECTION) == 0) { |
Luke Huang | 00b15f3 | 2019-01-04 19:56:29 +0800 | [diff] [blame] | 525 | throw new ParseException("No question found"); |
| 526 | } |
Luke Huang | 33bfef3 | 2019-01-23 21:53:13 +0800 | [diff] [blame] | 527 | // Expect only one question in question section. |
| 528 | mQueryType = mRecords[QDSECTION].get(0).nsType; |
Luke Huang | 00b15f3 | 2019-01-04 19:56:29 +0800 | [diff] [blame] | 529 | } |
| 530 | |
| 531 | public @NonNull List<InetAddress> getAddresses() { |
| 532 | final List<InetAddress> results = new ArrayList<InetAddress>(); |
Luke Huang | 304491d | 2019-03-04 17:08:03 +0800 | [diff] [blame] | 533 | if (mHeader.getRecordCount(ANSECTION) == 0) return results; |
| 534 | |
Luke Huang | 33bfef3 | 2019-01-23 21:53:13 +0800 | [diff] [blame] | 535 | for (final DnsRecord ansSec : mRecords[ANSECTION]) { |
Luke Huang | 00b15f3 | 2019-01-04 19:56:29 +0800 | [diff] [blame] | 536 | // Only support A and AAAA, also ignore answers if query type != answer type. |
| 537 | int nsType = ansSec.nsType; |
| 538 | if (nsType != mQueryType || (nsType != TYPE_A && nsType != TYPE_AAAA)) { |
| 539 | continue; |
| 540 | } |
| 541 | try { |
| 542 | results.add(InetAddress.getByAddress(ansSec.getRR())); |
| 543 | } catch (UnknownHostException e) { |
| 544 | if (DBG) { |
| 545 | Log.w(TAG, "rr to address fail"); |
| 546 | } |
| 547 | } |
| 548 | } |
| 549 | return results; |
| 550 | } |
| 551 | } |
| 552 | |
Luke Huang | 00b15f3 | 2019-01-04 19:56:29 +0800 | [diff] [blame] | 553 | } |