uBlock/platform/mv3/extension/js/mode-manager.js

397 lines
13 KiB
JavaScript
Raw Normal View History

/*******************************************************************************
uBlock Origin - a browser extension to block requests.
Copyright (C) 2022-present Raymond Hill
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see {http://www.gnu.org/licenses/}.
Home: https://github.com/gorhill/uBlock
*/
/* jshint esversion:11 */
'use strict';
/******************************************************************************/
import {
browser,
dnr,
localRead, localWrite,
sessionRead, sessionWrite,
} from './ext.js';
import {
hostnamesFromMatches,
isDescendantHostnameOfIter,
toBroaderHostname,
} from './utils.js';
import {
TRUSTED_DIRECTIVE_BASE_RULE_ID,
BLOCKING_MODES_RULE_ID,
getDynamicRules
} from './ruleset-manager.js';
/******************************************************************************/
const pruneDescendantHostnamesFromSet = (hostname, hnSet) => {
for ( const hn of hnSet ) {
if ( hn.endsWith(hostname) === false ) { continue; }
if ( hn === hostname ) { continue; }
if ( hn.at(-hostname.length-1) !== '.' ) { continue; }
hnSet.delete(hn);
}
};
/******************************************************************************/
const pruneHostnameFromSet = (hostname, hnSet) => {
let hn = hostname;
for (;;) {
hnSet.delete(hn);
hn = toBroaderHostname(hn);
if ( hn === '*' ) { break; }
}
};
/******************************************************************************/
const eqSets = (setBefore, setAfter) => {
for ( const hn of setAfter ) {
if ( setBefore.has(hn) === false ) { return false; }
}
for ( const hn of setBefore ) {
if ( setAfter.has(hn) === false ) { return false; }
}
return true;
};
/******************************************************************************/
// 0: no blocking
// 1: network
// 2: specific content
// 3: generic content
async function getActualFilteringModeDetails() {
if ( getActualFilteringModeDetails.cache ) {
return getActualFilteringModeDetails.cache;
}
let details = await sessionRead('filteringModeDetails');
if ( details === undefined ) {
details = await localRead('filteringModeDetails');
if ( details === undefined ) {
details = await getActualFilteringModeDetails.convertLegacyStorage();
if ( details === undefined ) {
details = {
network: [ 'all-urls' ],
};
}
}
if ( details ) {
sessionWrite('filteringModeDetails', details);
}
}
const out = {
none: new Set(details.none),
network: new Set(details.network),
extendedSpecific: new Set(details.extendedSpecific),
extendedGeneric: new Set(details.extendedGeneric),
};
getActualFilteringModeDetails.cache = out;
return out;
}
// TODO: To remove after next stable release is widespread (2023-06-04)
getActualFilteringModeDetails.convertLegacyStorage = async function() {
const dynamicRuleMap = await getDynamicRules();
const trustedSiteDirectives = (( ) => {
const rule = dynamicRuleMap.get(TRUSTED_DIRECTIVE_BASE_RULE_ID);
return rule ? rule.condition.requestDomains : [];
})();
const rule = dynamicRuleMap.get(BLOCKING_MODES_RULE_ID);
if ( rule === undefined ) { return; }
dnr.updateDynamicRules({
removeRuleIds: [
BLOCKING_MODES_RULE_ID,
],
});
const details = {
none: trustedSiteDirectives || [],
network: rule.condition.excludedInitiatorDomains || [],
extendedSpecific: rule.condition.excludedRequestDomains || [],
extendedGeneric: rule.condition.initiatorDomains || [],
};
sessionWrite('filteringModeDetails', details);
localWrite('filteringModeDetails', details);
return details;
};
/******************************************************************************/
async function getFilteringModeDetails() {
const actualDetails = await getActualFilteringModeDetails();
return {
none: new Set(actualDetails.none),
network: new Set(actualDetails.network),
extendedSpecific: new Set(actualDetails.extendedSpecific),
extendedGeneric: new Set(actualDetails.extendedGeneric),
};
}
/******************************************************************************/
async function setFilteringModeDetails(afterDetails) {
const actualDetails = await getActualFilteringModeDetails();
if ( eqSets(actualDetails.none, afterDetails.none) === false ) {
const dynamicRuleMap = await getDynamicRules();
const removeRuleIds = [];
if ( dynamicRuleMap.has(TRUSTED_DIRECTIVE_BASE_RULE_ID) ) {
removeRuleIds.push(TRUSTED_DIRECTIVE_BASE_RULE_ID);
dynamicRuleMap.delete(TRUSTED_DIRECTIVE_BASE_RULE_ID);
}
const addRules = [];
if ( afterDetails.none.size !== 0 ) {
const rule = {
id: TRUSTED_DIRECTIVE_BASE_RULE_ID,
action: { type: 'allowAllRequests' },
condition: {
resourceTypes: [ 'main_frame' ],
},
priority: 100,
};
if (
afterDetails.none.size !== 1 ||
afterDetails.none.has('all-urls') === false
) {
rule.condition.requestDomains = Array.from(afterDetails.none);
}
addRules.push(rule);
dynamicRuleMap.set(TRUSTED_DIRECTIVE_BASE_RULE_ID, rule);
}
if ( addRules.length !== 0 || removeRuleIds.length !== 0 ) {
const updateOptions = {};
if ( addRules.length ) {
updateOptions.addRules = addRules;
}
if ( removeRuleIds.length ) {
updateOptions.removeRuleIds = removeRuleIds;
}
await dnr.updateDynamicRules(updateOptions);
}
}
const data = {
none: Array.from(afterDetails.none),
network: Array.from(afterDetails.network),
extendedSpecific: Array.from(afterDetails.extendedSpecific),
extendedGeneric: Array.from(afterDetails.extendedGeneric),
};
sessionWrite('filteringModeDetails', data);
localWrite('filteringModeDetails', data);
getActualFilteringModeDetails.cache = undefined;
}
/******************************************************************************/
async function getFilteringMode(hostname) {
const filteringModes = await getFilteringModeDetails();
const {
none,
network,
extendedSpecific,
extendedGeneric,
} = filteringModes;
if ( none.has(hostname) ) { return 0; }
if ( none.has('all-urls') === false ) {
if ( isDescendantHostnameOfIter(hostname, none) ) { return 0; }
}
if ( network.has(hostname) ) { return 1; }
if ( network.has('all-urls') === false ) {
if ( isDescendantHostnameOfIter(hostname, network) ) { return 1; }
}
if ( extendedSpecific.has(hostname) ) { return 2; }
if ( extendedSpecific.has('all-urls') === false ) {
if ( isDescendantHostnameOfIter(hostname, extendedSpecific) ) { return 2; }
}
if ( extendedGeneric.has(hostname) ) { return 3; }
if ( extendedGeneric.has('all-urls') === false ) {
if ( isDescendantHostnameOfIter(hostname, extendedGeneric) ) { return 3; }
}
return getDefaultFilteringMode();
}
/******************************************************************************/
async function setFilteringMode(hostname, afterLevel) {
if ( hostname === 'all-urls' ) {
return setDefaultFilteringMode(afterLevel);
}
const [
beforeLevel,
defaultLevel,
filteringModes
] = await Promise.all([
getFilteringMode(hostname),
getDefaultFilteringMode(),
getFilteringModeDetails(),
]);
if ( afterLevel === beforeLevel ) { return afterLevel; }
const {
none,
network,
extendedSpecific,
extendedGeneric,
} = filteringModes;
switch ( beforeLevel ) {
case 0:
pruneHostnameFromSet(hostname, none);
break;
case 1:
pruneHostnameFromSet(hostname, network);
break;
case 2:
pruneHostnameFromSet(hostname, extendedSpecific);
break;
case 3:
pruneHostnameFromSet(hostname, extendedGeneric);
break;
}
if ( afterLevel !== defaultLevel ) {
switch ( afterLevel ) {
case 0:
if ( isDescendantHostnameOfIter(hostname, none) === false ) {
filteringModes.none.add(hostname);
pruneDescendantHostnamesFromSet(hostname, none);
}
break;
case 1:
if ( isDescendantHostnameOfIter(hostname, network) === false ) {
filteringModes.network.add(hostname);
pruneDescendantHostnamesFromSet(hostname, network);
}
break;
case 2:
if ( isDescendantHostnameOfIter(hostname, extendedSpecific) === false ) {
filteringModes.extendedSpecific.add(hostname);
pruneDescendantHostnamesFromSet(hostname, extendedSpecific);
}
break;
case 3:
if ( isDescendantHostnameOfIter(hostname, extendedGeneric) === false ) {
filteringModes.extendedGeneric.add(hostname);
pruneDescendantHostnamesFromSet(hostname, extendedGeneric);
}
break;
}
}
await setFilteringModeDetails(filteringModes);
return getFilteringMode(hostname);
}
/******************************************************************************/
async function getDefaultFilteringMode() {
const filteringModes = await getFilteringModeDetails();
if ( filteringModes.none.has('all-urls') ) { return 0; }
if ( filteringModes.network.has('all-urls') ) { return 1; }
if ( filteringModes.extendedSpecific.has('all-urls') ) { return 2; }
if ( filteringModes.extendedGeneric.has('all-urls') ) { return 3; }
return 1;
}
/******************************************************************************/
async function setDefaultFilteringMode(afterLevel) {
const [ beforeLevel, filteringModes ] = await Promise.all([
getDefaultFilteringMode(),
getFilteringModeDetails(),
]);
if ( afterLevel === beforeLevel ) { return afterLevel; }
switch ( afterLevel ) {
case 0:
filteringModes.none.clear();
filteringModes.none.add('all-urls');
break;
case 1:
filteringModes.network.clear();
filteringModes.network.add('all-urls');
break;
case 2:
filteringModes.extendedSpecific.clear();
filteringModes.extendedSpecific.add('all-urls');
break;
case 3:
filteringModes.extendedGeneric.clear();
filteringModes.extendedGeneric.add('all-urls');
break;
}
switch ( beforeLevel ) {
case 0:
filteringModes.none.delete('all-urls');
break;
case 1:
filteringModes.network.delete('all-urls');
break;
case 2:
filteringModes.extendedSpecific.delete('all-urls');
break;
case 3:
filteringModes.extendedGeneric.delete('all-urls');
break;
}
await setFilteringModeDetails(filteringModes);
return getDefaultFilteringMode();
}
/******************************************************************************/
async function syncWithBrowserPermissions() {
const permissions = await browser.permissions.getAll();
const allowedHostnames = new Set(hostnamesFromMatches(permissions.origins || []));
const beforeMode = await getDefaultFilteringMode();
let modified = false;
if ( beforeMode > 1 && allowedHostnames.has('all-urls') === false ) {
await setDefaultFilteringMode(1);
modified = true;
}
const afterMode = await getDefaultFilteringMode();
if ( afterMode > 1 ) { return false; }
const filteringModes = await getFilteringModeDetails();
const { extendedSpecific, extendedGeneric } = filteringModes;
for ( const hn of extendedSpecific ) {
if ( allowedHostnames.has(hn) ) { continue; }
extendedSpecific.delete(hn);
modified = true;
}
for ( const hn of extendedGeneric ) {
if ( allowedHostnames.has(hn) ) { continue; }
extendedGeneric.delete(hn);
modified = true;
}
await setFilteringModeDetails(filteringModes);
return modified;
}
/******************************************************************************/
export {
getFilteringMode,
setFilteringMode,
getDefaultFilteringMode,
setDefaultFilteringMode,
getFilteringModeDetails,
syncWithBrowserPermissions,
};