Rene Kievits
@@ -0,0 +1,871 @@
|
||||
/**
|
||||
* LG Update Blocker - root service.
|
||||
*
|
||||
* Everything this service does is reversible and is applied in layers:
|
||||
*
|
||||
* 1. hosts - point LG's firmware update servers at 127.0.0.1
|
||||
* 2. purge - delete the firmware image the TV already staged
|
||||
* 3. lock - bind-mount an empty read-only dir over the staging dir
|
||||
* 4. settings - switch off the update-related com.webos.settingsservice keys
|
||||
* 5. services - stop the update related upstart jobs (advanced, opt-in)
|
||||
*
|
||||
* / is read-only on webOS, and /tmp, /etc and the mount namespace are reset on
|
||||
* every boot, so each layer is re-applied by a boot hook script dropped into
|
||||
* /var/lib/webosbrew/init.d (run by the Homebrew Channel startup script).
|
||||
*
|
||||
* Written in ES5 without dependencies - it runs on the TV's own node with the
|
||||
* platform-provided webos-service module and nothing else.
|
||||
*/
|
||||
|
||||
'use strict';
|
||||
|
||||
var fs = require('fs');
|
||||
var path = require('path');
|
||||
var childProcess = require('child_process');
|
||||
var Service = require('webos-service');
|
||||
|
||||
var pkgInfo = require('./package.json');
|
||||
|
||||
var service = new Service(pkgInfo.name);
|
||||
service.activityManager.idleTimeout = 300;
|
||||
|
||||
var SLUG = 'lgupdateblocker';
|
||||
var STATE_DIR = '/var/lib/webosbrew/' + SLUG;
|
||||
var CONFIG_PATH = STATE_DIR + '/config.json';
|
||||
var HOSTS_LIST_PATH = STATE_DIR + '/hosts.txt';
|
||||
var SETTINGS_BACKUP_PATH = STATE_DIR + '/settings-backup.json';
|
||||
var EMPTY_DIR = STATE_DIR + '/empty';
|
||||
var BOOT_LOG_PATH = STATE_DIR + '/boot.log';
|
||||
var BOOT_HOOK_DIR = '/var/lib/webosbrew/init.d';
|
||||
var BOOT_HOOK_PATH = BOOT_HOOK_DIR + '/' + SLUG;
|
||||
|
||||
var HOSTS_PATH = '/etc/hosts';
|
||||
var HOSTS_TMP = '/tmp/' + SLUG + '-hosts';
|
||||
var MARKER_BEGIN = '# >>> lg-update-blocker >>>';
|
||||
var MARKER_END = '# <<< lg-update-blocker <<<';
|
||||
|
||||
var BUNDLED_HOSTS = path.join(__dirname, 'data', 'lg-update-hosts.txt');
|
||||
|
||||
/* Directories where the TV stages a downloaded firmware image. A staged image
|
||||
* keeps the "update is ready" popup coming back even when the update servers
|
||||
* are unreachable. Only paths below /mnt/lg are ever touched. */
|
||||
var CACHE_DIRS = [
|
||||
'/mnt/lg/cmn_data/swupdate',
|
||||
'/mnt/lg/swupdate',
|
||||
'/mnt/lg/cmn_data/var/palm/data/com.webos.service.swupdate'
|
||||
];
|
||||
var CACHE_GUARD = '/mnt/lg/';
|
||||
|
||||
var UPSTART_DIR = '/etc/init';
|
||||
var JOB_PATTERN = /(swupdate|softwareupdate|firmware|fota|update|upgrade|nsu)/i;
|
||||
|
||||
var SETTINGS_CATEGORIES = ['option', 'general', 'network', 'commercial'];
|
||||
var SETTINGS_KEY_PATTERN = /(update|upgrade|firmware|ota)/i;
|
||||
|
||||
var DEFAULT_CONFIG = {
|
||||
blockHosts: true,
|
||||
purgeCache: true,
|
||||
lockCache: false,
|
||||
disableSettings: true,
|
||||
stopServices: false
|
||||
};
|
||||
var CONFIG_KEYS = Object.keys(DEFAULT_CONFIG);
|
||||
|
||||
/* ------------------------------------------------------------------ utils */
|
||||
|
||||
function isRoot() {
|
||||
return typeof process.getuid === 'function' && process.getuid() === 0;
|
||||
}
|
||||
|
||||
function exists(target) {
|
||||
try {
|
||||
fs.statSync(target);
|
||||
return true;
|
||||
} catch (err) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
function isDirectory(target) {
|
||||
try {
|
||||
return fs.statSync(target).isDirectory();
|
||||
} catch (err) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
function mkdirp(dir) {
|
||||
if (isDirectory(dir)) return;
|
||||
mkdirp(path.dirname(dir));
|
||||
try {
|
||||
fs.mkdirSync(dir);
|
||||
} catch (err) {
|
||||
if (!isDirectory(dir)) throw err;
|
||||
}
|
||||
}
|
||||
|
||||
function readFile(target, fallback) {
|
||||
try {
|
||||
return fs.readFileSync(target, 'utf8');
|
||||
} catch (err) {
|
||||
return fallback;
|
||||
}
|
||||
}
|
||||
|
||||
function readJson(target, fallback) {
|
||||
try {
|
||||
return JSON.parse(fs.readFileSync(target, 'utf8'));
|
||||
} catch (err) {
|
||||
return fallback;
|
||||
}
|
||||
}
|
||||
|
||||
function writeJson(target, value) {
|
||||
mkdirp(path.dirname(target));
|
||||
fs.writeFileSync(target, JSON.stringify(value, null, 2) + '\n');
|
||||
}
|
||||
|
||||
function sh(command) {
|
||||
try {
|
||||
var out = childProcess.execSync(command + ' 2>&1', { encoding: 'utf8', timeout: 30000 });
|
||||
return { ok: true, output: String(out || '').trim() };
|
||||
} catch (err) {
|
||||
var output = (err && (err.stdout || err.message)) || '';
|
||||
return { ok: false, output: String(output).trim() };
|
||||
}
|
||||
}
|
||||
|
||||
function Log() {
|
||||
this.lines = [];
|
||||
}
|
||||
Log.prototype.add = function (line) {
|
||||
console.info(line);
|
||||
this.lines.push(line);
|
||||
return this;
|
||||
};
|
||||
|
||||
/* ----------------------------------------------------------------- config */
|
||||
|
||||
function readConfig() {
|
||||
var stored = readJson(CONFIG_PATH, {});
|
||||
var config = {};
|
||||
CONFIG_KEYS.forEach(function (key) {
|
||||
config[key] = typeof stored[key] === 'boolean' ? stored[key] : DEFAULT_CONFIG[key];
|
||||
});
|
||||
return config;
|
||||
}
|
||||
|
||||
function mergeConfig(config, payload) {
|
||||
var merged = {};
|
||||
CONFIG_KEYS.forEach(function (key) {
|
||||
merged[key] = typeof payload[key] === 'boolean' ? payload[key] : config[key];
|
||||
});
|
||||
return merged;
|
||||
}
|
||||
|
||||
function anyEnabled(config) {
|
||||
return CONFIG_KEYS.some(function (key) {
|
||||
return config[key];
|
||||
});
|
||||
}
|
||||
|
||||
/* ------------------------------------------------------------------ hosts */
|
||||
|
||||
function readDomains() {
|
||||
var raw = readFile(BUNDLED_HOSTS, null);
|
||||
if (raw === null) raw = readFile(HOSTS_LIST_PATH, '');
|
||||
return raw
|
||||
.split('\n')
|
||||
.map(function (line) {
|
||||
return line.replace(/#.*$/, '').trim();
|
||||
})
|
||||
.filter(function (line) {
|
||||
return line.length > 0 && line.indexOf(' ') === -1;
|
||||
});
|
||||
}
|
||||
|
||||
function mountTargets() {
|
||||
return readFile('/proc/mounts', '')
|
||||
.split('\n')
|
||||
.map(function (line) {
|
||||
return line.split(' ')[1];
|
||||
})
|
||||
.filter(Boolean);
|
||||
}
|
||||
|
||||
function isMountPoint(target) {
|
||||
return mountTargets().indexOf(target) !== -1;
|
||||
}
|
||||
|
||||
function hostsWritable() {
|
||||
try {
|
||||
fs.appendFileSync(HOSTS_PATH, '');
|
||||
return true;
|
||||
} catch (err) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
/* / is mounted read-only, so /etc/hosts gets replaced by a bind mount of a
|
||||
* writable copy in /tmp - the same trick the Homebrew Channel startup script
|
||||
* uses (and it happily stacks with it). */
|
||||
function makeHostsWritable(log) {
|
||||
if (hostsWritable()) return true;
|
||||
try {
|
||||
fs.writeFileSync(HOSTS_TMP, readFile(HOSTS_PATH, ''));
|
||||
fs.chmodSync(HOSTS_TMP, parseInt('644', 8));
|
||||
} catch (err) {
|
||||
log.add('! could not stage a writable hosts file: ' + err.message);
|
||||
return false;
|
||||
}
|
||||
var res = sh('mount --bind ' + HOSTS_TMP + ' ' + HOSTS_PATH);
|
||||
if (!res.ok || !hostsWritable()) {
|
||||
log.add('! bind mount of ' + HOSTS_PATH + ' failed: ' + res.output);
|
||||
return false;
|
||||
}
|
||||
log.add('bind-mounted a writable ' + HOSTS_PATH + ' (from ' + HOSTS_TMP + ')');
|
||||
return true;
|
||||
}
|
||||
|
||||
function stripHostsBlock(content) {
|
||||
var out = [];
|
||||
var inside = false;
|
||||
content.split('\n').forEach(function (line) {
|
||||
if (line.indexOf(MARKER_BEGIN) === 0) {
|
||||
inside = true;
|
||||
return;
|
||||
}
|
||||
if (inside) {
|
||||
if (line.indexOf(MARKER_END) === 0) inside = false;
|
||||
return;
|
||||
}
|
||||
out.push(line);
|
||||
});
|
||||
return out.join('\n').replace(/\n{3,}$/, '\n');
|
||||
}
|
||||
|
||||
function buildHostsBlock(domains) {
|
||||
var lines = [MARKER_BEGIN];
|
||||
domains.forEach(function (domain) {
|
||||
lines.push('127.0.0.1 ' + domain);
|
||||
lines.push('::1 ' + domain);
|
||||
});
|
||||
lines.push(MARKER_END);
|
||||
return lines.join('\n') + '\n';
|
||||
}
|
||||
|
||||
function hostsBlockedDomains() {
|
||||
var content = readFile(HOSTS_PATH, '');
|
||||
if (content.indexOf(MARKER_BEGIN) === -1) return 0;
|
||||
return readDomains().filter(function (domain) {
|
||||
return content.indexOf(' ' + domain) !== -1;
|
||||
}).length;
|
||||
}
|
||||
|
||||
function applyHosts(log) {
|
||||
var domains = readDomains();
|
||||
if (!domains.length) {
|
||||
log.add('! no update domains found to block');
|
||||
return false;
|
||||
}
|
||||
if (!makeHostsWritable(log)) return false;
|
||||
|
||||
var content = stripHostsBlock(readFile(HOSTS_PATH, ''));
|
||||
if (content.length && content.charAt(content.length - 1) !== '\n') content += '\n';
|
||||
fs.writeFileSync(HOSTS_PATH, content + buildHostsBlock(domains));
|
||||
log.add('blocked ' + domains.length + ' update hostnames in ' + HOSTS_PATH);
|
||||
return true;
|
||||
}
|
||||
|
||||
function removeHosts(log) {
|
||||
var content = readFile(HOSTS_PATH, '');
|
||||
if (content.indexOf(MARKER_BEGIN) === -1) {
|
||||
log.add('no hosts entries to remove');
|
||||
return true;
|
||||
}
|
||||
if (!hostsWritable()) {
|
||||
log.add('! ' + HOSTS_PATH + ' is not writable, entries stay until reboot');
|
||||
return false;
|
||||
}
|
||||
fs.writeFileSync(HOSTS_PATH, stripHostsBlock(content));
|
||||
log.add('removed update hostnames from ' + HOSTS_PATH);
|
||||
return true;
|
||||
}
|
||||
|
||||
/* ------------------------------------------------------- staged firmware */
|
||||
|
||||
function rmrf(target) {
|
||||
if (target.indexOf(CACHE_GUARD) !== 0) throw new Error('refusing to delete ' + target);
|
||||
var stat;
|
||||
try {
|
||||
stat = fs.lstatSync(target);
|
||||
} catch (err) {
|
||||
return;
|
||||
}
|
||||
if (stat.isDirectory()) {
|
||||
fs.readdirSync(target).forEach(function (entry) {
|
||||
rmrf(path.join(target, entry));
|
||||
});
|
||||
fs.rmdirSync(target);
|
||||
} else {
|
||||
fs.unlinkSync(target);
|
||||
}
|
||||
}
|
||||
|
||||
function dirBytes(target, depth) {
|
||||
var total = 0;
|
||||
var stat;
|
||||
try {
|
||||
stat = fs.lstatSync(target);
|
||||
} catch (err) {
|
||||
return 0;
|
||||
}
|
||||
if (!stat.isDirectory()) return stat.size;
|
||||
if (depth > 8) return 0;
|
||||
fs.readdirSync(target).forEach(function (entry) {
|
||||
total += dirBytes(path.join(target, entry), depth + 1);
|
||||
});
|
||||
return total;
|
||||
}
|
||||
|
||||
function cacheStatus() {
|
||||
return CACHE_DIRS.filter(isDirectory).map(function (dir) {
|
||||
var entries = [];
|
||||
try {
|
||||
entries = fs.readdirSync(dir);
|
||||
} catch (err) {
|
||||
entries = [];
|
||||
}
|
||||
return {
|
||||
path: dir,
|
||||
entries: entries,
|
||||
bytes: dirBytes(dir, 0),
|
||||
locked: isMountPoint(dir)
|
||||
};
|
||||
});
|
||||
}
|
||||
|
||||
function purgeCache(log) {
|
||||
var dirs = CACHE_DIRS.filter(isDirectory);
|
||||
if (!dirs.length) {
|
||||
log.add('no firmware staging directory present on this TV');
|
||||
return;
|
||||
}
|
||||
dirs.forEach(function (dir) {
|
||||
if (isMountPoint(dir)) {
|
||||
log.add(dir + ' is locked (empty read-only mount), nothing staged');
|
||||
return;
|
||||
}
|
||||
var entries;
|
||||
try {
|
||||
entries = fs.readdirSync(dir);
|
||||
} catch (err) {
|
||||
log.add('! cannot read ' + dir + ': ' + err.message);
|
||||
return;
|
||||
}
|
||||
if (!entries.length) {
|
||||
log.add(dir + ' is already empty');
|
||||
return;
|
||||
}
|
||||
var removed = 0;
|
||||
entries.forEach(function (entry) {
|
||||
try {
|
||||
rmrf(path.join(dir, entry));
|
||||
removed += 1;
|
||||
} catch (err) {
|
||||
log.add('! could not delete ' + entry + ' in ' + dir + ': ' + err.message);
|
||||
}
|
||||
});
|
||||
log.add('purged ' + removed + '/' + entries.length + ' staged item(s) from ' + dir);
|
||||
});
|
||||
}
|
||||
|
||||
function lockCache(log) {
|
||||
var dirs = CACHE_DIRS.filter(isDirectory);
|
||||
if (!dirs.length) {
|
||||
log.add('no firmware staging directory to lock');
|
||||
return;
|
||||
}
|
||||
mkdirp(EMPTY_DIR);
|
||||
dirs.forEach(function (dir) {
|
||||
if (isMountPoint(dir)) {
|
||||
log.add(dir + ' is already locked');
|
||||
return;
|
||||
}
|
||||
var res = sh('mount -o bind,ro ' + EMPTY_DIR + ' ' + dir);
|
||||
if (!res.ok) {
|
||||
log.add('! could not lock ' + dir + ': ' + res.output);
|
||||
return;
|
||||
}
|
||||
// Older busybox mount ignores "ro" on the initial bind, so remount.
|
||||
sh('mount -o bind,remount,ro ' + EMPTY_DIR + ' ' + dir);
|
||||
log.add('locked ' + dir + ' (empty, read-only)');
|
||||
});
|
||||
}
|
||||
|
||||
function unlockCache(log) {
|
||||
CACHE_DIRS.forEach(function (dir) {
|
||||
if (!isMountPoint(dir)) return;
|
||||
var res = sh('umount ' + dir);
|
||||
log.add(res.ok ? 'unlocked ' + dir : '! could not unlock ' + dir + ': ' + res.output);
|
||||
});
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------- upstart jobs */
|
||||
|
||||
function discoverJobs() {
|
||||
var entries;
|
||||
try {
|
||||
entries = fs.readdirSync(UPSTART_DIR);
|
||||
} catch (err) {
|
||||
return [];
|
||||
}
|
||||
return entries
|
||||
.filter(function (entry) {
|
||||
return /\.conf$/.test(entry) && JOB_PATTERN.test(entry);
|
||||
})
|
||||
.map(function (entry) {
|
||||
return entry.replace(/\.conf$/, '');
|
||||
})
|
||||
.sort();
|
||||
}
|
||||
|
||||
function stopJobs(jobs, log) {
|
||||
if (!jobs.length) {
|
||||
log.add('no update-related upstart jobs found');
|
||||
return;
|
||||
}
|
||||
jobs.forEach(function (job) {
|
||||
var res = sh('initctl stop ' + job);
|
||||
if (!res.ok) res = sh('stop ' + job);
|
||||
log.add(res.ok ? 'stopped upstart job ' + job : '! could not stop ' + job + ': ' + res.output);
|
||||
});
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------- settings */
|
||||
|
||||
function callLuna(uri, params, callback) {
|
||||
var done = false;
|
||||
var timer = setTimeout(function () {
|
||||
if (done) return;
|
||||
done = true;
|
||||
callback({ returnValue: false, errorText: 'timed out' });
|
||||
}, 4000);
|
||||
|
||||
function finish(payload) {
|
||||
if (done) return;
|
||||
done = true;
|
||||
clearTimeout(timer);
|
||||
callback(payload);
|
||||
}
|
||||
|
||||
try {
|
||||
service.call(uri, params || {}, function (message) {
|
||||
finish((message && message.payload) || {});
|
||||
});
|
||||
} catch (err) {
|
||||
finish({ returnValue: false, errorText: err.message });
|
||||
}
|
||||
}
|
||||
|
||||
/** Value that turns a setting off, or null when it is off/not a toggle. */
|
||||
function disabledValueFor(value) {
|
||||
if (value === true) return false;
|
||||
if (typeof value === 'string') {
|
||||
var normalized = value.toLowerCase();
|
||||
if (normalized === 'on') return 'off';
|
||||
if (normalized === 'true') return 'false';
|
||||
if (normalized === 'yes') return 'no';
|
||||
if (normalized === 'enable' || normalized === 'enabled') return 'disable';
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
function discoverSettings(callback) {
|
||||
var found = [];
|
||||
var index = 0;
|
||||
|
||||
function next() {
|
||||
if (index >= SETTINGS_CATEGORIES.length) {
|
||||
callback(found);
|
||||
return;
|
||||
}
|
||||
var category = SETTINGS_CATEGORIES[index];
|
||||
index += 1;
|
||||
callLuna('luna://com.webos.settingsservice/getSystemSettings', { category: category }, function (payload) {
|
||||
var settings = (payload && payload.settings) || {};
|
||||
Object.keys(settings).forEach(function (key) {
|
||||
if (!SETTINGS_KEY_PATTERN.test(key)) return;
|
||||
found.push({
|
||||
category: category,
|
||||
key: key,
|
||||
value: settings[key],
|
||||
canDisable: disabledValueFor(settings[key]) !== null
|
||||
});
|
||||
});
|
||||
next();
|
||||
});
|
||||
}
|
||||
|
||||
next();
|
||||
}
|
||||
|
||||
function disableSettings(log, callback) {
|
||||
discoverSettings(function (found) {
|
||||
var targets = found.filter(function (entry) {
|
||||
return entry.canDisable;
|
||||
});
|
||||
|
||||
if (!found.length) {
|
||||
log.add('no update-related system settings exposed by this firmware');
|
||||
callback();
|
||||
return;
|
||||
}
|
||||
if (!targets.length) {
|
||||
log.add('update-related settings are already off: ' + found.map(function (e) {
|
||||
return e.key + '=' + JSON.stringify(e.value);
|
||||
}).join(', '));
|
||||
callback();
|
||||
return;
|
||||
}
|
||||
|
||||
var backup = readJson(SETTINGS_BACKUP_PATH, {});
|
||||
targets.forEach(function (entry) {
|
||||
var id = entry.category + '.' + entry.key;
|
||||
if (!(id in backup)) backup[id] = entry.value;
|
||||
});
|
||||
try {
|
||||
writeJson(SETTINGS_BACKUP_PATH, backup);
|
||||
} catch (err) {
|
||||
log.add('! could not save settings backup: ' + err.message);
|
||||
}
|
||||
|
||||
var index = 0;
|
||||
function next() {
|
||||
if (index >= targets.length) {
|
||||
callback();
|
||||
return;
|
||||
}
|
||||
var entry = targets[index];
|
||||
index += 1;
|
||||
var settings = {};
|
||||
settings[entry.key] = disabledValueFor(entry.value);
|
||||
callLuna(
|
||||
'luna://com.webos.settingsservice/setSystemSettings',
|
||||
{ category: entry.category, settings: settings },
|
||||
function (payload) {
|
||||
if (payload && payload.returnValue) {
|
||||
log.add('turned off ' + entry.category + '/' + entry.key +
|
||||
' (' + JSON.stringify(entry.value) + ' -> ' + JSON.stringify(settings[entry.key]) + ')');
|
||||
} else {
|
||||
log.add('! could not change ' + entry.category + '/' + entry.key + ': ' +
|
||||
((payload && payload.errorText) || 'unknown error'));
|
||||
}
|
||||
next();
|
||||
}
|
||||
);
|
||||
}
|
||||
next();
|
||||
});
|
||||
}
|
||||
|
||||
function restoreSettings(log, callback) {
|
||||
var backup = readJson(SETTINGS_BACKUP_PATH, null);
|
||||
if (!backup || !Object.keys(backup).length) {
|
||||
log.add('no system settings to restore');
|
||||
callback();
|
||||
return;
|
||||
}
|
||||
var ids = Object.keys(backup);
|
||||
var index = 0;
|
||||
function next() {
|
||||
if (index >= ids.length) {
|
||||
try {
|
||||
fs.unlinkSync(SETTINGS_BACKUP_PATH);
|
||||
} catch (err) {
|
||||
/* nothing to clean up */
|
||||
}
|
||||
callback();
|
||||
return;
|
||||
}
|
||||
var id = ids[index];
|
||||
index += 1;
|
||||
var split = id.indexOf('.');
|
||||
var category = id.slice(0, split);
|
||||
var key = id.slice(split + 1);
|
||||
var settings = {};
|
||||
settings[key] = backup[id];
|
||||
callLuna(
|
||||
'luna://com.webos.settingsservice/setSystemSettings',
|
||||
{ category: category, settings: settings },
|
||||
function (payload) {
|
||||
log.add((payload && payload.returnValue ? 'restored ' : '! could not restore ') +
|
||||
category + '/' + key + ' = ' + JSON.stringify(backup[id]));
|
||||
next();
|
||||
}
|
||||
);
|
||||
}
|
||||
next();
|
||||
}
|
||||
|
||||
/* -------------------------------------------------------------- boot hook */
|
||||
|
||||
function bootHookScript(config, domains, jobs) {
|
||||
return [
|
||||
'#!/bin/sh',
|
||||
'# LG Update Blocker boot hook - generated by ' + pkgInfo.name + ' v' + pkgInfo.version + '.',
|
||||
'# Regenerated every time the settings are applied; delete it to disable.',
|
||||
'',
|
||||
'STATE=' + STATE_DIR,
|
||||
'LOG=' + BOOT_LOG_PATH,
|
||||
'HOSTS_TMP=' + HOSTS_TMP,
|
||||
'BLOCK_HOSTS=' + (config.blockHosts ? 1 : 0),
|
||||
'PURGE_CACHE=' + (config.purgeCache ? 1 : 0),
|
||||
'LOCK_CACHE=' + (config.lockCache ? 1 : 0),
|
||||
'STOP_SERVICES=' + (config.stopServices ? 1 : 0),
|
||||
'CACHE_DIRS="' + CACHE_DIRS.join(' ') + '"',
|
||||
'JOBS="' + jobs.join(' ') + '"',
|
||||
'',
|
||||
'mkdir -p "$STATE"',
|
||||
'if [ -f "$LOG" ] && [ "$(wc -c < "$LOG")" -gt 65536 ]; then rm -f "$LOG"; fi',
|
||||
'exec >>"$LOG" 2>&1',
|
||||
'echo "--- $(date) LG Update Blocker ---"',
|
||||
'',
|
||||
'if [ "$BLOCK_HOSTS" = 1 ] && [ -f "$STATE/hosts.txt" ]; then',
|
||||
' if ! (: >> /etc/hosts) 2>/dev/null; then',
|
||||
' cp /etc/hosts "$HOSTS_TMP" && chmod 644 "$HOSTS_TMP" \\',
|
||||
' && mount --bind "$HOSTS_TMP" /etc/hosts \\',
|
||||
' && echo "bind-mounted writable /etc/hosts"',
|
||||
' fi',
|
||||
' if grep -q "lg-update-blocker" /etc/hosts 2>/dev/null; then',
|
||||
' echo "hosts entries already present"',
|
||||
' elif (: >> /etc/hosts) 2>/dev/null; then',
|
||||
' {',
|
||||
' echo "' + MARKER_BEGIN + '"',
|
||||
' sed -e "s/#.*//" -e "s/[[:space:]]*$//" -e "/^$/d" "$STATE/hosts.txt" | while read -r domain; do',
|
||||
' echo "127.0.0.1 $domain"',
|
||||
' echo "::1 $domain"',
|
||||
' done',
|
||||
' echo "' + MARKER_END + '"',
|
||||
' } >> /etc/hosts && echo "hosts entries added"',
|
||||
' else',
|
||||
' echo "could not make /etc/hosts writable"',
|
||||
' fi',
|
||||
'fi',
|
||||
'',
|
||||
'if [ "$PURGE_CACHE" = 1 ]; then',
|
||||
' for dir in $CACHE_DIRS; do',
|
||||
' [ -d "$dir" ] || continue',
|
||||
' case "$dir" in /mnt/lg/*) ;; *) continue ;; esac',
|
||||
' entries=$(ls -A "$dir" 2>/dev/null)',
|
||||
' [ -n "$entries" ] || continue',
|
||||
' rm -rf "$dir"/* "$dir"/.[!.]* 2>/dev/null',
|
||||
' echo "purged staged item(s) from $dir: $(echo "$entries" | tr \'\\n\' \' \')"',
|
||||
' done',
|
||||
'fi',
|
||||
'',
|
||||
'if [ "$LOCK_CACHE" = 1 ]; then',
|
||||
' mkdir -p "$STATE/empty"',
|
||||
' for dir in $CACHE_DIRS; do',
|
||||
' [ -d "$dir" ] || continue',
|
||||
' case "$dir" in /mnt/lg/*) ;; *) continue ;; esac',
|
||||
' if awk \'{print $2}\' /proc/mounts | grep -qx "$dir"; then',
|
||||
' echo "$dir already locked"',
|
||||
' continue',
|
||||
' fi',
|
||||
' if mount -o bind,ro "$STATE/empty" "$dir"; then',
|
||||
' mount -o bind,remount,ro "$STATE/empty" "$dir" 2>/dev/null',
|
||||
' echo "locked $dir"',
|
||||
' else',
|
||||
' echo "could not lock $dir"',
|
||||
' fi',
|
||||
' done',
|
||||
'fi',
|
||||
'',
|
||||
'if [ "$STOP_SERVICES" = 1 ] && [ -n "$JOBS" ]; then',
|
||||
' for job in $JOBS; do',
|
||||
' if initctl stop "$job" >/dev/null 2>&1 || stop "$job" >/dev/null 2>&1; then',
|
||||
' echo "stopped $job"',
|
||||
' else',
|
||||
' echo "could not stop $job (not running?)"',
|
||||
' fi',
|
||||
' done',
|
||||
'fi',
|
||||
'',
|
||||
'echo "done"',
|
||||
''
|
||||
].join('\n');
|
||||
}
|
||||
|
||||
function installBootHook(config, jobs, log) {
|
||||
var domains = readDomains();
|
||||
mkdirp(STATE_DIR);
|
||||
mkdirp(BOOT_HOOK_DIR);
|
||||
fs.writeFileSync(HOSTS_LIST_PATH, domains.join('\n') + '\n');
|
||||
fs.writeFileSync(BOOT_HOOK_PATH, bootHookScript(config, domains, jobs));
|
||||
fs.chmodSync(BOOT_HOOK_PATH, parseInt('755', 8));
|
||||
log.add('boot hook installed at ' + BOOT_HOOK_PATH);
|
||||
}
|
||||
|
||||
function removeBootHook(log) {
|
||||
if (!exists(BOOT_HOOK_PATH)) {
|
||||
log.add('no boot hook installed');
|
||||
return;
|
||||
}
|
||||
try {
|
||||
fs.unlinkSync(BOOT_HOOK_PATH);
|
||||
log.add('removed boot hook ' + BOOT_HOOK_PATH);
|
||||
} catch (err) {
|
||||
log.add('! could not remove boot hook: ' + err.message);
|
||||
}
|
||||
}
|
||||
|
||||
/* ---------------------------------------------------------------- methods */
|
||||
|
||||
function baseStatus() {
|
||||
return {
|
||||
version: pkgInfo.version,
|
||||
uid: typeof process.getuid === 'function' ? process.getuid() : -1,
|
||||
root: isRoot(),
|
||||
config: readConfig(),
|
||||
hosts: {
|
||||
path: HOSTS_PATH,
|
||||
writable: hostsWritable(),
|
||||
bindMounted: isMountPoint(HOSTS_PATH),
|
||||
blockedDomains: hostsBlockedDomains(),
|
||||
totalDomains: readDomains().length
|
||||
},
|
||||
cache: cacheStatus(),
|
||||
jobs: discoverJobs(),
|
||||
bootHook: {
|
||||
path: BOOT_HOOK_PATH,
|
||||
installed: exists(BOOT_HOOK_PATH)
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
function respondError(message, text) {
|
||||
message.respond({ returnValue: false, errorText: text });
|
||||
}
|
||||
|
||||
service.register('status', function (message) {
|
||||
var status = baseStatus();
|
||||
discoverSettings(function (settings) {
|
||||
status.settings = settings;
|
||||
status.returnValue = true;
|
||||
message.respond(status);
|
||||
});
|
||||
});
|
||||
|
||||
service.register('apply', function (message) {
|
||||
if (!isRoot()) {
|
||||
respondError(message, 'Service is not running as root - elevate it through the Homebrew Channel first.');
|
||||
return;
|
||||
}
|
||||
|
||||
var log = new Log();
|
||||
var config = mergeConfig(readConfig(), message.payload || {});
|
||||
|
||||
try {
|
||||
mkdirp(STATE_DIR);
|
||||
writeJson(CONFIG_PATH, config);
|
||||
|
||||
if (config.blockHosts) {
|
||||
applyHosts(log);
|
||||
} else {
|
||||
removeHosts(log);
|
||||
}
|
||||
|
||||
if (config.purgeCache) purgeCache(log);
|
||||
|
||||
if (config.lockCache) {
|
||||
lockCache(log);
|
||||
} else {
|
||||
unlockCache(log);
|
||||
}
|
||||
|
||||
var jobs = discoverJobs();
|
||||
if (config.stopServices) {
|
||||
stopJobs(jobs, log);
|
||||
}
|
||||
|
||||
if (anyEnabled(config)) {
|
||||
installBootHook(config, config.stopServices ? jobs : [], log);
|
||||
} else {
|
||||
removeBootHook(log);
|
||||
}
|
||||
} catch (err) {
|
||||
log.add('! ' + err.message);
|
||||
message.respond({ returnValue: false, errorText: err.message, log: log.lines, config: config });
|
||||
return;
|
||||
}
|
||||
|
||||
function finish() {
|
||||
log.add('done - reboot the TV to verify the popup is gone');
|
||||
message.respond({ returnValue: true, log: log.lines, config: config, status: baseStatus() });
|
||||
}
|
||||
|
||||
if (config.disableSettings) {
|
||||
disableSettings(log, finish);
|
||||
} else {
|
||||
restoreSettings(log, finish);
|
||||
}
|
||||
});
|
||||
|
||||
service.register('revert', function (message) {
|
||||
if (!isRoot()) {
|
||||
respondError(message, 'Service is not running as root - elevate it through the Homebrew Channel first.');
|
||||
return;
|
||||
}
|
||||
|
||||
var log = new Log();
|
||||
var config = {};
|
||||
CONFIG_KEYS.forEach(function (key) {
|
||||
config[key] = false;
|
||||
});
|
||||
|
||||
try {
|
||||
removeHosts(log);
|
||||
unlockCache(log);
|
||||
removeBootHook(log);
|
||||
mkdirp(STATE_DIR);
|
||||
writeJson(CONFIG_PATH, config);
|
||||
} catch (err) {
|
||||
log.add('! ' + err.message);
|
||||
}
|
||||
|
||||
restoreSettings(log, function () {
|
||||
log.add('everything reverted; stopped services come back after a reboot');
|
||||
message.respond({ returnValue: true, log: log.lines, config: config, status: baseStatus() });
|
||||
});
|
||||
});
|
||||
|
||||
service.register('purge', function (message) {
|
||||
if (!isRoot()) {
|
||||
respondError(message, 'Service is not running as root - elevate it through the Homebrew Channel first.');
|
||||
return;
|
||||
}
|
||||
var log = new Log();
|
||||
purgeCache(log);
|
||||
message.respond({ returnValue: true, log: log.lines, status: baseStatus() });
|
||||
});
|
||||
|
||||
service.register('diagnostics', function (message) {
|
||||
var status = baseStatus();
|
||||
discoverSettings(function (settings) {
|
||||
message.respond({
|
||||
returnValue: true,
|
||||
status: status,
|
||||
settings: settings,
|
||||
osInfo: readJson('/var/run/nyx/os_info.json', null),
|
||||
hostsFile: readFile(HOSTS_PATH, '(unreadable)').split('\n').slice(-40).join('\n'),
|
||||
bootLog: readFile(BOOT_LOG_PATH, '(no boot log yet)').split('\n').slice(-40).join('\n'),
|
||||
mounts: mountTargets().filter(function (target) {
|
||||
return target === HOSTS_PATH || target.indexOf('/mnt/lg') === 0;
|
||||
})
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
console.info(pkgInfo.name + ' v' + pkgInfo.version + ' started, uid=' +
|
||||
(typeof process.getuid === 'function' ? process.getuid() : 'unknown'));
|
||||
Reference in New Issue
Block a user