114 lines
3.3 KiB
C++
114 lines
3.3 KiB
C++
//
|
|
// Copyright (C) 2011 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 SHILL_DNS_CLIENT_H_
|
|
#define SHILL_DNS_CLIENT_H_
|
|
|
|
#include <memory>
|
|
#include <string>
|
|
#include <vector>
|
|
|
|
#include <base/callback.h>
|
|
#include <base/cancelable_callback.h>
|
|
#include <base/memory/weak_ptr.h>
|
|
#include <gtest/gtest_prod.h> // for FRIEND_TEST
|
|
|
|
#include "shill/error.h"
|
|
#include "shill/event_dispatcher.h"
|
|
#include "shill/net/ip_address.h"
|
|
#include "shill/refptr_types.h"
|
|
|
|
struct hostent;
|
|
|
|
namespace shill {
|
|
|
|
class Ares;
|
|
class Time;
|
|
struct DNSClientState;
|
|
|
|
// Implements a DNS resolution client that can run asynchronously.
|
|
class DNSClient {
|
|
public:
|
|
typedef base::Callback<void(const Error&, const IPAddress&)> ClientCallback;
|
|
|
|
static const char kErrorNoData[];
|
|
static const char kErrorFormErr[];
|
|
static const char kErrorServerFail[];
|
|
static const char kErrorNotFound[];
|
|
static const char kErrorNotImp[];
|
|
static const char kErrorRefused[];
|
|
static const char kErrorBadQuery[];
|
|
static const char kErrorNetRefused[];
|
|
static const char kErrorTimedOut[];
|
|
static const char kErrorUnknown[];
|
|
|
|
DNSClient(IPAddress::Family family,
|
|
const std::string& interface_name,
|
|
const std::vector<std::string>& dns_servers,
|
|
int timeout_ms,
|
|
EventDispatcher* dispatcher,
|
|
const ClientCallback& callback);
|
|
virtual ~DNSClient();
|
|
|
|
// Returns true if the DNS client started successfully, false otherwise.
|
|
// If successful, the callback will be called with the result of the
|
|
// request. If Start() fails and returns false, the callback will not
|
|
// be called, but the error that caused the failure will be returned in
|
|
// |error|.
|
|
virtual bool Start(const std::string& hostname, Error* error);
|
|
|
|
// Aborts any running DNS client transaction. This will cancel any callback
|
|
// invocation.
|
|
virtual void Stop();
|
|
|
|
virtual bool IsActive() const;
|
|
|
|
std::string interface_name() { return interface_name_; }
|
|
|
|
private:
|
|
friend class DNSClientTest;
|
|
|
|
void HandleCompletion();
|
|
void HandleDNSRead(int fd);
|
|
void HandleDNSWrite(int fd);
|
|
void HandleTimeout();
|
|
void ReceiveDNSReply(int status, struct hostent* hostent);
|
|
static void ReceiveDNSReplyCB(void* arg, int status, int timeouts,
|
|
struct hostent* hostent);
|
|
bool RefreshHandles();
|
|
|
|
static const int kDefaultDNSPort;
|
|
|
|
Error error_;
|
|
IPAddress address_;
|
|
std::string interface_name_;
|
|
std::vector<std::string> dns_servers_;
|
|
EventDispatcher* dispatcher_;
|
|
ClientCallback callback_;
|
|
int timeout_ms_;
|
|
bool running_;
|
|
std::unique_ptr<DNSClientState> resolver_state_;
|
|
base::CancelableClosure timeout_closure_;
|
|
base::WeakPtrFactory<DNSClient> weak_ptr_factory_;
|
|
Ares* ares_;
|
|
Time* time_;
|
|
|
|
DISALLOW_COPY_AND_ASSIGN(DNSClient);
|
|
};
|
|
|
|
} // namespace shill
|
|
|
|
#endif // SHILL_DNS_CLIENT_H_
|