1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
|
/**
* GNU LibreJS - A browser add-on to block nonfree nontrivial JavaScript.
*
* Copyright (C) 2018 Giorgio Maone <giorgio@maone.net>
* Copyright (C) 2022 Yuchen Pei <id@ypei.org>
*
* This file is part of GNU LibreJS.
*
* GNU LibreJS 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.
*
* GNU LibreJS 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 GNU LibreJS. If not, see <http://www.gnu.org/licenses/>.
*/
/**
Singleton to handle external licenses, e.g. WebLabels
*/
'use strict';
const { licenses } = require('../license_definitions')
const licensesByLabel = new Map(Object.entries(licenses).map(([id, license]) =>
[
[license.identifier.toUpperCase(), license],
[id.toUpperCase(), license],
[license.licenseName.toUpperCase(), license]
]).flat());
const licensesByUrl = new Map(Object.values(licenses).map(license =>
license.canonicalUrl.map(url => [url, license])).flat());
for (const [id, license] of Object.entries(licenses)) {
if (!license.identifier) {
license.identifier = id;
}
}
const cachedHrefs = new Map();
const ExternalLicenses = {
purgeCache(tabId) {
cachedHrefs.delete(tabId);
},
async check(script) {
const { url, tabId, frameId, documentUrl } = script;
const tabCache = cachedHrefs.get(tabId);
const frameCache = tabCache && tabCache.get(frameId);
const cache = frameCache && frameCache.get(documentUrl);
const scriptInfo = await browser.tabs.sendMessage(tabId, {
action: 'checkLicensedScript',
url,
cache,
}, { frameId });
if (!(scriptInfo && scriptInfo.licenseLinks.length)) {
return null;
}
scriptInfo.licenses = new Set(scriptInfo.licenseLinks.map(
({ label, url }) => {
const uLabel = label.trim().toUpperCase();
const license = licensesByLabel.get(uLabel) || licensesByUrl.get(url) ||
licensesByLabel.get(uLabel.replace(/^GNU-|-(?:OR-LATER|ONLY)$/, ''));
return license ? [license] : [];
}).flat());
scriptInfo.toString = () => {
const licenseIds = [...this.licenses].map(l => l.identifier).sort().join(', ');
return licenseIds
? `Free license${this.licenses.size > 1 ? 's' : ''} (${licenseIds})`
: 'Unknown license(s)';
}
scriptInfo.free = scriptInfo.licenses.size > 0;
return scriptInfo;
},
/**
* moves / creates external license references before any script in the page
* if needed, to have them ready when the first script load is triggered.
* It also caches the external licens href by page URL, to help not actually
* modify the rendered HTML but rather feed the content script on demand.
* Returns true if the document has been actually modified, false otherwise.
*/
optimizeDocument(doc, cachePointer) {
const cache = {};
const { tabId, frameId, documentUrl } = cachePointer;
const frameCache = cachedHrefs.get(tabId) || new Map();
cachedHrefs.set(tabId, frameCache);
frameCache.set(frameId, new Map([[documentUrl, cache]]));
const link = doc.querySelector('link[rel="jslicense"], link[data-jslicense="1"], a[rel="jslicense"], a[data-jslicense="1"]');
if (link) {
const href = link.getAttribute('href');
cache.webLabels = { href };
const move = (link) => !!doc.head.insertBefore(link, doc.head.firstChild);
if (link.parentNode === doc.head) {
// TODO: eliminate let
let node = link.previousElementSibling;
for (; node; node = node.previousElementSibling) {
if (node.tagName.toUpperCase() === 'SCRIPT') {
return move(link);
}
}
} else { // the reference is only in the body
if (link.tagName.toUpperCase() === 'A') {
const newLink = doc.createElement('link');
newLink.rel = 'jslicense';
newLink.setAttribute('href', href);
return move(newLink);
}
return move(link);
}
}
return false;
}
};
module.exports = { ExternalLicenses };
|
