OLD | NEW |
(Empty) | |
| 1 // Copyright (c) 2011 The Chromium Authors. All rights reserved. |
| 2 // Use of this source code is governed by a BSD-style license that can be |
| 3 // found in the LICENSE file. |
| 4 |
| 5 #include "net/proxy/dhcp_proxy_script_fetcher_win.h" |
| 6 |
| 7 #include "net/base/net_errors.h" |
| 8 #include "net/proxy/dhcp_proxy_script_adapter_fetcher_win.h" |
| 9 |
| 10 #include <winsock2.h> |
| 11 #include <iphlpapi.h> |
| 12 #pragma comment(lib, "iphlpapi.lib") |
| 13 |
| 14 namespace { |
| 15 |
| 16 // How long to wait at maximum after we get results (a PAC file or |
| 17 // knowledge that no PAC file is configured) from whichever network |
| 18 // adapter finishes first. |
| 19 const int kMaxWaitAfterFirstResultMs = 400; |
| 20 |
| 21 } // namespace |
| 22 |
| 23 namespace net { |
| 24 |
| 25 DhcpProxyScriptFetcherWin::DhcpProxyScriptFetcherWin( |
| 26 URLRequestContext* url_request_context) |
| 27 : state_(STATE_START), |
| 28 ALLOW_THIS_IN_INITIALIZER_LIST(fetcher_callback_( |
| 29 this, &DhcpProxyScriptFetcherWin::OnFetcherDone)), |
| 30 num_pending_fetchers_(0), |
| 31 url_request_context_(url_request_context) { |
| 32 DCHECK(url_request_context_); |
| 33 } |
| 34 |
| 35 DhcpProxyScriptFetcherWin::~DhcpProxyScriptFetcherWin() { |
| 36 Cancel(); |
| 37 } |
| 38 |
| 39 int DhcpProxyScriptFetcherWin::Fetch(string16* utf16_text, |
| 40 CompletionCallback* callback) { |
| 41 DCHECK(CalledOnValidThread()); |
| 42 if (state_ != STATE_START && state_ != STATE_DONE) { |
| 43 NOTREACHED(); |
| 44 return ERR_UNEXPECTED; |
| 45 } |
| 46 |
| 47 std::set<std::string> adapter_names; |
| 48 if (!ImplGetCandidateAdapterNames(&adapter_names)) { |
| 49 return ERR_UNEXPECTED; |
| 50 } |
| 51 if (adapter_names.empty()) { |
| 52 return ERR_PAC_NOT_IN_DHCP; |
| 53 } |
| 54 |
| 55 state_ = STATE_NO_RESULTS; |
| 56 |
| 57 client_callback_ = callback; |
| 58 destination_string_ = utf16_text; |
| 59 |
| 60 for (std::set<std::string>::iterator it = adapter_names.begin(); |
| 61 it != adapter_names.end(); |
| 62 ++it) { |
| 63 DhcpProxyScriptAdapterFetcher* fetcher(ImplCreateAdapterFetcher()); |
| 64 fetcher->Fetch(*it, &fetcher_callback_); |
| 65 fetchers_.push_back(fetcher); |
| 66 } |
| 67 num_pending_fetchers_ = fetchers_.size(); |
| 68 |
| 69 return ERR_IO_PENDING; |
| 70 } |
| 71 |
| 72 void DhcpProxyScriptFetcherWin::Cancel() { |
| 73 DCHECK(CalledOnValidThread()); |
| 74 |
| 75 if (state_ != STATE_DONE) { |
| 76 wait_timer_.Stop(); |
| 77 state_ = STATE_DONE; |
| 78 |
| 79 for (FetcherVector::iterator it = fetchers_.begin(); |
| 80 it != fetchers_.end(); |
| 81 ++it) { |
| 82 (*it)->Cancel(); |
| 83 } |
| 84 |
| 85 fetchers_.reset(); |
| 86 } |
| 87 } |
| 88 |
| 89 std::string DhcpProxyScriptFetcherWin::GetFetcherName() const { |
| 90 DCHECK(CalledOnValidThread()); |
| 91 return "win"; |
| 92 } |
| 93 |
| 94 const GURL& DhcpProxyScriptFetcherWin::GetPacURL() const { |
| 95 DCHECK(CalledOnValidThread()); |
| 96 DCHECK_EQ(state_, STATE_DONE); |
| 97 |
| 98 return pac_url_; |
| 99 } |
| 100 |
| 101 void DhcpProxyScriptFetcherWin::OnFetcherDone(int result) { |
| 102 DCHECK(state_ == STATE_NO_RESULTS || state_ == STATE_SOME_RESULTS); |
| 103 |
| 104 if (--num_pending_fetchers_ == 0) { |
| 105 TransitionToDone(); |
| 106 return; |
| 107 } |
| 108 |
| 109 // If the only pending adapters are those less preferred than one |
| 110 // with a valid PAC script, we do not need to wait any longer. |
| 111 for (FetcherVector::iterator it = fetchers_.begin(); |
| 112 it != fetchers_.end(); |
| 113 ++it) { |
| 114 bool did_finish = (*it)->DidFinish(); |
| 115 int result = (*it)->GetResult(); |
| 116 if (did_finish && result == OK) { |
| 117 TransitionToDone(); |
| 118 return; |
| 119 } |
| 120 if (!did_finish || result != ERR_PAC_NOT_IN_DHCP) { |
| 121 break; |
| 122 } |
| 123 } |
| 124 |
| 125 // Once we have a single result, we set a maximum on how long to wait |
| 126 // for the rest of the results. |
| 127 if (state_ == STATE_NO_RESULTS) { |
| 128 state_ = STATE_SOME_RESULTS; |
| 129 wait_timer_.Start( |
| 130 base::TimeDelta::FromMilliseconds(ImplGetMaxWaitMs()), |
| 131 this, &DhcpProxyScriptFetcherWin::OnWaitTimer); |
| 132 } |
| 133 } |
| 134 |
| 135 void DhcpProxyScriptFetcherWin::OnWaitTimer() { |
| 136 DCHECK_EQ(state_, STATE_SOME_RESULTS); |
| 137 TransitionToDone(); |
| 138 } |
| 139 |
| 140 void DhcpProxyScriptFetcherWin::TransitionToDone() { |
| 141 DCHECK(state_ == STATE_NO_RESULTS || state_ == STATE_SOME_RESULTS); |
| 142 |
| 143 // Should have returned immediately at Fetch() if no adapters to check. |
| 144 DCHECK(!fetchers_.empty()); |
| 145 |
| 146 // Scan twice for the result; once through the whole list for success, |
| 147 // then if no success, return result for most preferred network adapter, |
| 148 // preferring "real" network errors to the ERR_PAC_NOT_IN_DHCP error. |
| 149 // Default to ERR_ABORTED if no fetcher completed. |
| 150 int result = ERR_ABORTED; |
| 151 for (FetcherVector::iterator it = fetchers_.begin(); |
| 152 it != fetchers_.end(); |
| 153 ++it) { |
| 154 if ((*it)->DidFinish() && (*it)->GetResult() == OK) { |
| 155 result = OK; |
| 156 *destination_string_ = (*it)->GetPacScript(); |
| 157 pac_url_ = (*it)->GetPacURL(); |
| 158 break; |
| 159 } |
| 160 } |
| 161 if (result != OK) { |
| 162 destination_string_->clear(); |
| 163 for (FetcherVector::iterator it = fetchers_.begin(); |
| 164 it != fetchers_.end(); |
| 165 ++it) { |
| 166 if ((*it)->DidFinish()) { |
| 167 result = (*it)->GetResult(); |
| 168 if (result != ERR_PAC_NOT_IN_DHCP) { |
| 169 break; |
| 170 } |
| 171 } |
| 172 } |
| 173 } |
| 174 |
| 175 Cancel(); |
| 176 DCHECK_EQ(state_, STATE_DONE); |
| 177 DCHECK(fetchers_.empty()); |
| 178 |
| 179 client_callback_->Run(result); |
| 180 } |
| 181 |
| 182 DhcpProxyScriptAdapterFetcher* |
| 183 DhcpProxyScriptFetcherWin::ImplCreateAdapterFetcher() { |
| 184 return new DhcpProxyScriptAdapterFetcher(url_request_context_); |
| 185 } |
| 186 |
| 187 bool DhcpProxyScriptFetcherWin::ImplGetCandidateAdapterNames( |
| 188 std::set<std::string>* adapter_names) { |
| 189 return GetCandidateAdapterNames(adapter_names); |
| 190 } |
| 191 |
| 192 int DhcpProxyScriptFetcherWin::ImplGetMaxWaitMs() { |
| 193 return kMaxWaitAfterFirstResultMs; |
| 194 } |
| 195 |
| 196 bool DhcpProxyScriptFetcherWin::GetCandidateAdapterNames( |
| 197 std::set<std::string>* adapter_names) { |
| 198 DCHECK(adapter_names); |
| 199 adapter_names->clear(); |
| 200 |
| 201 // The GetAdaptersAddresses MSDN page recommends using a size of 15000 to |
| 202 // avoid reallocation. |
| 203 ULONG adapters_size = 15000; |
| 204 scoped_ptr_malloc<IP_ADAPTER_ADDRESSES> adapters; |
| 205 ULONG error = ERROR_SUCCESS; |
| 206 int num_tries = 0; |
| 207 do { |
| 208 adapters.reset( |
| 209 reinterpret_cast<IP_ADAPTER_ADDRESSES*>(malloc(adapters_size))); |
| 210 // Return only unicast addresses, and skip information we do not need. |
| 211 error = GetAdaptersAddresses(AF_UNSPEC, |
| 212 GAA_FLAG_SKIP_ANYCAST | |
| 213 GAA_FLAG_SKIP_MULTICAST | |
| 214 GAA_FLAG_SKIP_DNS_SERVER | |
| 215 GAA_FLAG_SKIP_FRIENDLY_NAME, |
| 216 NULL, |
| 217 adapters.get(), |
| 218 &adapters_size); |
| 219 ++num_tries; |
| 220 } while (error == ERROR_BUFFER_OVERFLOW && num_tries <= 3); |
| 221 |
| 222 if (error == ERROR_NO_DATA) { |
| 223 // There are no adapters that we care about. |
| 224 return true; |
| 225 } |
| 226 |
| 227 if (error != ERROR_SUCCESS) { |
| 228 LOG(WARNING) << "Unexpected error retrieving WPAD configuration from DHCP."; |
| 229 return false; |
| 230 } |
| 231 |
| 232 IP_ADAPTER_ADDRESSES* adapter = NULL; |
| 233 for (adapter = adapters.get(); adapter; adapter = adapter->Next) { |
| 234 if (adapter->IfType == IF_TYPE_SOFTWARE_LOOPBACK) |
| 235 continue; |
| 236 if ((adapter->Flags & IP_ADAPTER_DHCP_ENABLED) == 0) |
| 237 continue; |
| 238 |
| 239 DCHECK(adapter->AdapterName); |
| 240 adapter_names->insert(adapter->AdapterName); |
| 241 } |
| 242 |
| 243 return true; |
| 244 } |
| 245 |
| 246 } // namespace net |
OLD | NEW |