Quelle  nsUnixSystemProxySettings.cpp

/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#include "nsISystemProxySettings.h"
#include "mozilla/Components.h"
#include "nsIURI.h"
#include "nsArrayUtils.h"
#include "prnetdb.h"
#include "prenv.h"
#include "nsClassHashtable.h"
#include "nsHashtablesFwd.h"
#include "nsHashKeys.h"
#include "nsNetUtil.h"
#include "nsISupportsPrimitives.h"
#include "mozilla/widget/GSettings.h"
#include "nsReadableUtils.h"
#include "ProxyUtils.h"

using namespace mozilla;

class nsUnixSystemProxySettings final : public nsISystemProxySettings {
 public:
  NS_DECL_ISUPPORTS
  NS_DECL_NSISYSTEMPROXYSETTINGS

  nsUnixSystemProxySettings() : mSchemeProxySettings(4) {}

 private:
  ~nsUnixSystemProxySettings() = default;

  widget::GSettings::Collection mProxySettings{"org.gnome.system.proxy"_ns};
  nsClassHashtable<nsCStringHashKey, widget::GSettings::Collection>
      mSchemeProxySettings;
  nsresult GetProxyFromGSettings(const nsACString& aScheme,
                                 const nsACString& aHost, int32_t aPort,
                                 nsACString& aResult);
  nsresult SetProxyResultFromGSettings(const nsCString& aSchema,
                                       const char* aType, nsACString& aResult);
};

NS_IMPL_ISUPPORTS(nsUnixSystemProxySettings, nsISystemProxySettings)

NS_IMETHODIMP
nsUnixSystemProxySettings::GetMainThreadOnly(bool* aMainThreadOnly) {
  // dbus prevents us from being threadsafe, but this routine should not block
  // anyhow
  *aMainThreadOnly = true;
  return NS_OK;
}

nsresult nsUnixSystemProxySettings::GetPACURI(nsACString& aResult) {
  if (mProxySettings) {
    nsAutoCString proxyMode;
    // Check if mode is auto
    mProxySettings.GetString("mode"_ns, proxyMode);
    if (proxyMode.EqualsLiteral("auto")) {
      mProxySettings.GetString("autoconfig-url"_ns, aResult);
      return NS_OK;
    }
  }
  // Return an empty string when auto mode is not set.
  aResult.Truncate();
  return NS_OK;
}

static void SetProxyResult(const char* aType, const nsACString& aHost,
                           int32_t aPort, nsACString& aResult) {
  aResult.AssignASCII(aType);
  aResult.Append(' ');
  aResult.Append(aHost);
  if (aPort > 0) {
    aResult.Append(':');
    aResult.AppendInt(aPort);
  }
}

static void SetProxyResultDirect(nsACString& aResult) {
  aResult.AssignLiteral("DIRECT");
}

nsresult nsUnixSystemProxySettings::SetProxyResultFromGSettings(
    const nsCString& aSchema, const char* aType, nsACString& aResult) {
  auto& settings = mSchemeProxySettings.LookupOrInsertWith(aSchema, [&] {
    return MakeUnique<widget::GSettings::Collection>(aSchema);
  });

  nsAutoCString host;
  settings->GetString("host"_ns, host);
  if (host.IsEmpty()) {
    return NS_ERROR_FAILURE;
  }

  int32_t port = settings->GetInt("port"_ns).valueOr(0);

  // When port is 0, proxy is not considered as enabled even if host is set.
  if (port == 0) {
    return NS_ERROR_FAILURE;
  }

  SetProxyResult(aType, host, port, aResult);
  return NS_OK;
}

/* copied from nsProtocolProxyService.cpp --- we should share this! */
static void proxy_MaskIPv6Addr(PRIPv6Addr& addr, uint16_t mask_len) {
  if (mask_len == 128) return;

  if (mask_len > 96) {
    addr.pr_s6_addr32[3] =
        PR_htonl(PR_ntohl(addr.pr_s6_addr32[3]) & (~0L << (128 - mask_len)));
  } else if (mask_len > 64) {
    addr.pr_s6_addr32[3] = 0;
    addr.pr_s6_addr32[2] =
        PR_htonl(PR_ntohl(addr.pr_s6_addr32[2]) & (~0L << (96 - mask_len)));
  } else if (mask_len > 32) {
    addr.pr_s6_addr32[3] = 0;
    addr.pr_s6_addr32[2] = 0;
    addr.pr_s6_addr32[1] =
        PR_htonl(PR_ntohl(addr.pr_s6_addr32[1]) & (~0L << (64 - mask_len)));
  } else {
    addr.pr_s6_addr32[3] = 0;
    addr.pr_s6_addr32[2] = 0;
    addr.pr_s6_addr32[1] = 0;
    addr.pr_s6_addr32[0] =
        PR_htonl(PR_ntohl(addr.pr_s6_addr32[0]) & (~0L << (32 - mask_len)));
  }
}

static bool ConvertToIPV6Addr(const nsACString& aName, PRIPv6Addr* aAddr,
                              int32_t* aMask) {
  PRNetAddr addr;
  // try to convert hostname to IP
  if (PR_StringToNetAddr(PromiseFlatCString(aName).get(), &addr) != PR_SUCCESS)
    return false;

  // convert parsed address to IPv6
  if (addr.raw.family == PR_AF_INET) {
    // convert to IPv4-mapped address
    PR_ConvertIPv4AddrToIPv6(addr.inet.ip, aAddr);
    if (aMask) {
      if (*aMask <= 32)
        *aMask += 96;
      else
        return false;
    }
  } else if (addr.raw.family == PR_AF_INET6) {
    // copy the address
    memcpy(aAddr, &addr.ipv6.ip, sizeof(PRIPv6Addr));
  } else {
    return false;
  }

  return true;
}

