diff options
Diffstat (limited to 'toolkit/system/osxproxy')
| -rw-r--r-- | toolkit/system/osxproxy/components.conf | 13 | ||||
| -rw-r--r-- | toolkit/system/osxproxy/moz.build | 23 | ||||
| -rw-r--r-- | toolkit/system/osxproxy/nsOSXSystemProxySettings.mm | 428 |
3 files changed, 464 insertions, 0 deletions
diff --git a/toolkit/system/osxproxy/components.conf b/toolkit/system/osxproxy/components.conf new file mode 100644 index 0000000000..b3e3c464b6 --- /dev/null +++ b/toolkit/system/osxproxy/components.conf @@ -0,0 +1,13 @@ +# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*- +# vim: set filetype=python: +# 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/. + +Classes = [ + { + 'cid': '{9afcd4b8-2e0f-41f4-8f1f-3bf0d3cf67de}', + 'contract_ids': ['@mozilla.org/system-proxy-settings;1'], + 'type': 'nsOSXSystemProxySettings', + }, +] diff --git a/toolkit/system/osxproxy/moz.build b/toolkit/system/osxproxy/moz.build new file mode 100644 index 0000000000..a28c9ce35c --- /dev/null +++ b/toolkit/system/osxproxy/moz.build @@ -0,0 +1,23 @@ +# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*- +# vim: set filetype=python: +# 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/. + +with Files("**"): + BUG_COMPONENT = ("Core", "Networking") + +SOURCES += [ + "nsOSXSystemProxySettings.mm", +] + +XPCOM_MANIFESTS += [ + "components.conf", +] + +FINAL_LIBRARY = "xul" + +LOCAL_INCLUDES += [ + "../commonproxy", + "/netwerk/base", +] diff --git a/toolkit/system/osxproxy/nsOSXSystemProxySettings.mm b/toolkit/system/osxproxy/nsOSXSystemProxySettings.mm new file mode 100644 index 0000000000..b1ad41ccc1 --- /dev/null +++ b/toolkit/system/osxproxy/nsOSXSystemProxySettings.mm @@ -0,0 +1,428 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:set ts=2 sw=2 sts=2 et: */ +/* 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/. */ + +#import <Cocoa/Cocoa.h> +#import <SystemConfiguration/SystemConfiguration.h> + +#include "nsISystemProxySettings.h" +#include "mozilla/Components.h" +#include "nsPrintfCString.h" +#include "nsNetCID.h" +#include "nsObjCExceptions.h" +#include "mozilla/Attributes.h" +#include "mozilla/StaticPrefs_network.h" +#include "ProxyUtils.h" +#include "ProxyConfig.h" + +class nsOSXSystemProxySettings : public nsISystemProxySettings { + public: + NS_DECL_THREADSAFE_ISUPPORTS + NS_DECL_NSISYSTEMPROXYSETTINGS + + nsOSXSystemProxySettings(); + nsresult Init(); + + // called by OSX when the proxy settings have changed + void ProxyHasChanged(); + + // is there a PAC url specified in the system configuration + bool IsAutoconfigEnabled() const; + // retrieve the pac url + nsresult GetAutoconfigURL(nsAutoCString& aResult) const; + + // Find the SystemConfiguration proxy & port for a given URI + nsresult FindSCProxyPort(const nsACString& aScheme, nsACString& aResultHost, + int32_t& aResultPort, bool& aResultSocksProxy); + + // is host:port on the proxy exception list? + bool IsInExceptionList(const nsACString& aHost) const; + + protected: + virtual ~nsOSXSystemProxySettings(); + virtual void InitDone() {} + virtual void OnProxyConfigChangedInternal() {} + + SCDynamicStoreContext mContext; + SCDynamicStoreRef mSystemDynamicStore; + NSDictionary* mProxyDict; + + // Mapping of URI schemes to SystemConfiguration keys + struct SchemeMapping { + const char* mScheme; + CFStringRef mEnabled; + CFStringRef mHost; + CFStringRef mPort; + bool mIsSocksProxy; + }; + static const SchemeMapping gSchemeMappingList[]; +}; + +NS_IMPL_ISUPPORTS(nsOSXSystemProxySettings, nsISystemProxySettings) + +NS_IMETHODIMP +nsOSXSystemProxySettings::GetMainThreadOnly(bool* aMainThreadOnly) { + *aMainThreadOnly = true; + return NS_OK; +} + +// Mapping of URI schemes to SystemConfiguration keys +const nsOSXSystemProxySettings::SchemeMapping + nsOSXSystemProxySettings::gSchemeMappingList[] = { + {"http", kSCPropNetProxiesHTTPEnable, kSCPropNetProxiesHTTPProxy, + kSCPropNetProxiesHTTPPort, false}, + {"https", kSCPropNetProxiesHTTPSEnable, kSCPropNetProxiesHTTPSProxy, + kSCPropNetProxiesHTTPSPort, false}, + {"ftp", kSCPropNetProxiesFTPEnable, kSCPropNetProxiesFTPProxy, + kSCPropNetProxiesFTPPort, false}, + {"socks", kSCPropNetProxiesSOCKSEnable, kSCPropNetProxiesSOCKSProxy, + kSCPropNetProxiesSOCKSPort, true}, + {NULL, NULL, NULL, NULL, false}, +}; + +static void ProxyHasChangedWrapper(SCDynamicStoreRef aStore, + CFArrayRef aChangedKeys, void* aInfo) { + static_cast<nsOSXSystemProxySettings*>(aInfo)->ProxyHasChanged(); +} + +nsOSXSystemProxySettings::nsOSXSystemProxySettings() + : mSystemDynamicStore(NULL), mProxyDict(NULL) { + mContext = (SCDynamicStoreContext){0, this, NULL, NULL, NULL}; +} + +nsresult nsOSXSystemProxySettings::Init() { + NS_OBJC_BEGIN_TRY_BLOCK_RETURN; + + // Register for notification of proxy setting changes + // See: + // http://developer.apple.com/documentation/Networking/Conceptual/CFNetwork/CFStreamTasks/chapter_4_section_5.html + mSystemDynamicStore = SCDynamicStoreCreate(NULL, CFSTR("Mozilla"), + ProxyHasChangedWrapper, &mContext); + if (!mSystemDynamicStore) return NS_ERROR_FAILURE; + + // Set up the store to monitor any changes to the proxies + CFStringRef proxiesKey = SCDynamicStoreKeyCreateProxies(NULL); + if (!proxiesKey) return NS_ERROR_FAILURE; + + CFArrayRef keyArray = CFArrayCreate(NULL, (const void**)(&proxiesKey), 1, + &kCFTypeArrayCallBacks); + CFRelease(proxiesKey); + if (!keyArray) return NS_ERROR_FAILURE; + + SCDynamicStoreSetNotificationKeys(mSystemDynamicStore, keyArray, NULL); + CFRelease(keyArray); + + // Add the dynamic store to the run loop + CFRunLoopSourceRef storeRLSource = + SCDynamicStoreCreateRunLoopSource(NULL, mSystemDynamicStore, 0); + if (!storeRLSource) return NS_ERROR_FAILURE; + CFRunLoopAddSource(CFRunLoopGetCurrent(), storeRLSource, + kCFRunLoopCommonModes); + CFRelease(storeRLSource); + + // Load the initial copy of proxy info + mProxyDict = (NSDictionary*)SCDynamicStoreCopyProxies(mSystemDynamicStore); + if (!mProxyDict) return NS_ERROR_FAILURE; + + InitDone(); + + return NS_OK; + + NS_OBJC_END_TRY_BLOCK_RETURN(NS_ERROR_FAILURE); +} + +nsOSXSystemProxySettings::~nsOSXSystemProxySettings() { + NS_OBJC_BEGIN_TRY_IGNORE_BLOCK; + + [mProxyDict release]; + + if (mSystemDynamicStore) { + // Invalidate the dynamic store's run loop source + // to get the store out of the run loop + CFRunLoopSourceRef rls = + SCDynamicStoreCreateRunLoopSource(NULL, mSystemDynamicStore, 0); + if (rls) { + CFRunLoopSourceInvalidate(rls); + CFRelease(rls); + } + CFRelease(mSystemDynamicStore); + } + + NS_OBJC_END_TRY_IGNORE_BLOCK; +} + +void nsOSXSystemProxySettings::ProxyHasChanged() { + NS_OBJC_BEGIN_TRY_IGNORE_BLOCK; + + [mProxyDict release]; + mProxyDict = (NSDictionary*)SCDynamicStoreCopyProxies(mSystemDynamicStore); + + NS_OBJC_END_TRY_IGNORE_BLOCK; + + OnProxyConfigChangedInternal(); +} + +nsresult nsOSXSystemProxySettings::FindSCProxyPort(const nsACString& aScheme, + nsACString& aResultHost, + int32_t& aResultPort, + bool& aResultSocksProxy) { + NS_OBJC_BEGIN_TRY_BLOCK_RETURN; + + NS_ENSURE_TRUE(mProxyDict != NULL, NS_ERROR_FAILURE); + + for (const SchemeMapping* keys = gSchemeMappingList; keys->mScheme != NULL; + ++keys) { + // Check for matching scheme (when appropriate) + if (strcasecmp(keys->mScheme, PromiseFlatCString(aScheme).get()) && + !keys->mIsSocksProxy) + continue; + + // Check the proxy is enabled + NSNumber* enabled = [mProxyDict objectForKey:(NSString*)keys->mEnabled]; + NS_ENSURE_TRUE(enabled == NULL || [enabled isKindOfClass:[NSNumber class]], + NS_ERROR_FAILURE); + if ([enabled intValue] == 0) continue; + + // Get the proxy host + NSString* host = [mProxyDict objectForKey:(NSString*)keys->mHost]; + if (host == NULL) break; + NS_ENSURE_TRUE([host isKindOfClass:[NSString class]], NS_ERROR_FAILURE); + aResultHost.Assign([host UTF8String]); + + // Get the proxy port + NSNumber* port = [mProxyDict objectForKey:(NSString*)keys->mPort]; + NS_ENSURE_TRUE([port isKindOfClass:[NSNumber class]], NS_ERROR_FAILURE); + aResultPort = [port intValue]; + + aResultSocksProxy = keys->mIsSocksProxy; + + return NS_OK; + } + + return NS_ERROR_FAILURE; + + NS_OBJC_END_TRY_BLOCK_RETURN(NS_ERROR_FAILURE); +} + +bool nsOSXSystemProxySettings::IsAutoconfigEnabled() const { + NS_OBJC_BEGIN_TRY_BLOCK_RETURN; + + NSNumber* value = [mProxyDict + objectForKey:(NSString*)kSCPropNetProxiesProxyAutoConfigEnable]; + NS_ENSURE_TRUE(value == NULL || [value isKindOfClass:[NSNumber class]], + false); + return ([value intValue] != 0); + + NS_OBJC_END_TRY_BLOCK_RETURN(false); +} + +nsresult nsOSXSystemProxySettings::GetAutoconfigURL( + nsAutoCString& aResult) const { + NS_OBJC_BEGIN_TRY_BLOCK_RETURN; + + NSString* value = [mProxyDict + objectForKey:(NSString*)kSCPropNetProxiesProxyAutoConfigURLString]; + if (value != NULL) { + NS_ENSURE_TRUE([value isKindOfClass:[NSString class]], NS_ERROR_FAILURE); + aResult.Assign([value UTF8String]); + return NS_OK; + } + + return NS_ERROR_FAILURE; + + NS_OBJC_END_TRY_BLOCK_RETURN(NS_ERROR_FAILURE); +} + +bool nsOSXSystemProxySettings::IsInExceptionList( + const nsACString& aHost) const { + NS_OBJC_BEGIN_TRY_BLOCK_RETURN; + + NS_ENSURE_TRUE(mProxyDict != NULL, false); + + NSArray* exceptionList = + [mProxyDict objectForKey:(NSString*)kSCPropNetProxiesExceptionsList]; + NS_ENSURE_TRUE( + exceptionList == NULL || [exceptionList isKindOfClass:[NSArray class]], + false); + + NSEnumerator* exceptionEnumerator = [exceptionList objectEnumerator]; + NSString* currentValue = NULL; + while ((currentValue = [exceptionEnumerator nextObject])) { + NS_ENSURE_TRUE([currentValue isKindOfClass:[NSString class]], false); + nsAutoCString overrideStr([currentValue UTF8String]); + if (mozilla::toolkit::system::IsHostProxyEntry(aHost, overrideStr)) + return true; + } + + NS_OBJC_END_TRY_BLOCK_RETURN(false); +} + +nsresult nsOSXSystemProxySettings::GetPACURI(nsACString& aResult) { + NS_OBJC_BEGIN_TRY_BLOCK_RETURN; + + NS_ENSURE_TRUE(mProxyDict != NULL, NS_ERROR_FAILURE); + + nsAutoCString pacUrl; + if (IsAutoconfigEnabled() && NS_SUCCEEDED(GetAutoconfigURL(pacUrl))) { + aResult.Assign(pacUrl); + return NS_OK; + } + + return NS_ERROR_FAILURE; + + NS_OBJC_END_TRY_BLOCK_RETURN(NS_ERROR_FAILURE); +} + +nsresult nsOSXSystemProxySettings::GetProxyForURI(const nsACString& aSpec, + const nsACString& aScheme, + const nsACString& aHost, + const int32_t aPort, + nsACString& aResult) { + NS_OBJC_BEGIN_TRY_BLOCK_RETURN; + + int32_t proxyPort; + nsAutoCString proxyHost; + bool proxySocks; + nsresult rv = FindSCProxyPort(aScheme, proxyHost, proxyPort, proxySocks); + + if (NS_FAILED(rv) || IsInExceptionList(aHost)) { + aResult.AssignLiteral("DIRECT"); + } else if (proxySocks) { + aResult.Assign("SOCKS "_ns + proxyHost + nsPrintfCString(":%d", proxyPort)); + } else { + aResult.Assign("PROXY "_ns + proxyHost + nsPrintfCString(":%d", proxyPort)); + } + + return NS_OK; + + NS_OBJC_END_TRY_BLOCK_RETURN(NS_ERROR_FAILURE); +} + +using namespace mozilla::net; + +class OSXSystemProxySettingsAsync final : public nsOSXSystemProxySettings { + public: + NS_INLINE_DECL_REFCOUNTING_INHERITED(OSXSystemProxySettingsAsync, + nsOSXSystemProxySettings) + NS_DECL_NSISYSTEMPROXYSETTINGS + + OSXSystemProxySettingsAsync(); + + protected: + virtual void OnProxyConfigChangedInternal() override; + void InitDone() override; + + private: + virtual ~OSXSystemProxySettingsAsync(); + + ProxyConfig mConfig; +}; + +OSXSystemProxySettingsAsync::OSXSystemProxySettingsAsync() = default; + +OSXSystemProxySettingsAsync::~OSXSystemProxySettingsAsync() = default; + +void OSXSystemProxySettingsAsync::InitDone() { OnProxyConfigChangedInternal(); } + +void OSXSystemProxySettingsAsync::OnProxyConfigChangedInternal() { + ProxyConfig config; + + // PAC + nsAutoCString pacUrl; + if (IsAutoconfigEnabled() && NS_SUCCEEDED(GetAutoconfigURL(pacUrl))) { + config.SetPACUrl(pacUrl); + } + + // proxies (for now: PROXY and SOCKS) + for (const SchemeMapping* keys = gSchemeMappingList; keys->mScheme != NULL; + ++keys) { + // Check the proxy is enabled + NSNumber* enabled = [mProxyDict objectForKey:(NSString*)keys->mEnabled]; + if (!(enabled == NULL || [enabled isKindOfClass:[NSNumber class]])) { + continue; + } + + if ([enabled intValue] == 0) { + continue; + } + + // Get the proxy host + NSString* host = [mProxyDict objectForKey:(NSString*)keys->mHost]; + if (host == NULL) break; + if (!([host isKindOfClass:[NSString class]])) { + continue; + } + + nsCString resultHost; + resultHost.Assign([host UTF8String]); + + // Get the proxy port + NSNumber* port = [mProxyDict objectForKey:(NSString*)keys->mPort]; + if (!([port isKindOfClass:[NSNumber class]])) { + continue; + } + + int32_t resultPort = [port intValue]; + ProxyServer server(ProxyConfig::ToProxyType(keys->mScheme), resultHost, + resultPort); + config.Rules().mProxyServers[server.Type()] = std::move(server); + } + + // exceptions + NSArray* exceptionList = + [mProxyDict objectForKey:(NSString*)kSCPropNetProxiesExceptionsList]; + if (exceptionList != NULL && [exceptionList isKindOfClass:[NSArray class]]) { + NSEnumerator* exceptionEnumerator = [exceptionList objectEnumerator]; + NSString* currentValue = NULL; + while ((currentValue = [exceptionEnumerator nextObject])) { + if (currentValue != NULL && + [currentValue isKindOfClass:[NSString class]]) { + nsCString overrideStr([currentValue UTF8String]); + config.ByPassRules().mExceptions.AppendElement(std::move(overrideStr)); + } + } + } + + mConfig = std::move(config); +} + +NS_IMETHODIMP +OSXSystemProxySettingsAsync::GetMainThreadOnly(bool* aMainThreadOnly) { + return nsOSXSystemProxySettings::GetMainThreadOnly(aMainThreadOnly); +} + +NS_IMETHODIMP +OSXSystemProxySettingsAsync::GetPACURI(nsACString& aResult) { + aResult.Assign(mConfig.PACUrl()); + return NS_OK; +} + +NS_IMETHODIMP +OSXSystemProxySettingsAsync::GetProxyForURI(const nsACString& aSpec, + const nsACString& aScheme, + const nsACString& aHost, + const int32_t aPort, + nsACString& aResult) { + for (const auto& bypassRule : mConfig.ByPassRules().mExceptions) { + if (mozilla::toolkit::system::IsHostProxyEntry(aHost, bypassRule)) { + aResult.AssignLiteral("DIRECT"); + return NS_OK; + } + } + + mConfig.GetProxyString(aScheme, aResult); + return NS_OK; +} + +NS_IMPL_COMPONENT_FACTORY(nsOSXSystemProxySettings) { + auto settings = + mozilla::StaticPrefs::network_proxy_detect_system_proxy_changes() + ? mozilla::MakeRefPtr<OSXSystemProxySettingsAsync>() + : mozilla::MakeRefPtr<nsOSXSystemProxySettings>(); + if (NS_SUCCEEDED(settings->Init())) { + return settings.forget().downcast<nsISupports>(); + } + return nullptr; +} |