| /* |
| * Copyright (C) 2017 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| #ifndef _DNS_DNSTLSDISPATCHER_H |
| #define _DNS_DNSTLSDISPATCHER_H |
| |
| #include <list> |
| #include <map> |
| #include <memory> |
| #include <mutex> |
| |
| #include <android-base/thread_annotations.h> |
| #include <netdutils/Slice.h> |
| |
| #include "DnsTlsServer.h" |
| #include "DnsTlsTransport.h" |
| #include "IDnsTlsSocketFactory.h" |
| |
| namespace android { |
| namespace net { |
| |
| // This is a singleton class that manages the collection of active DnsTlsTransports. |
| // Queries made here are dispatched to an existing or newly constructed DnsTlsTransport. |
| class DnsTlsDispatcher { |
| public: |
| // Default constructor. |
| DnsTlsDispatcher(); |
| |
| // Constructor with dependency injection for testing. |
| explicit DnsTlsDispatcher(std::unique_ptr<IDnsTlsSocketFactory> factory) |
| : mFactory(std::move(factory)) {} |
| |
| // Enqueues |query| for resolution via the given |tlsServers| on the |
| // network indicated by |mark|; writes the response into |ans|, and stores |
| // the count of bytes written in |resplen|. Returns a success or error code. |
| // The order in which servers from |tlsServers| are queried may not be the |
| // order passed in by the caller. |
| DnsTlsTransport::Response query(const std::list<DnsTlsServer>& tlsServers, unsigned mark, |
| const netdutils::Slice query, const netdutils::Slice ans, |
| int* _Nonnull resplen); |
| |
| // Given a |query|, sends it to the server on the network indicated by |mark|, |
| // and writes the response into |ans|, and indicates |
| // the number of bytes written in |resplen|. Returns a success or error code. |
| DnsTlsTransport::Response query(const DnsTlsServer& server, unsigned mark, |
| const netdutils::Slice query, const netdutils::Slice ans, |
| int* _Nonnull resplen); |
| |
| private: |
| // This lock is static so that it can be used to annotate the Transport struct. |
| // DnsTlsDispatcher is a singleton in practice, so making this static does not change |
| // the locking behavior. |
| static std::mutex sLock; |
| |
| // Key = <mark, server> |
| typedef std::pair<unsigned, const DnsTlsServer> Key; |
| |
| // Transport is a thin wrapper around DnsTlsTransport, adding reference counting and |
| // usage monitoring so we can expire idle sessions from the cache. |
| struct Transport { |
| Transport(const DnsTlsServer& server, unsigned mark, IDnsTlsSocketFactory* _Nonnull factory) |
| : transport(server, mark, factory) {} |
| // DnsTlsTransport is thread-safe, so it doesn't need to be guarded. |
| DnsTlsTransport transport; |
| // This use counter and timestamp are used to ensure that only idle sessions are |
| // destroyed. |
| int useCount GUARDED_BY(sLock) = 0; |
| // lastUsed is only guaranteed to be meaningful after useCount is decremented to zero. |
| std::chrono::time_point<std::chrono::steady_clock> lastUsed GUARDED_BY(sLock); |
| }; |
| |
| // Cache of reusable DnsTlsTransports. Transports stay in cache as long as |
| // they are in use and for a few minutes after. |
| // The key is a (netid, server) pair. The netid is first for lexicographic comparison speed. |
| std::map<Key, std::unique_ptr<Transport>> mStore GUARDED_BY(sLock); |
| |
| // The last time we did a cleanup. For efficiency, we only perform a cleanup once every |
| // few minutes. |
| std::chrono::time_point<std::chrono::steady_clock> mLastCleanup GUARDED_BY(sLock); |
| |
| // Drop any cache entries whose useCount is zero and which have not been used recently. |
| // This function performs a linear scan of mStore. |
| void cleanup(std::chrono::time_point<std::chrono::steady_clock> now) REQUIRES(sLock); |
| |
| // Return a sorted list of DnsTlsServers in preference order. |
| std::list<DnsTlsServer> getOrderedServerList(const std::list<DnsTlsServer>& tlsServers, |
| unsigned mark) const; |
| |
| // Trivial factory for DnsTlsSockets. Dependency injection is only used for testing. |
| std::unique_ptr<IDnsTlsSocketFactory> mFactory; |
| }; |
| |
| } // end of namespace net |
| } // end of namespace android |
| |
| #endif // _DNS_DNSTLSDISPATCHER_H |