Home | History | Annotate | Download | only in proxy 
      1 // Copyright (c) 2012 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_adapter_fetcher_win.h"
      6 
      7 #include "base/bind.h"
      8 #include "base/bind_helpers.h"
      9 #include "base/logging.h"
     10 #include "base/message_loop/message_loop_proxy.h"
     11 #include "base/metrics/histogram.h"
     12 #include "base/strings/string_util.h"
     13 #include "base/strings/sys_string_conversions.h"
     14 #include "base/task_runner.h"
     15 #include "base/time/time.h"
     16 #include "net/base/net_errors.h"
     17 #include "net/proxy/dhcpcsvc_init_win.h"
     18 #include "net/proxy/proxy_script_fetcher_impl.h"
     19 #include "net/url_request/url_request_context.h"
     20 
     21 #include <windows.h>
     22 #include <winsock2.h>
     23 #include <dhcpcsdk.h>
     24 #pragma comment(lib, "dhcpcsvc.lib")
     25 
     26 namespace {
     27 
     28 // Maximum amount of time to wait for response from the Win32 DHCP API.
     29 const int kTimeoutMs = 2000;
     30 
     31 }  // namespace
     32 
     33 namespace net {
     34 
     35 DhcpProxyScriptAdapterFetcher::DhcpProxyScriptAdapterFetcher(
     36     URLRequestContext* url_request_context,
     37     scoped_refptr<base::TaskRunner> task_runner)
     38     : task_runner_(task_runner),
     39       state_(STATE_START),
     40       result_(ERR_IO_PENDING),
     41       url_request_context_(url_request_context) {
     42   DCHECK(url_request_context_);
     43 }
     44 
     45 DhcpProxyScriptAdapterFetcher::~DhcpProxyScriptAdapterFetcher() {
     46   Cancel();
     47 }
     48 
     49 void DhcpProxyScriptAdapterFetcher::Fetch(
     50     const std::string& adapter_name, const CompletionCallback& callback) {
     51   DCHECK(CalledOnValidThread());
     52   DCHECK_EQ(state_, STATE_START);
     53   result_ = ERR_IO_PENDING;
     54   pac_script_ = base::string16();
     55   state_ = STATE_WAIT_DHCP;
     56   callback_ = callback;
     57 
     58   wait_timer_.Start(FROM_HERE, ImplGetTimeout(),
     59                     this, &DhcpProxyScriptAdapterFetcher::OnTimeout);
     60   scoped_refptr<DhcpQuery> dhcp_query(ImplCreateDhcpQuery());
     61   task_runner_->PostTaskAndReply(
     62       FROM_HERE,
     63       base::Bind(
     64           &DhcpProxyScriptAdapterFetcher::DhcpQuery::GetPacURLForAdapter,
     65           dhcp_query.get(),
     66           adapter_name),
     67       base::Bind(
     68           &DhcpProxyScriptAdapterFetcher::OnDhcpQueryDone,
     69           AsWeakPtr(),
     70           dhcp_query));
     71 }
     72 
     73 void DhcpProxyScriptAdapterFetcher::Cancel() {
     74   DCHECK(CalledOnValidThread());
     75   callback_.Reset();
     76   wait_timer_.Stop();
     77   script_fetcher_.reset();
     78 
     79   switch (state_) {
     80     case STATE_WAIT_DHCP:
     81       // Nothing to do here, we let the worker thread run to completion,
     82       // the task it posts back when it completes will check the state.
     83       break;
     84     case STATE_WAIT_URL:
     85       break;
     86     case STATE_START:
     87     case STATE_FINISH:
     88     case STATE_CANCEL:
     89       break;
     90   }
     91 
     92   if (state_ != STATE_FINISH) {
     93     result_ = ERR_ABORTED;
     94     state_ = STATE_CANCEL;
     95   }
     96 }
     97 
     98 bool DhcpProxyScriptAdapterFetcher::DidFinish() const {
     99   DCHECK(CalledOnValidThread());
    100   return state_ == STATE_FINISH;
    101 }
    102 
    103 int DhcpProxyScriptAdapterFetcher::GetResult() const {
    104   DCHECK(CalledOnValidThread());
    105   return result_;
    106 }
    107 
    108 base::string16 DhcpProxyScriptAdapterFetcher::GetPacScript() const {
    109   DCHECK(CalledOnValidThread());
    110   return pac_script_;
    111 }
    112 
    113 GURL DhcpProxyScriptAdapterFetcher::GetPacURL() const {
    114   DCHECK(CalledOnValidThread());
    115   return pac_url_;
    116 }
    117 
    118 DhcpProxyScriptAdapterFetcher::DhcpQuery::DhcpQuery() {
    119 }
    120 
    121 DhcpProxyScriptAdapterFetcher::DhcpQuery::~DhcpQuery() {
    122 }
    123 
    124 void DhcpProxyScriptAdapterFetcher::DhcpQuery::GetPacURLForAdapter(
    125     const std::string& adapter_name) {
    126   url_ = ImplGetPacURLFromDhcp(adapter_name);
    127 }
    128 
    129 const std::string& DhcpProxyScriptAdapterFetcher::DhcpQuery::url() const {
    130   return url_;
    131 }
    132 
    133 std::string
    134     DhcpProxyScriptAdapterFetcher::DhcpQuery::ImplGetPacURLFromDhcp(
    135         const std::string& adapter_name) {
    136   return DhcpProxyScriptAdapterFetcher::GetPacURLFromDhcp(adapter_name);
    137 }
    138 
    139 void DhcpProxyScriptAdapterFetcher::OnDhcpQueryDone(
    140     scoped_refptr<DhcpQuery> dhcp_query) {
    141   DCHECK(CalledOnValidThread());
    142   // Because we can't cancel the call to the Win32 API, we can expect
    143   // it to finish while we are in a few different states.  The expected
    144   // one is WAIT_DHCP, but it could be in CANCEL if Cancel() was called,
    145   // or FINISH if timeout occurred.
    146   DCHECK(state_ == STATE_WAIT_DHCP || state_ == STATE_CANCEL ||
    147          state_ == STATE_FINISH);
    148   if (state_ != STATE_WAIT_DHCP)
    149     return;
    150 
    151   wait_timer_.Stop();
    152 
    153   pac_url_ = GURL(dhcp_query->url());
    154   if (pac_url_.is_empty() || !pac_url_.is_valid()) {
    155     result_ = ERR_PAC_NOT_IN_DHCP;
    156     TransitionToFinish();
    157   } else {
    158     state_ = STATE_WAIT_URL;
    159     script_fetcher_.reset(ImplCreateScriptFetcher());
    160     script_fetcher_->Fetch(
    161         pac_url_, &pac_script_,
    162         base::Bind(&DhcpProxyScriptAdapterFetcher::OnFetcherDone,
    163                    base::Unretained(this)));
    164   }
    165 }
    166 
    167 void DhcpProxyScriptAdapterFetcher::OnTimeout() {
    168   DCHECK_EQ(state_, STATE_WAIT_DHCP);
    169   result_ = ERR_TIMED_OUT;
    170   TransitionToFinish();
    171 }
    172 
    173 void DhcpProxyScriptAdapterFetcher::OnFetcherDone(int result) {
    174   DCHECK(CalledOnValidThread());
    175   DCHECK(state_ == STATE_WAIT_URL || state_ == STATE_CANCEL);
    176   if (state_ == STATE_CANCEL)
    177     return;
    178 
    179   // At this point, pac_script_ has already been written to.
    180   script_fetcher_.reset();
    181   result_ = result;
    182   TransitionToFinish();
    183 }
    184 
    185 void DhcpProxyScriptAdapterFetcher::TransitionToFinish() {
    186   DCHECK(state_ == STATE_WAIT_DHCP || state_ == STATE_WAIT_URL);
    187   state_ = STATE_FINISH;
    188   CompletionCallback callback = callback_;
    189   callback_.Reset();
    190 
    191   // Be careful not to touch any member state after this, as the client
    192   // may delete us during this callback.
    193   callback.Run(result_);
    194 }
    195 
    196 DhcpProxyScriptAdapterFetcher::State
    197     DhcpProxyScriptAdapterFetcher::state() const {
    198   return state_;
    199 }
    200 
    201 ProxyScriptFetcher* DhcpProxyScriptAdapterFetcher::ImplCreateScriptFetcher() {
    202   return new ProxyScriptFetcherImpl(url_request_context_);
    203 }
    204 
    205 DhcpProxyScriptAdapterFetcher::DhcpQuery*
    206     DhcpProxyScriptAdapterFetcher::ImplCreateDhcpQuery() {
    207   return new DhcpQuery();
    208 }
    209 
    210 base::TimeDelta DhcpProxyScriptAdapterFetcher::ImplGetTimeout() const {
    211   return base::TimeDelta::FromMilliseconds(kTimeoutMs);
    212 }
    213 
    214 // static
    215 std::string DhcpProxyScriptAdapterFetcher::GetPacURLFromDhcp(
    216     const std::string& adapter_name) {
    217   EnsureDhcpcsvcInit();
    218 
    219   std::wstring adapter_name_wide = base::SysMultiByteToWide(adapter_name,
    220                                                             CP_ACP);
    221 
    222   DHCPCAPI_PARAMS_ARRAY send_params = { 0, NULL };
    223 
    224   BYTE option_data[] = { 1, 252 };
    225   DHCPCAPI_PARAMS wpad_params = { 0 };
    226   wpad_params.OptionId = 252;
    227   wpad_params.IsVendor = FALSE;  // Surprising, but intentional.
    228 
    229   DHCPCAPI_PARAMS_ARRAY request_params = { 0 };
    230   request_params.nParams = 1;
    231   request_params.Params = &wpad_params;
    232 
    233   // The maximum message size is typically 4096 bytes on Windows per
    234   // http://support.microsoft.com/kb/321592
    235   DWORD result_buffer_size = 4096;
    236   scoped_ptr<BYTE, base::FreeDeleter> result_buffer;
    237   int retry_count = 0;
    238   DWORD res = NO_ERROR;
    239   do {
    240     result_buffer.reset(static_cast<BYTE*>(malloc(result_buffer_size)));
    241 
    242     // Note that while the DHCPCAPI_REQUEST_SYNCHRONOUS flag seems to indicate
    243     // there might be an asynchronous mode, there seems to be (at least in
    244     // terms of well-documented use of this API) only a synchronous mode, with
    245     // an optional "async notifications later if the option changes" mode.
    246     // Even IE9, which we hope to emulate as IE is the most widely deployed
    247     // previous implementation of the DHCP aspect of WPAD and the only one
    248     // on Windows (Konqueror is the other, on Linux), uses this API with the
    249     // synchronous flag.  There seem to be several Microsoft Knowledge Base
    250     // articles about calls to this function failing when other flags are used
    251     // (e.g. http://support.microsoft.com/kb/885270) so we won't take any
    252     // chances on non-standard, poorly documented usage.
    253     res = ::DhcpRequestParams(DHCPCAPI_REQUEST_SYNCHRONOUS,
    254                               NULL,
    255                               const_cast<LPWSTR>(adapter_name_wide.c_str()),
    256                               NULL,
    257                               send_params, request_params,
    258                               result_buffer.get(), &result_buffer_size,
    259                               NULL);
    260     ++retry_count;
    261   } while (res == ERROR_MORE_DATA && retry_count <= 3);
    262 
    263   if (res != NO_ERROR) {
    264     VLOG(1) << "Error fetching PAC URL from DHCP: " << res;
    265     UMA_HISTOGRAM_COUNTS("Net.DhcpWpadUnhandledDhcpError", 1);
    266   } else if (wpad_params.nBytesData) {
    267     return SanitizeDhcpApiString(
    268         reinterpret_cast<const char*>(wpad_params.Data),
    269         wpad_params.nBytesData);
    270   }
    271 
    272   return "";
    273 }
    274 
    275 // static
    276 std::string DhcpProxyScriptAdapterFetcher::SanitizeDhcpApiString(
    277     const char* data, size_t count_bytes) {
    278   // The result should be ASCII, not wide character.  Some DHCP
    279   // servers appear to count the trailing NULL in nBytesData, others
    280   // do not.  A few (we've had one report, http://crbug.com/297810)
    281   // do not NULL-terminate but may \n-terminate.
    282   //
    283   // Belt and suspenders and elastic waistband: First, ensure we
    284   // NULL-terminate after nBytesData; this is the inner constructor
    285   // with nBytesData as a parameter.  Then, return only up to the
    286   // first null in case of embedded NULLs; this is the outer
    287   // constructor that takes the result of c_str() on the inner.  If
    288   // the server is giving us back a buffer with embedded NULLs,
    289   // something is broken anyway.  Finally, trim trailing whitespace.
    290   std::string result(std::string(data, count_bytes).c_str());
    291   base::TrimWhitespaceASCII(result, base::TRIM_TRAILING, &result);
    292   return result;
    293 }
    294 
    295 }  // namespace net
    296