Haketilo

/**

 * Myext serving of page actions to content scripts

 *

 * Copyright (C) 2021 Wojtek Kosior

 *

 * This code is dual-licensed under:

 * - Asshole license 1.0,

 * - GPLv3 or (at your option) any later version

 *

 * "dual-licensed" means you can choose the license you prefer.

 *

 * This code is released under a permissive license because I disapprove of

 * copyright and wouldn't be willing to sue a violator. Despite not putting

 * this code under copyleft (which is also kind of copyright), I do not want

 * it to be made proprietary. Hence, the permissive alternative to GPL is the

 * Asshole license 1.0 that allows me to call you an asshole if you use it.

 * This means you're legally ok regardless of how you utilize this code but if

 * you make it into something nonfree, you're an asshole.

 *

 * You should have received a copy of both GPLv3 and Asshole license 1.0

 * together with this code. If not, please see:

 * - https://www.gnu.org/licenses/gpl-3.0.en.html

 * - https://koszko.org/asshole-license.txt

 */

"use strict";

(() => {

    const get_storage = window.get_storage;

    const TYPE_PREFIX = window.TYPE_PREFIX;

    const CONNECTION_TYPE = window.CONNECTION_TYPE;

    const browser = window.browser;

    const listen_for_connection = window.listen_for_connection;

    const sha256 = window.sha256;

    const get_query_best = window.get_query_best;

    var storage;

    var query_best;

    var handler;

    function send_scripts(url, port)

    {

	let [pattern, settings] = query_best(url);

	if (settings === undefined)

	    return;

	let components = settings.components;

	let processed_bags = new Set();

	if (components !== undefined)

	    send_scripts_rec([components], port, processed_bags);

    }

    // TODO: parallelize script fetching

    async function send_scripts_rec(components, port, processed_bags)

    {

	for (let [prefix, name] of components) {

	    if (prefix === TYPE_PREFIX.BAG) {

		if (processed_bags.has(name)) {

		    console.log(`preventing recursive inclusion of bag ${name}`);

		    continue;

		}

		var bag = storage.get(TYPE_PREFIX.BAG, name);

		if (bag === undefined) {

		    console.log(`no bag in storage for key ${name}`);

		    continue;

		}

		processed_bags.add(name);

		await send_scripts_rec(bag, port, processed_bags);

		processed_bags.delete(name);

	    } else {

		let script_text = await get_script_text(name);

		if (script_text === undefined)

		    continue;

		port.postMessage({inject : [script_text]});

	    }

	}

    }

    async function get_script_text(script_name)

    {

	try {

	    let script_data = storage.get(TYPE_PREFIX.SCRIPT, script_name);

	    if (script_data === undefined) {

		console.log(`missing data for ${script_name}`);

		return;

	    }

	    let script_text = script_data.text;

	    if (!script_text)

		script_text = await fetch_remote_script(script_data);

	    return script_text;

	} catch (e) {

	    console.log(e);

	}

    }

    function ajax_callback()

    {

	if (this.readyState == 4)

	    this.resolve_callback(this);

    }

    function initiate_ajax_request(resolve, method, url)

    {

	var xhttp = new XMLHttpRequest();

	xhttp.resolve_callback = resolve;

	xhttp.onreadystatechange = ajax_callback;

	xhttp.open(method, url, true);

	xhttp.send();

    }

    function make_ajax_request(method, url)

    {

	return new Promise((resolve, reject) =>

			   initiate_ajax_request(resolve, method, url));

    }

    async function fetch_remote_script(script_data)

    {

	try {

	    let xhttp = await make_ajax_request("GET", script_data.url);

	    if (xhttp.status === 200) {

		let computed_hash = sha256(xhttp.responseText);

		if (computed_hash !== script_data.hash) {

		    console.log(`Bad hash for ${script_data.url}\n    got ${computed_hash} instead of ${script_data.hash}`);

		    return;

		}

		return xhttp.responseText;

	    } else {

		console.log("script not fetched: " + script_data.url);

		return;

	    }

	} catch (e) {

	    console.log(e);

	}

    }

    function handle_message(port, message, handler)

    {

	port.onMessage.removeListener(handler[0]);

	let url = message.url;

	console.log({url});

	send_scripts(url, port);

    }

    function new_connection(port)

    {

	console.log("new page actions connection!");

	let handler = [];

	handler.push(m => handle_message(port, m, handler));

	port.onMessage.addListener(handler[0]);

    }

    async function start()

    {

	storage = await get_storage();

	query_best = await get_query_best();

	listen_for_connection(CONNECTION_TYPE.PAGE_ACTIONS, new_connection);

    }

    window.start_page_actions_server = start;

})();