mozilla
/
gecko-dev
зеркало из https://github.com/mozilla/gecko-dev.git
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность

Bug 1236969 - remove autodialer r=valentin

This commit is contained in:
Patrick McManus 2016-02-19 14:33:59 -05:00
Родитель 89eb82cf26
Коммит f03b618067
15 изменённых файлов: 0 добавлений и 928 удалений
Показать статистику Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

4
modules/libpref/init/all.js
Просмотреть файл

@ -3293,10 +3293,6 @@ pref("plugin.scan.plid.all", true);
// Whether sending WM_MOUSEWHEEL and WM_MOUSEHWHEEL to plugins on Windows.
pref("plugin.mousewheel.enabled", true);
// Help Windows NT, 2000, and XP dialup a RAS connection
// when a network address is unreachable.
pref("network.autodial-helper.enabled", false);
// Switch the keyboard layout per window
pref("intl.keyboard.per_window_layout", false);

3
netwerk/base/moz.build
Просмотреть файл

@ -263,8 +263,6 @@ UNIFIED_SOURCES += [
if CONFIG['MOZ_WIDGET_TOOLKIT'] == 'windows':
SOURCES += [
'nsAutodialWin.cpp',
'nsNativeConnectionHelper.cpp',
'nsURLHelperWin.cpp',
'ShutdownLayer.cpp',
]
@ -279,7 +277,6 @@ else:
if CONFIG['MOZ_ENABLE_QTNETWORK']:
SOURCES += [
'nsAutodialQt.cpp',
]
EXTRA_COMPONENTS += [

46
netwerk/base/nsAutodialQt.cpp
Просмотреть файл

@ -1,46 +0,0 @@
/* 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 "nsQtNetworkManager.h"
#include "nsAutodialQt.h"
#include "nsNetCID.h"
#include "nsCOMPtr.h"
#include "nsIPrefBranch.h"
#include "nsIPrefService.h"
#include "nsIServiceManager.h"
nsAutodial::nsAutodial()
{
}
nsAutodial::~nsAutodial()
{
}
nsresult
nsAutodial::Init()
{
return NS_OK;
}
nsresult
nsAutodial::DialDefault(const char16_t* hostName)
{
if (nsQtNetworkManager::get()->openConnection(QString::fromUtf16((const ushort*)hostName))) {
return NS_OK;
}
return NS_ERROR_FAILURE;
}
bool
nsAutodial::ShouldDialOnNetworkError()
{
if (nsQtNetworkManager::get()->isOnline()) {
return false;
}
return true;
}

26
netwerk/base/nsAutodialQt.h
Просмотреть файл

@ -1,26 +0,0 @@
/* 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/. */
#ifndef NSAUTODIALQT
#define NSAUTODIALQT
#include "nspr.h"
#include "nscore.h"
class nsAutodial
{
public:
nsAutodial();
~nsAutodial();
nsresult Init();
// Dial the default RAS dialup connection.
nsresult DialDefault(const char16_t* hostName);
// Should we try to dial on network error?
bool ShouldDialOnNetworkError();
};
#endif /* NSAUTODIALQT */

591
netwerk/base/nsAutodialWin.cpp
Просмотреть файл

@ -1,591 +0,0 @@
/* 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/. */
// This source is mostly a bunch of Windows API calls. It is only compiled for
// Windows builds.
//
// Registry entries for Autodial mappings are located here:
// HKEY_CURRENT_USER\Software\Microsoft\RAS Autodial\Addresses
#include <windows.h>
#include <winsvc.h>
#include "nsString.h"
#include "nsAutodialWin.h"
#include "mozilla/Logging.h"
#include "nsWindowsHelpers.h"
#include "mozilla/Telemetry.h"
#define AUTODIAL_DEFAULT AUTODIAL_NEVER
//
// Log module for autodial logging...
//
// To enable logging (see prlog.h for full details):
//
// set NSPR_LOG_MODULES=Autodial:5
// set NSPR_LOG_FILE=nspr.log
//
// this enables LogLevel::Debug level information and places all output in
// the file nspr.log
//
static mozilla::LazyLogModule gLog("Autodial");
#undef LOGD
#undef LOGE
#define LOGD(args) MOZ_LOG(gLog, mozilla::LogLevel::Debug, args)
#define LOGE(args) MOZ_LOG(gLog, mozilla::LogLevel::Error, args)
// Don't try to dial again within a few seconds of when user pressed cancel.
#define NO_RETRY_PERIOD_SEC 5
PRIntervalTime nsAutodial::mDontRetryUntil = 0;
// ctor.
nsAutodial::nsAutodial()
: mAutodialBehavior(AUTODIAL_DEFAULT),
mAutodialServiceDialingLocation(-1),
mNumRASConnectionEntries(0)
{
// Initializations that can be made again since RAS OS settings can
// change.
Init();
}
// dtor
nsAutodial::~nsAutodial()
{
}
// Get settings from the OS. These are settings that might change during
// the OS session. Call Init() again to pick up those changes if required.
// Returns NS_ERROR_FAILURE if error or NS_OK if success.
nsresult nsAutodial::Init()
{
mDefaultEntryName[0] = '\0';
mNumRASConnectionEntries = 0;
mAutodialBehavior = QueryAutodialBehavior();
// No need to continue in this case.
if (mAutodialBehavior == AUTODIAL_NEVER)
{
return NS_OK;
}
// Get the number of dialup entries in the phonebook.
mNumRASConnectionEntries = NumRASEntries();
// Get the name of the default entry.
nsresult result = GetDefaultEntryName(mDefaultEntryName,
sizeof(mDefaultEntryName));
return result;
}
// Should we attempt to dial on a network error? Yes if the Internet Options
// configured as such. Yes if the RAS autodial service is running (we'll try to
// force it to dial in that case by adding the network address to its db.)
bool nsAutodial::ShouldDialOnNetworkError()
{
// Don't try to dial again within a few seconds of when user pressed cancel.
if (mDontRetryUntil)
{
PRIntervalTime intervalNow = PR_IntervalNow();
if (intervalNow < mDontRetryUntil)
{
LOGD(("Autodial: Not dialing: too soon."));
return false;
}
}
return ((mAutodialBehavior == AUTODIAL_ALWAYS)
|| (mAutodialBehavior == AUTODIAL_ON_NETWORKERROR)
|| (mAutodialBehavior == AUTODIAL_USE_SERVICE));
}
// The autodial info is set in Control Panel | Internet Options | Connections.
// The values are stored in the registry. This function gets those values from
// the registry and determines if we should never dial, always dial, or dial
// when there is no network found.
int nsAutodial::QueryAutodialBehavior()
{
if (IsAutodialServiceRunning())
{
// Is Autodial service enabled for the current login session?
DWORD disabled = 0;
DWORD size = sizeof(DWORD);
if (RasGetAutodialParamW(RASADP_LoginSessionDisable, &disabled, &size) == ERROR_SUCCESS)
{
if (!disabled)
{
// If current dialing location has autodial on, we'll let the service dial.
mAutodialServiceDialingLocation = GetCurrentLocation();
if (IsAutodialServiceEnabled(mAutodialServiceDialingLocation))
{
return AUTODIAL_USE_SERVICE;
}
}
}
}
// If we get to here, then the service is not going to dial on error, so we
// can dial ourselves if the control panel settings are set up that way.
HKEY hKey = 0;
LONG result = ::RegOpenKeyExW(
HKEY_CURRENT_USER,
L"Software\\Microsoft\\Windows\\CurrentVersion\\Internet Settings",
0,
KEY_READ,
&hKey);
if (result != ERROR_SUCCESS)
{
LOGE(("Autodial: Error opening reg key Internet Settings"));
return AUTODIAL_NEVER;
}
DWORD entryType = 0;
DWORD autodial = 0;
DWORD onDemand = 0;
DWORD paramSize = sizeof(DWORD);
result = ::RegQueryValueExW(hKey, L"EnableAutodial", nullptr, &entryType, (LPBYTE)&autodial, &paramSize);
if (result != ERROR_SUCCESS)
{
::RegCloseKey(hKey);
LOGE(("Autodial: Error reading reg value EnableAutodial."));
return AUTODIAL_NEVER;
}
result = ::RegQueryValueExW(hKey, L"NoNetAutodial", nullptr, &entryType, (LPBYTE)&onDemand, &paramSize);
if (result != ERROR_SUCCESS)
{
::RegCloseKey(hKey);
LOGE(("Autodial: Error reading reg value NoNetAutodial."));
return AUTODIAL_NEVER;
}
::RegCloseKey(hKey);
if (!autodial)
{
return AUTODIAL_NEVER;
}
else
{
if (onDemand)
{
return AUTODIAL_ON_NETWORKERROR;
}
else
{
return AUTODIAL_ALWAYS;
}
}
}
// only do telemetry once per session
static bool reportedAutoDial = false;
// If the RAS autodial service is running, use it. Otherwise, dial
// the default RAS connection. There are two possible RAS dialogs:
// one that dials a single entry, and one that lets the user choose which
// to dial. If there is only one connection entry in the phone book, or
// there are multiple entries but one is defined as the default, we'll use
// the single entry dial dialog. If there are multiple connection entries,
// and none is specified as default, we'll bring up the diallog which lets
// the user select the connection entry to use.
//
// Return values:
// NS_OK: dialing was successful and caller should retry
// all other values indicate that the caller should not retry
nsresult nsAutodial::DialDefault(const char16_t* hostName)
{
mDontRetryUntil = 0;
if (mAutodialBehavior == AUTODIAL_NEVER)
{
return NS_ERROR_FAILURE; // don't retry the network error
}
// If already a RAS connection, bail.
if (IsRASConnected())
{
LOGD(("Autodial: Not dialing: active connection."));
return NS_ERROR_FAILURE; // don't retry
}
// If no dialup connections configured, bail.
if (mNumRASConnectionEntries <= 0)
{
LOGD(("Autodial: Not dialing: no entries."));
return NS_ERROR_FAILURE; // don't retry
}
// If autodial service is running, let it dial. In order for it to dial more
// reliably, we have to add the target address to the autodial database.
// This is the only way the autodial service dial if there is a network
// adapter installed. But even then it might not dial. We have to assume that
// it will though, or we could end up with two attempts to dial on the same
// network error if the user cancels the first one: one from the service and
// one from us.
// See http://msdn.microsoft.com/library/default.asp?url=/library/en-us/rras/ras4over_3dwl.asp
if (mAutodialBehavior == AUTODIAL_USE_SERVICE)
{
AddAddressToAutodialDirectory(hostName);
return NS_ERROR_FAILURE; // don't retry
}
// Do the dialing ourselves.
else
{
// If a default dial entry is configured, use it.
if (mDefaultEntryName[0] != '\0')
{
LOGD(("Autodial: Dialing default: %s.",mDefaultEntryName));
RASDIALDLG rasDialDlg;
memset(&rasDialDlg, 0, sizeof(rasDialDlg));
rasDialDlg.dwSize = sizeof(rasDialDlg);
BOOL dialed =
RasDialDlgW(nullptr, mDefaultEntryName, nullptr, &rasDialDlg);
if (!dialed)
{
if (rasDialDlg.dwError != 0)
{
LOGE(("Autodial ::RasDialDlg failed: Error: %d.",
rasDialDlg.dwError));
}
else
{
mDontRetryUntil = PR_IntervalNow() + PR_SecondsToInterval(NO_RETRY_PERIOD_SEC);
LOGD(("Autodial: User cancelled dial."));
}
return NS_ERROR_FAILURE; // don't retry
}
if (!reportedAutoDial) {
reportedAutoDial = true;
mozilla::Telemetry::Accumulate(mozilla::Telemetry::NETWORK_AUTODIAL, true);
}
LOGD(("Autodial: RAS dialup connection successful."));
}
// If no default connection specified, open the dialup dialog that lets
// the user specifiy which connection to dial.
else
{
LOGD(("Autodial: Prompting for phonebook entry."));
RASPBDLG rasPBDlg;
memset(&rasPBDlg, 0, sizeof(rasPBDlg));
rasPBDlg.dwSize = sizeof(rasPBDlg);
BOOL dialed = RasPhonebookDlgW(nullptr, nullptr, &rasPBDlg);
if (!dialed)
{
if (rasPBDlg.dwError != 0)
{
LOGE(("Autodial: ::RasPhonebookDlg failed: Error = %d.",
rasPBDlg.dwError));
}
else
{
mDontRetryUntil = PR_IntervalNow() + PR_SecondsToInterval(NO_RETRY_PERIOD_SEC);
LOGD(("Autodial: User cancelled dial."));
}
return NS_ERROR_FAILURE; // don't retry
}
if (!reportedAutoDial) {
reportedAutoDial = true;
mozilla::Telemetry::Accumulate(mozilla::Telemetry::NETWORK_AUTODIAL, true);
}
LOGD(("Autodial: RAS dialup connection successful."));
}
}
// Retry because we just established a dialup connection.
return NS_OK;
}
// Check to see if RAS is already connected.
bool nsAutodial::IsRASConnected()
{
DWORD connections;
RASCONN rasConn;
rasConn.dwSize = sizeof(rasConn);
DWORD structSize = sizeof(rasConn);
DWORD result = RasEnumConnectionsW(&rasConn, &structSize, &connections);
// ERROR_BUFFER_TOO_SMALL is OK because we only need one struct.
if (result == ERROR_SUCCESS || result == ERROR_BUFFER_TOO_SMALL)
{
return (connections > 0);
}
LOGE(("Autodial: ::RasEnumConnections failed: Error = %d", result));
return false;
}
// Get the first RAS dial entry name from the phonebook.
nsresult nsAutodial::GetFirstEntryName(wchar_t* entryName, int bufferSize)
{
RASENTRYNAMEW rasEntryName;
rasEntryName.dwSize = sizeof(rasEntryName);
DWORD cb = sizeof(rasEntryName);
DWORD cEntries = 0;
DWORD result =
RasEnumEntriesW(nullptr, nullptr, &rasEntryName, &cb, &cEntries);
// ERROR_BUFFER_TOO_SMALL is OK because we only need one struct.
if (result == ERROR_SUCCESS || result == ERROR_BUFFER_TOO_SMALL)
{
wcsncpy(entryName, rasEntryName.szEntryName,
bufferSize / sizeof(*entryName));
return NS_OK;
}
return NS_ERROR_FAILURE;
}
// Get the number of RAS dial entries in the phonebook.
int nsAutodial::NumRASEntries()
{
RASENTRYNAMEW rasEntryName;
rasEntryName.dwSize = sizeof(rasEntryName);
DWORD cb = sizeof(rasEntryName);
DWORD cEntries = 0;
DWORD result =
RasEnumEntriesW(nullptr, nullptr, &rasEntryName, &cb, &cEntries);
// ERROR_BUFFER_TOO_SMALL is OK because we only need one struct.
if (result == ERROR_SUCCESS || result == ERROR_BUFFER_TOO_SMALL)
{
return (int)cEntries;
}
return 0;
}
// Get the name of the default dial entry.
nsresult nsAutodial::GetDefaultEntryName(wchar_t* entryName, int bufferSize)
{
// No RAS dialup entries.
if (mNumRASConnectionEntries <= 0)
{
return NS_ERROR_FAILURE;
}
// Single RAS dialup entry. Use it as the default to autodial.
if (mNumRASConnectionEntries == 1)
{
return GetFirstEntryName(entryName, bufferSize);
}
// Multiple RAS dialup entries. If a default configured in the registry,
// use it.
//
// For Windows XP: HKCU/Software/Microsoft/RAS Autodial/Default/DefaultInternet.
// or HKLM/Software/Microsoft/RAS Autodial/Default/DefaultInternet.
const wchar_t* key = L"Software\\Microsoft\\RAS Autodial\\Default";
const wchar_t* val = L"DefaultInternet";
HKEY hKey = 0;
LONG result = 0;
// Try HKCU first.
result = ::RegOpenKeyExW(
HKEY_CURRENT_USER,
key,
0,
KEY_READ,
&hKey);
if (result != ERROR_SUCCESS)
{
// If not present, try HKLM.
result = ::RegOpenKeyExW(
HKEY_LOCAL_MACHINE,
key,
0,
KEY_READ,
&hKey);
if (result != ERROR_SUCCESS)
{
return NS_ERROR_FAILURE;
}
}
DWORD entryType = 0;
DWORD buffSize = bufferSize;
result = ::RegQueryValueExW(hKey,
val,
nullptr,
&entryType,
(LPBYTE)entryName,
&buffSize);
::RegCloseKey(hKey);
if (result != ERROR_SUCCESS)
{
// Results in a prompt for which to use at dial time.
return NS_ERROR_FAILURE;
}
return NS_OK;
}
// Determine if the autodial service is running on this PC.
bool nsAutodial::IsAutodialServiceRunning()
{
nsAutoServiceHandle hSCManager(OpenSCManager(nullptr,
SERVICES_ACTIVE_DATABASE,
SERVICE_QUERY_STATUS));
if (hSCManager == nullptr)
{
LOGE(("Autodial: failed to open service control manager. Error %d.",
::GetLastError()));
return false;
}
nsAutoServiceHandle hService(OpenServiceW(hSCManager,
L"RasAuto",
SERVICE_QUERY_STATUS));
if (hSCManager == nullptr)
{
LOGE(("Autodial: failed to open RasAuto service."));
return false;
}
SERVICE_STATUS status;
if (!QueryServiceStatus(hService, &status))
{
LOGE(("Autodial: ::QueryServiceStatus() failed. Error: %d",
::GetLastError()));
return false;
}
return (status.dwCurrentState == SERVICE_RUNNING);
}
// Add the specified address to the autodial directory.
bool nsAutodial::AddAddressToAutodialDirectory(char16ptr_t hostName)
{
// First see if there is already a db entry for this address.
RASAUTODIALENTRYW autodialEntry;
autodialEntry.dwSize = sizeof(autodialEntry);
DWORD size = sizeof(autodialEntry);
DWORD entries = 0;
DWORD result = RasGetAutodialAddressW(hostName,
nullptr,
&autodialEntry,
&size,
&entries);
// If there is already at least 1 entry in db for this address, return.
if (result != ERROR_FILE_NOT_FOUND)
{
LOGD(("Autodial: Address %s already in autodial db.", hostName));
return false;
}
autodialEntry.dwSize = sizeof(autodialEntry);
autodialEntry.dwFlags = 0;
autodialEntry.dwDialingLocation = mAutodialServiceDialingLocation;
GetDefaultEntryName(autodialEntry.szEntry, sizeof(autodialEntry.szEntry));
result = RasSetAutodialAddressW(hostName,
0,
&autodialEntry,
sizeof(autodialEntry),
1);
if (result != ERROR_SUCCESS)
{
LOGE(("Autodial ::RasSetAutodialAddress failed result %d.", result));
return false;
}
LOGD(("Autodial: Added address %s to RAS autodial db for entry %s.",
hostName, NS_ConvertUTF16toUTF8(autodialEntry.szEntry).get()));
return true;
}
// Get the current TAPI dialing location.
int nsAutodial::GetCurrentLocation()
{
HKEY hKey = 0;
LONG result = ::RegOpenKeyExW(
HKEY_LOCAL_MACHINE,
L"Software\\Microsoft\\Windows\\CurrentVersion\\Telephony\\Locations",
0,
KEY_READ,
&hKey);
if (result != ERROR_SUCCESS)
{
LOGE(("Autodial: Error opening reg key ...CurrentVersion\\Telephony\\Locations"));
return -1;
}
DWORD entryType = 0;
DWORD location = 0;
DWORD paramSize = sizeof(DWORD);
result = ::RegQueryValueExW(hKey, L"CurrentID", nullptr, &entryType, (LPBYTE)&location, &paramSize);
if (result != ERROR_SUCCESS)
{
::RegCloseKey(hKey);
LOGE(("Autodial: Error reading reg value CurrentID."));
return -1;
}
::RegCloseKey(hKey);
return location;
}
// Check to see if autodial for the specified location is enabled.
bool nsAutodial::IsAutodialServiceEnabled(int location)
{
if (location < 0)
return false;
BOOL enabled;
if (RasGetAutodialEnableW(location, &enabled) != ERROR_SUCCESS)
{
LOGE(("Autodial: Error calling RasGetAutodialEnable()"));
return false;
}
return enabled;
}

116
netwerk/base/nsAutodialWin.h
Просмотреть файл

@ -1,116 +0,0 @@
/* 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/. */
#ifndef nsAutodialWin_h__
#define nsAutodialWin_h__
#include <windows.h>
#include <ras.h>
#include <rasdlg.h>
#include <raserror.h>
#include "nscore.h"
#include "nspr.h"
// For Windows NT 4, 2000, and XP, we sometimes want to open the RAS dialup
// window ourselves, since those versions aren't very nice about it.
// See bug 93002. If the RAS autodial service is running, (Remote Access
// Auto Connection Manager, aka RasAuto) we will force it to dial
// on network error by adding the target address to the autodial
// database. If the service is not running, we will open the RAS dialogs
// instead.
//
// The OS can be configured to always dial, or dial when there is no
// connection. We implement both by dialing when a network error occurs.
//
// An object of this class checks with the OS when it is constructed and
// remembers those settings. If required, it can be resynced with
// the OS at anytime with the Init() method. At the time of implementation,
// the caller creates an object of this class each time a network error occurs.
// In this case, the initialization overhead is not significant, and it will
// guaranteed to be in sync with OS.
//
// To use, create an instance and call ShouldDialOnNetworkError() to determine
// if you should dial or not. That function only return true for the
// target OS's so the caller doesn't have to deal with OS version checking.
//
class nsAutodial
{
private:
//
// Some helper functions to query the OS for autodial configuration.
//
// Determine if the autodial service is running on this PC.
bool IsAutodialServiceRunning();
// Get the number of RAS connection entries configured from the OS.
int NumRASEntries();
// Get the name of the default connection from the OS.
nsresult GetDefaultEntryName(wchar_t* entryName, int bufferSize);
// Get the name of the first RAS dial entry from the OS.
nsresult GetFirstEntryName(wchar_t* entryName, int bufferSize);
// Check to see if RAS already has a dialup connection going.
bool IsRASConnected();
// Get the autodial behavior from the OS.
int QueryAutodialBehavior();
// Add the specified address to the autodial directory.
bool AddAddressToAutodialDirectory(char16ptr_t hostName);
// Get the current TAPI dialing location.
int GetCurrentLocation();
// See if autodial is enabled for specified location.
bool IsAutodialServiceEnabled(int location);
//
// Autodial behavior. This comes from the Windows registry, set in the ctor.
// Object won't pick up changes to the registry automatically, but can be
// refreshed at anytime by calling Init(). So if the user changed the
// autodial settings, they wouldn't be noticed unless Init() is called.
int mAutodialBehavior;
int mAutodialServiceDialingLocation;
enum { AUTODIAL_NEVER = 1 }; // Never autodial.
enum { AUTODIAL_ALWAYS = 2 }; // Always autodial as set in Internet Options.
enum { AUTODIAL_ON_NETWORKERROR = 3 }; // Autodial when a connection error occurs as set in Internet Options.
enum { AUTODIAL_USE_SERVICE = 4 }; // Use the RAS autodial service to dial.
// Number of RAS connection entries in the phonebook.
int mNumRASConnectionEntries;
// Default connection entry name.
wchar_t mDefaultEntryName[RAS_MaxEntryName + 1];
// Don't try to dial again within a few seconds of when user pressed cancel.
static PRIntervalTime mDontRetryUntil;
public:
// ctor
nsAutodial();
// dtor
virtual ~nsAutodial();
// Get the autodial info from the OS and init this obj with it. Call it any
// time to refresh the object's settings from the OS.
nsresult Init();
// Dial the default RAS dialup connection.
nsresult DialDefault(const char16_t* hostName);
// Should we try to dial on network error?
bool ShouldDialOnNetworkError();
};
#endif // !nsAutodialWin_h__

40
netwerk/base/nsIOService.cpp
Просмотреть файл

@ -60,17 +60,12 @@
#include "nsINetworkInterface.h"
#endif
#if defined(XP_WIN)
#include "nsNativeConnectionHelper.h"
#endif
using namespace mozilla;
using mozilla::net::IsNeckoChild;
using mozilla::net::CaptivePortalService;
#define PORT_PREF_PREFIX "network.security.ports."
#define PORT_PREF(x) PORT_PREF_PREFIX x
#define AUTODIAL_PREF "network.autodial-helper.enabled"
#define MANAGE_OFFLINE_STATUS_PREF "network.manage-offline-status"
#define OFFLINE_MIRRORS_CONNECTIVITY "network.offline-mirrors-connectivity"
@ -192,7 +187,6 @@ nsIOService::nsIOService()
, mHttpHandlerAlreadyShutingDown(false)
, mNetworkLinkServiceInitialized(false)
, mChannelEventSinks(NS_CHANNEL_EVENT_SINK_CATEGORY)
, mAutoDialEnabled(false)
, mNetworkNotifyChanged(true)
, mPreviousWifiState(-1)
, mLastOfflineStateChange(PR_IntervalNow())
@ -236,7 +230,6 @@ nsIOService::Init()
GetPrefBranch(getter_AddRefs(prefBranch));
if (prefBranch) {
prefBranch->AddObserver(PORT_PREF_PREFIX, this, true);
prefBranch->AddObserver(AUTODIAL_PREF, this, true);
prefBranch->AddObserver(MANAGE_OFFLINE_STATUS_PREF, this, true);
prefBranch->AddObserver(NECKO_BUFFER_CACHE_COUNT_PREF, this, true);
prefBranch->AddObserver(NECKO_BUFFER_CACHE_SIZE_PREF, this, true);
@ -309,7 +302,6 @@ nsIOService::InitializeSocketTransportService()
if (mSocketTransportService) {
rv = mSocketTransportService->Init();
NS_ASSERTION(NS_SUCCEEDED(rv), "socket transport service init failed");
mSocketTransportService->SetAutodialEnabled(mAutoDialEnabled);
mSocketTransportService->SetOffline(false);
}
@ -1251,17 +1243,6 @@ nsIOService::PrefsChanged(nsIPrefBranch *prefs, const char *pref)
if (!pref || strcmp(pref, PORT_PREF("banned.override")) == 0)
ParsePortList(prefs, PORT_PREF("banned.override"), true);
if (!pref || strcmp(pref, AUTODIAL_PREF) == 0) {
bool enableAutodial = false;
nsresult rv = prefs->GetBoolPref(AUTODIAL_PREF, &enableAutodial);
// If pref not found, default to disabled.
mAutoDialEnabled = enableAutodial;
if (NS_SUCCEEDED(rv)) {
if (mSocketTransportService)
mSocketTransportService->SetAutodialEnabled(enableAutodial);
}
}
if (!pref || strcmp(pref, MANAGE_OFFLINE_STATUS_PREF) == 0) {
bool manage;
if (mNetworkLinkServiceInitialized &&
@ -1713,27 +1694,6 @@ nsIOService::OnNetworkLinkEvent(const char *data)
return NS_OK;
}
if (!strcmp(data, NS_NETWORK_LINK_DATA_DOWN)) {
// check to make sure this won't collide with Autodial
if (mSocketTransportService) {
bool autodialEnabled = false;
mSocketTransportService->GetAutodialEnabled(&autodialEnabled);
// If autodialing-on-link-down is enabled, check if the OS auto
// dial option is set to always autodial. If so, then we are
// always up for the purposes of offline management.
if (autodialEnabled) {
bool isUp = true;
#if defined(XP_WIN)
// On Windows, we should first check with the OS to see if
// autodial is enabled. If it is enabled then we are allowed
// to manage the offline state.
isUp = nsNativeConnectionHelper::IsAutodialEnabled();
#endif
return SetConnectivityInternal(isUp);
}
}
}
bool isUp = true;
if (!strcmp(data, NS_NETWORK_LINK_DATA_CHANGED)) {
mLastNetworkLinkChange = PR_IntervalNow();

1
netwerk/base/nsIOService.h
Просмотреть файл

@ -178,7 +178,6 @@ private:
nsTArray<int32_t> mRestrictedPortList;
bool mAutoDialEnabled;
bool mNetworkNotifyChanged;
int32_t mPreviousWifiState;
// Hashtable of (appId, nsIAppOffineInfo::mode) pairs

31
netwerk/base/nsNativeConnectionHelper.cpp
Просмотреть файл

@ -1,31 +0,0 @@
/* 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 "nsNativeConnectionHelper.h"
#include "nsAutodialWin.h"
#include "nsIOService.h"
//-----------------------------------------------------------------------------
// API typically invoked on the socket transport thread
//-----------------------------------------------------------------------------
bool
nsNativeConnectionHelper::OnConnectionFailed(const char16_t* hostName)
{
if (gIOService->IsLinkUp())
return false;
nsAutodial autodial;
if (autodial.ShouldDialOnNetworkError())
return NS_SUCCEEDED(autodial.DialDefault(hostName));
return false;
}
bool
nsNativeConnectionHelper::IsAutodialEnabled()
{
nsAutodial autodial;
return autodial.Init() == NS_OK && autodial.ShouldDialOnNetworkError();
}

28
netwerk/base/nsNativeConnectionHelper.h
Просмотреть файл

@ -1,28 +0,0 @@
/* 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/. */
#ifndef nsNativeConnectionHelper_h__
#define nsNativeConnectionHelper_h__
#include "nscore.h"
class nsNativeConnectionHelper
{
public:
/**
* OnConnectionFailed
*
* Return true if the connection should be re-attempted.
*/
static bool OnConnectionFailed(const char16_t* hostName);
/**
* IsAutoDialEnabled
*
* Return true if autodial is enabled in the operating system.
*/
static bool IsAutodialEnabled();
};
#endif // !nsNativeConnectionHelper_h__

6
netwerk/base/nsPISocketTransportService.idl
Просмотреть файл

@ -20,12 +20,6 @@ interface nsPISocketTransportService : nsIRoutedSocketTransportService
void init();
void shutdown();
/**
* controls whether or not the socket transport service should poke
* the autodialer on connection failure.
*/
attribute boolean autodialEnabled;
/**
* controls the TCP sender window clamp
*/

14
netwerk/base/nsSocketTransport2.cpp
Просмотреть файл

@ -39,7 +39,6 @@
#if defined(XP_WIN)
#include "mozilla/WindowsVersion.h"
#include "nsNativeConnectionHelper.h"
#include "ShutdownLayer.h"
#endif
@ -1611,19 +1610,6 @@ nsSocketTransport::RecoverFromError()
}
}
#if defined(XP_WIN)
// If not trying next address, try to make a connection using dialup.
// Retry if that connection is made.
if (!tryAgain) {
bool autodialEnabled;
mSocketTransportService->GetAutodialEnabled(&autodialEnabled);
if (autodialEnabled) {
tryAgain = nsNativeConnectionHelper::OnConnectionFailed(
NS_ConvertUTF8toUTF16(SocketHost()).get());
}
}
#endif
// prepare to try again.
if (tryAgain) {
uint32_t msg;

15
netwerk/base/nsSocketTransportService2.cpp
Просмотреть файл

@ -89,7 +89,6 @@ DebugMutexAutoLock::~DebugMutexAutoLock()
nsSocketTransportService::nsSocketTransportService()
: mThread(nullptr)
, mAutodialEnabled(false)
, mLock("nsSocketTransportService::mLock")
, mInitialized(false)
, mShuttingDown(false)
@ -766,20 +765,6 @@ nsSocketTransportService::CreateUnixDomainTransport(nsIFile *aPath,
return NS_OK;
}
NS_IMETHODIMP
nsSocketTransportService::GetAutodialEnabled(bool *value)
{
*value = mAutodialEnabled;
return NS_OK;
}
NS_IMETHODIMP
nsSocketTransportService::SetAutodialEnabled(bool value)
{
mAutodialEnabled = value;
return NS_OK;
}
NS_IMETHODIMP
nsSocketTransportService::OnDispatchedEvent(nsIThreadInternal *thread)
{

2
netwerk/base/nsSocketTransportService2.h
Просмотреть файл

@ -120,8 +120,6 @@ private:
nsCOMPtr<nsIThread> mThread; // protected by mLock
mozilla::UniquePtr<mozilla::net::PollableEvent> mPollableEvent;
bool mAutodialEnabled;
// pref to control autodial code
// Returns mThread, protecting the get-and-addref with mLock
already_AddRefed<nsIThread> GetThreadSafely();

5
toolkit/components/telemetry/Histograms.json
Просмотреть файл

@ -2841,11 +2841,6 @@
"kind": "boolean",
"description": "The URL path contains !//"
},
"NETWORK_AUTODIAL": {
"expires_in_version": "never",
"kind": "boolean",
"description": "session used autodialer"
},
"NETWORK_SESSION_AT_256FD": {
"expires_in_version": "49",
"kind": "boolean",