1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
|
// Copyright (c) 2012 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef NET_DNS_HOST_RESOLVER_PROC_H_
#define NET_DNS_HOST_RESOLVER_PROC_H_
#include <string>
#include "base/macros.h"
#include "base/memory/ref_counted.h"
#include "base/time/time.h"
#include "net/base/address_family.h"
#include "net/base/net_export.h"
namespace net {
class AddressList;
// Interface for a getaddrinfo()-like procedure. This is used by unit-tests
// to control the underlying resolutions in HostResolverManager.
// HostResolverProcs can be chained together; they fallback to the next
// procedure in the chain by calling ResolveUsingPrevious().
//
// Note that implementations of HostResolverProc *MUST BE THREADSAFE*, since
// the HostResolver implementation using them can be multi-threaded.
class NET_EXPORT HostResolverProc
: public base::RefCountedThreadSafe<HostResolverProc> {
public:
explicit HostResolverProc(HostResolverProc* previous);
// Resolves |host| to an address list, restricting the results to addresses
// in |address_family|. If successful returns OK and fills |addrlist| with
// a list of socket addresses. Otherwise returns a network error code, and
// fills |os_error| with a more specific error if it was non-NULL.
virtual int Resolve(const std::string& host,
AddressFamily address_family,
HostResolverFlags host_resolver_flags,
AddressList* addrlist,
int* os_error) = 0;
protected:
friend class base::RefCountedThreadSafe<HostResolverProc>;
virtual ~HostResolverProc();
// Asks the fallback procedure (if set) to do the resolve.
int ResolveUsingPrevious(const std::string& host,
AddressFamily address_family,
HostResolverFlags host_resolver_flags,
AddressList* addrlist,
int* os_error);
private:
friend class HostResolverManager;
friend class MockHostResolverBase;
friend class ScopedDefaultHostResolverProc;
// Sets the previous procedure in the chain. Aborts if this would result in a
// cycle.
void SetPreviousProc(HostResolverProc* proc);
// Sets the last procedure in the chain, i.e. appends |proc| to the end of the
// current chain. Aborts if this would result in a cycle.
void SetLastProc(HostResolverProc* proc);
// Returns the last procedure in the chain starting at |proc|. Will return
// NULL iff |proc| is NULL.
static HostResolverProc* GetLastProc(HostResolverProc* proc);
// Sets the default host resolver procedure that is used by
// HostResolverManager. This can be used through ScopedDefaultHostResolverProc
// to set a catch-all DNS block in unit-tests (individual tests should use
// MockHostResolver to prevent hitting the network).
static HostResolverProc* SetDefault(HostResolverProc* proc);
static HostResolverProc* GetDefault();
scoped_refptr<HostResolverProc> previous_proc_;
static HostResolverProc* default_proc_;
DISALLOW_COPY_AND_ASSIGN(HostResolverProc);
};
// Resolves |host| to an address list, using the system's default host resolver.
// (i.e. this calls out to getaddrinfo()). If successful returns OK and fills
// |addrlist| with a list of socket addresses. Otherwise returns a
// network error code, and fills |os_error| with a more specific error if it
// was non-NULL.
NET_EXPORT_PRIVATE int SystemHostResolverCall(
const std::string& host,
AddressFamily address_family,
HostResolverFlags host_resolver_flags,
AddressList* addrlist,
int* os_error);
// Wraps call to SystemHostResolverCall as an instance of HostResolverProc.
class NET_EXPORT_PRIVATE SystemHostResolverProc : public HostResolverProc {
public:
SystemHostResolverProc();
int Resolve(const std::string& hostname,
AddressFamily address_family,
HostResolverFlags host_resolver_flags,
AddressList* addr_list,
int* os_error) override;
protected:
~SystemHostResolverProc() override;
DISALLOW_COPY_AND_ASSIGN(SystemHostResolverProc);
};
// Parameters for customizing HostResolverProc behavior in HostResolvers.
//
// |resolver_proc| is used to perform the actual resolves; it must be
// thread-safe since it may be run from multiple worker threads. If
// |resolver_proc| is NULL then the default host resolver procedure is
// used (which is SystemHostResolverProc except if overridden).
//
// For each attempt, we could start another attempt if host is not resolved
// within |unresponsive_delay| time. We keep attempting to resolve the host
// for |max_retry_attempts|. For every retry attempt, we grow the
// |unresponsive_delay| by the |retry_factor| amount (that is retry interval
// is multiplied by the retry factor each time). Once we have retried
// |max_retry_attempts|, we give up on additional attempts.
//
struct NET_EXPORT_PRIVATE ProcTaskParams {
// Default delay between calls to the system resolver for the same hostname.
// (Can be overridden by field trial.)
static const base::TimeDelta kDnsDefaultUnresponsiveDelay;
// Sets up defaults.
ProcTaskParams(HostResolverProc* resolver_proc, size_t max_retry_attempts);
ProcTaskParams(const ProcTaskParams& other);
~ProcTaskParams();
// The procedure to use for resolving host names. This will be NULL, except
// in the case of unit-tests which inject custom host resolving behaviors.
scoped_refptr<HostResolverProc> resolver_proc;
// Maximum number retry attempts to resolve the hostname.
// Pass HostResolver::Options::kDefaultRetryAttempts to choose a default
// value.
size_t max_retry_attempts;
// This is the limit after which we make another attempt to resolve the host
// if the worker thread has not responded yet.
base::TimeDelta unresponsive_delay;
// Factor to grow |unresponsive_delay| when we re-re-try.
uint32_t retry_factor;
};
} // namespace net
#endif // NET_DNS_HOST_RESOLVER_PROC_H_
|
