mirror of
https://github.com/mozilla/gecko-dev.git
synced 2025-11-09 12:51:09 +02:00
5dc21d568c
The inclusions were removed with the following very crude script and the
resulting breakage was fixed up by hand. The manual fixups did either
revert the changes done by the script, replace a generic header with a more
specific one or replace a header with a forward declaration.
find . -name "*.idl" | grep -v web-platform | grep -v third_party | while read path; do
interfaces=$(grep "^\(class\|interface\).*:.*" "$path" | cut -d' ' -f2)
if [ -n "$interfaces" ]; then
if [[ "$interfaces" == *$'\n'* ]]; then
regexp="\("
for i in $interfaces; do regexp="$regexp$i\|"; done
regexp="${regexp%%\\\|}\)"
else
regexp="$interfaces"
fi
interface=$(basename "$path")
rg -l "#include.*${interface%%.idl}.h" . | while read path2; do
hits=$(grep -v "#include.*${interface%%.idl}.h" "$path2" | grep -c "$regexp" )
if [ $hits -eq 0 ]; then
echo "Removing ${interface} from ${path2}"
grep -v "#include.*${interface%%.idl}.h" "$path2" > "$path2".tmp
mv -f "$path2".tmp "$path2"
fi
done
fi
done
Differential Revision: https://phabricator.services.mozilla.com/D55444
--HG--
extra : moz-landing-system : lando
284 lines
8.4 KiB
C++
284 lines
8.4 KiB
C++
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode:nil; c-basic-offset: 2 -*- */
|
|
/* 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 "nsParentalControlsService.h"
|
|
#include "nsComponentManagerUtils.h"
|
|
#include "nsString.h"
|
|
#include "nsIArray.h"
|
|
#include "nsIWidget.h"
|
|
#include "nsIInterfaceRequestor.h"
|
|
#include "nsIInterfaceRequestorUtils.h"
|
|
#include "nsIFile.h"
|
|
#include "nsILocalFileWin.h"
|
|
#include "nsArrayUtils.h"
|
|
#include "nsIXULAppInfo.h"
|
|
#include "nsWindowsHelpers.h"
|
|
#include "nsIWindowsRegKey.h"
|
|
#include "mozilla/UniquePtr.h"
|
|
#include "mozilla/WindowsVersion.h"
|
|
|
|
#include <sddl.h>
|
|
|
|
using namespace mozilla;
|
|
|
|
NS_IMPL_ISUPPORTS(nsParentalControlsService, nsIParentalControlsService)
|
|
|
|
// Get the SID string for the user associated with this process's token.
|
|
static nsAutoString GetUserSid() {
|
|
nsAutoString ret;
|
|
HANDLE rawToken;
|
|
BOOL success =
|
|
::OpenProcessToken(::GetCurrentProcess(), TOKEN_QUERY, &rawToken);
|
|
if (!success) {
|
|
return ret;
|
|
}
|
|
nsAutoHandle token(rawToken);
|
|
|
|
DWORD bufLen;
|
|
success = ::GetTokenInformation(token, TokenUser, nullptr, 0, &bufLen);
|
|
if (GetLastError() != ERROR_INSUFFICIENT_BUFFER) {
|
|
return ret;
|
|
}
|
|
|
|
UniquePtr<char[]> buf = MakeUnique<char[]>(bufLen);
|
|
success = ::GetTokenInformation(token, TokenUser, buf.get(), bufLen, &bufLen);
|
|
MOZ_ASSERT(success);
|
|
|
|
if (success) {
|
|
TOKEN_USER* tokenUser = (TOKEN_USER*)(buf.get());
|
|
PSID sid = tokenUser->User.Sid;
|
|
LPWSTR sidStr;
|
|
success = ::ConvertSidToStringSidW(sid, &sidStr);
|
|
if (success) {
|
|
ret = sidStr;
|
|
::LocalFree(sidStr);
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
nsParentalControlsService::nsParentalControlsService()
|
|
: mEnabled(false), mProvider(0), mPC(nullptr) {
|
|
// On at least some builds of Windows 10, the old parental controls API no
|
|
// longer exists, so we have to pull the info we need out of the registry.
|
|
if (IsWin10OrLater()) {
|
|
nsAutoString regKeyName;
|
|
regKeyName.AppendLiteral(
|
|
"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Parental Controls\\"
|
|
"Users\\");
|
|
regKeyName.Append(GetUserSid());
|
|
regKeyName.AppendLiteral("\\Web");
|
|
|
|
nsresult rv;
|
|
nsCOMPtr<nsIWindowsRegKey> regKey =
|
|
do_CreateInstance("@mozilla.org/windows-registry-key;1", &rv);
|
|
if (NS_FAILED(rv)) {
|
|
return;
|
|
}
|
|
|
|
rv = regKey->Open(nsIWindowsRegKey::ROOT_KEY_LOCAL_MACHINE, regKeyName,
|
|
nsIWindowsRegKey::ACCESS_READ);
|
|
if (NS_FAILED(rv)) {
|
|
return;
|
|
}
|
|
|
|
uint32_t filterOn = 0;
|
|
rv = regKey->ReadIntValue(NS_LITERAL_STRING("Filter On"), &filterOn);
|
|
if (NS_FAILED(rv)) {
|
|
return;
|
|
}
|
|
|
|
mEnabled = filterOn != 0;
|
|
return;
|
|
}
|
|
|
|
HRESULT hr;
|
|
CoInitialize(nullptr);
|
|
hr = CoCreateInstance(__uuidof(WindowsParentalControls), nullptr,
|
|
CLSCTX_INPROC, IID_PPV_ARGS(&mPC));
|
|
if (FAILED(hr)) return;
|
|
|
|
RefPtr<IWPCSettings> wpcs;
|
|
if (FAILED(mPC->GetUserSettings(nullptr, getter_AddRefs(wpcs)))) {
|
|
// Not available on this os or not enabled for this user account or we're
|
|
// running as admin
|
|
mPC->Release();
|
|
mPC = nullptr;
|
|
return;
|
|
}
|
|
|
|
DWORD settings = 0;
|
|
wpcs->GetRestrictions(&settings);
|
|
|
|
// If we can't determine specifically whether Web Filtering is on/off (i.e.
|
|
// we're on Windows < 8), then assume it's on unless no restrictions are set.
|
|
bool enable = IsWin8OrLater() ? settings & WPCFLAG_WEB_FILTERED
|
|
: settings != WPCFLAG_NO_RESTRICTION;
|
|
|
|
if (enable) {
|
|
mEnabled = true;
|
|
}
|
|
}
|
|
|
|
nsParentalControlsService::~nsParentalControlsService() {
|
|
if (mPC) mPC->Release();
|
|
|
|
if (mProvider) {
|
|
EventUnregister(mProvider);
|
|
}
|
|
}
|
|
|
|
//------------------------------------------------------------------------
|
|
|
|
NS_IMETHODIMP
|
|
nsParentalControlsService::GetParentalControlsEnabled(bool* aResult) {
|
|
*aResult = false;
|
|
|
|
if (mEnabled) *aResult = true;
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsParentalControlsService::GetBlockFileDownloadsEnabled(bool* aResult) {
|
|
*aResult = false;
|
|
|
|
if (!mEnabled) {
|
|
return NS_ERROR_NOT_AVAILABLE;
|
|
}
|
|
|
|
// If we're on Windows 10 and we don't have the whole API available, then
|
|
// we can't tell if file downloads are allowed, so assume they are to avoid
|
|
// breaking downloads for every single user with parental controls.
|
|
if (!mPC) {
|
|
return NS_OK;
|
|
}
|
|
|
|
RefPtr<IWPCWebSettings> wpcws;
|
|
if (SUCCEEDED(mPC->GetWebSettings(nullptr, getter_AddRefs(wpcws)))) {
|
|
DWORD settings = 0;
|
|
wpcws->GetSettings(&settings);
|
|
if (settings == WPCFLAG_WEB_SETTING_DOWNLOADSBLOCKED) *aResult = true;
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsParentalControlsService::GetLoggingEnabled(bool* aResult) {
|
|
*aResult = false;
|
|
|
|
if (!mEnabled) {
|
|
return NS_ERROR_NOT_AVAILABLE;
|
|
}
|
|
|
|
// If we're on Windows 10 and we don't have the whole API available, then
|
|
// we don't know how logging should be done, so report that it's disabled.
|
|
if (!mPC) {
|
|
return NS_OK;
|
|
}
|
|
|
|
// Check the general purpose logging flag
|
|
RefPtr<IWPCSettings> wpcs;
|
|
if (SUCCEEDED(mPC->GetUserSettings(nullptr, getter_AddRefs(wpcs)))) {
|
|
BOOL enabled = FALSE;
|
|
wpcs->IsLoggingRequired(&enabled);
|
|
if (enabled) *aResult = true;
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
// Post a log event to the system
|
|
NS_IMETHODIMP
|
|
nsParentalControlsService::Log(int16_t aEntryType, bool blocked,
|
|
nsIURI* aSource, nsIFile* aTarget) {
|
|
if (!mEnabled) return NS_ERROR_NOT_AVAILABLE;
|
|
|
|
NS_ENSURE_ARG_POINTER(aSource);
|
|
|
|
// Confirm we should be logging
|
|
bool enabled;
|
|
GetLoggingEnabled(&enabled);
|
|
if (!enabled) return NS_ERROR_NOT_AVAILABLE;
|
|
|
|
// Register a Vista log event provider associated with the parental controls
|
|
// channel.
|
|
if (!mProvider) {
|
|
if (EventRegister(&WPCPROV, nullptr, nullptr, &mProvider) != ERROR_SUCCESS)
|
|
return NS_ERROR_OUT_OF_MEMORY;
|
|
}
|
|
|
|
switch (aEntryType) {
|
|
case ePCLog_URIVisit:
|
|
// Not needed, Vista's web content filter handles this for us
|
|
break;
|
|
case ePCLog_FileDownload:
|
|
LogFileDownload(blocked, aSource, aTarget);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
//------------------------------------------------------------------------
|
|
|
|
// Sends a file download event to the Vista Event Log
|
|
void nsParentalControlsService::LogFileDownload(bool blocked, nsIURI* aSource,
|
|
nsIFile* aTarget) {
|
|
nsAutoCString curi;
|
|
|
|
// Note, EventDataDescCreate is a macro defined in the headers, not a function
|
|
|
|
aSource->GetSpec(curi);
|
|
nsAutoString uri = NS_ConvertUTF8toUTF16(curi);
|
|
|
|
// Get the name of the currently running process
|
|
nsCOMPtr<nsIXULAppInfo> appInfo =
|
|
do_GetService("@mozilla.org/xre/app-info;1");
|
|
nsAutoCString asciiAppName;
|
|
if (appInfo) appInfo->GetName(asciiAppName);
|
|
nsAutoString appName = NS_ConvertUTF8toUTF16(asciiAppName);
|
|
|
|
static const WCHAR fill[] = L"";
|
|
|
|
// See wpcevent.h and msdn for event formats
|
|
EVENT_DATA_DESCRIPTOR eventData[WPC_ARGS_FILEDOWNLOADEVENT_CARGS];
|
|
DWORD dwBlocked = blocked;
|
|
|
|
EventDataDescCreate(&eventData[WPC_ARGS_FILEDOWNLOADEVENT_URL],
|
|
(const void*)uri.get(),
|
|
((ULONG)uri.Length() + 1) * sizeof(WCHAR));
|
|
EventDataDescCreate(&eventData[WPC_ARGS_FILEDOWNLOADEVENT_APPNAME],
|
|
(const void*)appName.get(),
|
|
((ULONG)appName.Length() + 1) * sizeof(WCHAR));
|
|
EventDataDescCreate(&eventData[WPC_ARGS_FILEDOWNLOADEVENT_VERSION],
|
|
(const void*)fill, sizeof(fill));
|
|
EventDataDescCreate(&eventData[WPC_ARGS_FILEDOWNLOADEVENT_BLOCKED],
|
|
(const void*)&dwBlocked, sizeof(dwBlocked));
|
|
|
|
nsCOMPtr<nsILocalFileWin> local(do_QueryInterface(aTarget)); // May be null
|
|
if (local) {
|
|
nsAutoString path;
|
|
local->GetCanonicalPath(path);
|
|
EventDataDescCreate(&eventData[WPC_ARGS_FILEDOWNLOADEVENT_PATH],
|
|
(const void*)path.get(),
|
|
((ULONG)path.Length() + 1) * sizeof(WCHAR));
|
|
} else {
|
|
EventDataDescCreate(&eventData[WPC_ARGS_FILEDOWNLOADEVENT_PATH],
|
|
(const void*)fill, sizeof(fill));
|
|
}
|
|
|
|
EventWrite(mProvider, &WPCEVENT_WEB_FILEDOWNLOAD, ARRAYSIZE(eventData),
|
|
eventData);
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsParentalControlsService::IsAllowed(int16_t aAction, nsIURI* aUri,
|
|
bool* _retval) {
|
|
return NS_ERROR_NOT_AVAILABLE;
|
|
}
|