• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (C) 2018 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 #ifndef _DNS_DNSTLSQUERYMAP_H
18 #define _DNS_DNSTLSQUERYMAP_H
19 
20 #include <future>
21 #include <map>
22 #include <mutex>
23 #include <vector>
24 
25 #include <android-base/thread_annotations.h>
26 #include <netdutils/Slice.h>
27 
28 #include "DnsTlsServer.h"
29 
30 namespace android {
31 namespace net {
32 
33 // Keeps track of queries and responses.  This class matches responses with queries.
34 // All methods are thread-safe and non-blocking.
35 class DnsTlsQueryMap {
36   public:
37     enum class Response : uint8_t { success, network_error, limit_error, internal_error };
38 
39     DnsTlsQueryMap();
40 
41     struct Query {
42         // The new ID number assigned to this query.
43         uint16_t newId;
44         // A query that has been passed to recordQuery(), with its original ID number.
45         const std::vector<uint8_t> query;
46     };
47 
48     struct Result {
49         Response code;
50         std::vector<uint8_t> response;
51     };
52 
53     struct QueryFuture {
QueryFutureQueryFuture54         QueryFuture(Query query, std::future<Result> result)
55             : query(query), result(std::move(result)) {}
56         Query query;
57         // A future which will resolve to the result of this query.
58         std::future<Result> result;
59     };
60 
61     // Returns an object containing everything needed to complete processing of
62     // this query, or null if the query could not be recorded.
63     std::unique_ptr<QueryFuture> recordQuery(const netdutils::Slice query);
64 
65     // Process a response, including a new ID.  If the response
66     // is not recognized as matching any query, it will be ignored.
67     void onResponse(std::vector<uint8_t> response);
68 
69     // Clear all map contents.  This causes all pending queries to resolve with failure.
70     void clear();
71 
72     // Get all pending queries.  This returns a shallow copy, mostly for thread-safety.
73     std::vector<Query> getAll();
74 
75     // Mark a query has having been retried.  If the query hits the retry limit, it will
76     // be expired at the next call to cleanup.
77     void markTried(uint16_t newId);
78     void cleanup();
79 
80     // Returns true if there are no pending queries.
81     bool empty();
82 
83     // The maximum number of times we will send a query before abandoning it.
84     static constexpr int kMaxTries = 3;
85     int mMaxTries;
86 
87   private:
88     std::mutex mLock;
89 
90     struct QueryPromise {
QueryPromiseQueryPromise91         QueryPromise(Query query) : query(query) {}
92         Query query;
93         // Number of times the query has been tried.  Limited to kMaxTries.
94         int tries = 0;
95         // A promise whose future is returned by recordQuery()
96         // It is fulfilled by onResponse().
97         std::promise<Result> result;
98     };
99 
100     // Outstanding queries by newId.
101     std::map<uint16_t, QueryPromise> mQueries GUARDED_BY(mLock);
102 
103     // Get a "newId" number that is not currently in use.  Returns -1 if there are none.
104     int32_t getFreeId() REQUIRES(mLock);
105 
106     // Fulfill the result with an error code.
107     static void expire(QueryPromise* _Nonnull p);
108 };
109 
110 }  // end of namespace net
111 }  // end of namespace android
112 
113 #endif  // _DNS_DNSTLSQUERYMAP_H
114