NetworkProxyWin.cpp

Go to the documentation of this file.

// Mantid Repository : https://github.com/mantidproject/mantid
//
// Copyright © 2018 ISIS Rutherford Appleton Laboratory UKRI,
//   NScD Oak Ridge National Laboratory, European Spallation Source,
//   Institut Laue - Langevin & CSNS, Institute of High Energy Physics, CAS
// SPDX - License - Identifier: GPL - 3.0 +
// Only compile on windows.
#if defined(_WIN32) || defined(_WIN64)
 
#include "MantidKernel/NetworkProxy.h"
#include "MantidKernel/WarningSuppressions.h"
// std
#include <sstream>
// windows
#include <Winhttp.h>
#include <windows.h>
 
namespace Mantid {
namespace Kernel {
 
bool get_proxy_configuration_win(const std::string &target_url, std::string &proxy_str, std::string &err_msg) {
  HINTERNET hSession = NULL;
  std::wstring proxy;
  std::wstring wtarget_url;
  if (target_url.find("http://") == std::string::npos) {
    wtarget_url = L"http://";
  }
  wtarget_url += std::wstring(target_url.begin(), target_url.end());
  bool fail = false;
  std::stringstream info;
  WINHTTP_CURRENT_USER_IE_PROXY_CONFIG ie_proxy;
  WINHTTP_AUTOPROXY_OPTIONS proxy_options;
  WINHTTP_PROXY_INFO proxy_info;
  ZeroMemory(&proxy_options, sizeof(proxy_options));
  ZeroMemory(&ie_proxy, sizeof(ie_proxy));
  ZeroMemory(&proxy_info, sizeof(proxy_info));
 
  // the loop is just to allow us to go out of this session whenever we want
  while (true) {
    // Use WinHttpOpen to obtain a session handle.
    hSession = WinHttpOpen(L"NetworkProxyWin FindingProxy/1.0", WINHTTP_ACCESS_TYPE_DEFAULT_PROXY,
                           WINHTTP_NO_PROXY_NAME, WINHTTP_NO_PROXY_BYPASS, 0);
    if (!hSession) {
      fail = true;
      info << "Failed to create the session (Error Code: " << GetLastError() << ").";
      break;
    }
    // get the configuration of the web browser
    if (!WinHttpGetIEProxyConfigForCurrentUser(&ie_proxy)) {
      fail = true;
      info << "Could not find the proxy settings (Error code :" << GetLastError();
      break;
    }
 
    if (ie_proxy.lpszProxy) {
      // the proxy was already given,
      // it is not necessary to query the system for the auto proxy
      proxy = ie_proxy.lpszProxy;
      break;
    }
 
    if (ie_proxy.fAutoDetect) {
      // if auto detect, than setup the proxy to auto detect
      proxy_options.dwFlags |= WINHTTP_AUTOPROXY_AUTO_DETECT;
      proxy_options.dwAutoDetectFlags = WINHTTP_AUTO_DETECT_TYPE_DNS_A;
    }
 
    if (ie_proxy.lpszAutoConfigUrl) {
      // configure to auto proxy
      proxy_options.dwFlags |= WINHTTP_AUTOPROXY_CONFIG_URL;
      proxy_options.lpszAutoConfigUrl = ie_proxy.lpszAutoConfigUrl;
    }
 
    if (!WinHttpGetProxyForUrl(hSession, wtarget_url.c_str(), &proxy_options, &proxy_info)) {
      info << "Could not find the proxy for this url (Error code :" << GetLastError() << ").";
      fail = true;
      break;
    }
 
    // std::cout << "get proxy for url passed" << std::endl;
    if (proxy_info.dwAccessType == WINHTTP_ACCESS_TYPE_NO_PROXY) {
      // no proxy (return an empty proxy)
      break;
    }
 
    if (proxy_info.lpszProxy) {
      // proxy found. Get it.
      proxy = proxy_info.lpszProxy;
      break;
    }
    break; // loop finished
  }
 
  // free memory of all possibly allocated objects
  // ie_proxy
  if (ie_proxy.lpszAutoConfigUrl)
    GlobalFree(ie_proxy.lpszAutoConfigUrl);
  if (ie_proxy.lpszProxy)
    GlobalFree(ie_proxy.lpszProxy);
  if (ie_proxy.lpszProxyBypass)
    GlobalFree(ie_proxy.lpszProxyBypass);
  // proxy_info
  if (proxy_info.lpszProxyBypass)
    GlobalFree(proxy_info.lpszProxyBypass);
  if (proxy_info.lpszProxy)
    GlobalFree(proxy_info.lpszProxy);
 
  // hSession
  if (hSession)
    WinHttpCloseHandle(hSession);
 
  if (fail) {
    err_msg = info.str();
  }
  MSVC_DIAG_OFF(4244)
  proxy_str = std::string(proxy.begin(), proxy.end());
  MSVC_DIAG_ON(4244)
  return !fail;
}
 
//----------------------------------------------------------------------------------------------
NetworkProxy::NetworkProxy() : m_logger("network_proxy_logger_win") {}
 
ProxyInfo NetworkProxy::getHttpProxy(const std::string &targetURLString) {
 
  ProxyInfo proxyInfo; // No proxy
  std::string errmsg, proxy_option;
  m_logger.debug() << "Attempt to get the windows proxy configuration for this connection" << std::endl;
  if (get_proxy_configuration_win(targetURLString, proxy_option, errmsg)) {
    std::string proxyServer;
    int proxyPort = 0;
    if (!proxy_option.empty()) {
      size_t pos = proxy_option.rfind(':');
      if (pos != std::string::npos) {
        if (pos == 4 || pos == 5) // means it found http(s):
        {
          proxyServer = proxy_option;
          proxyPort = 8080; // default port for proxy
        } else {
          proxyServer = std::string(proxy_option.begin(), proxy_option.begin() + pos);
          std::stringstream port_str;
          port_str << std::string(proxy_option.begin() + pos + 1, proxy_option.end());
          port_str >> proxyPort;
        }
      } else {
        proxyServer = proxy_option;
        proxyPort = 8080;
      }
    }
    proxyInfo = ProxyInfo(proxyServer, proxyPort, true);
  } else {
    m_logger.information() << "NetworkProxyWin failed to find the proxy "
                              "information. It will attempt without proxy. "
                           << errmsg << std::endl;
  }
 
  return proxyInfo;
}
 
} // namespace Kernel
} // namespace Mantid
 
#endif