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