static bool HostIgnoredByProxy(const nsACString& aIgnore,
                               const nsACString& aHost) {
  if (aIgnore.IsEmpty()) {
    return false;
  }
  if (aIgnore.Equals(aHost, nsCaseInsensitiveCStringComparator)) {
    return true;
  }
  if (aIgnore.First() == '*' &&
      StringEndsWith(aHost, nsDependentCSubstring(aIgnore, 1),
                     nsCaseInsensitiveCStringComparator)) {
    return true;
  }

  int32_t mask = 128;
  nsReadingIterator<char> start;
  nsReadingIterator<char> slash;
  nsReadingIterator<char> end;
  aIgnore.BeginReading(start);
  aIgnore.BeginReading(slash);
  aIgnore.EndReading(end);
  if (FindCharInReadable('/', slash, end)) {
    ++slash;
    nsDependentCSubstring maskStr(slash, end);
    nsAutoCString maskStr2(maskStr);
    nsresult err;
    mask = maskStr2.ToInteger(&err);
    if (NS_FAILED(err)) {
      mask = 128;
    }
    --slash;
  } else {
    slash = end;
  }

  nsDependentCSubstring ignoreStripped(start, slash);
  PRIPv6Addr ignoreAddr, hostAddr;
  if (!ConvertToIPV6Addr(ignoreStripped, &ignoreAddr, &mask) ||
      !ConvertToIPV6Addr(aHost, &hostAddr, nullptr)) {
    return false;
  }

  proxy_MaskIPv6Addr(ignoreAddr, mask);
  proxy_MaskIPv6Addr(hostAddr, mask);

  return memcmp(&ignoreAddr, &hostAddr, sizeof(PRIPv6Addr)) == 0;
}

nsresult nsUnixSystemProxySettings::GetProxyFromGSettings(
    const nsACString& aScheme, const nsACString& aHost, int32_t aPort,
    nsACString& aResult) {
  nsCString proxyMode;
  mProxySettings.GetString("mode"_ns, proxyMode);
  // return NS_ERROR_FAILURE when no proxy is set
  if (!proxyMode.EqualsLiteral("manual")) {
    return NS_ERROR_FAILURE;
  }

  nsTArray<nsCString> ignoreList;
  mProxySettings.GetStringList("ignore-hosts"_ns, ignoreList);
  for (auto& s : ignoreList) {
    if (HostIgnoredByProxy(s, aHost)) {
      SetProxyResultDirect(aResult);
      return NS_OK;
    }
  }

  nsresult rv = NS_OK;
  if (aScheme.LowerCaseEqualsLiteral("http")) {
    rv = SetProxyResultFromGSettings("org.gnome.system.proxy.http"_ns, "PROXY",
                                     aResult);
  } else if (aScheme.LowerCaseEqualsLiteral("https")) {
    rv = SetProxyResultFromGSettings("org.gnome.system.proxy.https"_ns, "PROXY",
                                     aResult);
    /* Try to use HTTP proxy when HTTPS proxy is not explicitly defined */
    if (rv != NS_OK) {
      rv = SetProxyResultFromGSettings("org.gnome.system.proxy.http"_ns,
                                       "PROXY", aResult);
    }
  } else {
    rv = NS_ERROR_FAILURE;
  }
  if (rv != NS_OK) {
    /* If proxy for scheme is not specified, use SOCKS proxy for all schemes */
    rv = SetProxyResultFromGSettings("org.gnome.system.proxy.socks"_ns, "SOCKS",
                                     aResult);
  }

  if (NS_FAILED(rv)) {
    SetProxyResultDirect(aResult);
  }

  return NS_OK;
}

NS_IMETHODIMP nsUnixSystemProxySettings::SetSystemProxyInfo(
    const nsACString& aHost, int32_t aPort, const nsACString& aPacFileUrl,
    const nsTArray<nsCString>& aExclusionList) {
  MOZ_ASSERT(false, "Did not expect to be called on this platform");
  return NS_ERROR_NOT_IMPLEMENTED;
}

nsresult nsUnixSystemProxySettings::GetProxyForURI(const nsACString& aSpec,
                                                   const nsACString& aScheme,
                                                   const nsACString& aHost,
                                                   const int32_t aPort,
                                                   nsACString& aResult) {
  nsresult rv = mozilla::toolkit::system::GetProxyFromEnvironment(
      aScheme, aHost, aPort, aResult);
  if (NS_SUCCEEDED(rv)) {
    return rv;
  }

  if (mProxySettings) {
    rv = GetProxyFromGSettings(aScheme, aHost, aPort, aResult);
    if (NS_SUCCEEDED(rv)) return rv;
  }

  return rv;
}

NS_IMETHODIMP
nsUnixSystemProxySettings::GetSystemWPADSetting(bool* aSystemWPADSetting) {
  *aSystemWPADSetting = false;
  return NS_OK;
}

NS_IMETHODIMP
nsUnixSystemProxySettings::GetSystemProxyDirect(bool* aResult) {
  if (mozilla::toolkit::system::HasProxyEnvVars()) {
    *aResult = false;
    return NS_OK;
  }

  if (!mProxySettings) {
    *aResult = true;
    return NS_OK;
  }

  nsAutoCString proxyMode;
  mProxySettings.GetString("mode"_ns, proxyMode);
  *aResult = proxyMode.EqualsLiteral("none") || proxyMode.IsEmpty();
  return NS_OK;
}

NS_IMPL_COMPONENT_FACTORY(nsUnixSystemProxySettings) {
  auto result = MakeRefPtr<nsUnixSystemProxySettings>();
  return result.forget().downcast<nsISupports>();
}