I2P_in_Private_Browsing_Mode_for_Firefox/proxy.js

var titlepref = chrome.i18n.getMessage('titlePreface');
var webpref = chrome.i18n.getMessage('webPreface');
var routerpref = chrome.i18n.getMessage('routerPreface');
var mailpref = chrome.i18n.getMessage('mailPreface');
var torrentpref = chrome.i18n.getMessage('torrentPreface');
var tunnelpref = chrome.i18n.getMessage('i2ptunnelPreface');
var ircpref = chrome.i18n.getMessage('ircPreface');
var extensionpref = chrome.i18n.getMessage('extensionPreface');
var muwirepref = chrome.i18n.getMessage('muwirePreface');
var botepref = chrome.i18n.getMessage('botePreface');
var blogpref = chrome.i18n.getMessage('blogPreface');
var blogprefpriv = chrome.i18n.getMessage('blogPrefacePrivate');

browser.privacy.network.peerConnectionEnabled.set({
  value: true
});

chrome.privacy.network.networkPredictionEnabled.set({
  value: false
});
chrome.privacy.network.webRTCIPHandlingPolicy.set({
  value: 'disable_non_proxied_udp'
});
console.log('Disabled unproxied UDP.');

function shouldProxyRequest(requestInfo) {
  return requestInfo.parentFrameId != -1;
}

var handleContextProxyRequest = async function(requestDetails) {
  function ircProxy() {
    if (!requestDetails.url.includes('7669')) {
      proxy = {
        type: getScheme(),
        host: getHost(),
        port: getPort()
      };
      return proxy;
    }
    if (requestDetails.url.includes(':7669')) {
      proxy = null;
      return proxy;
    }
  }
  function blogProxy() {
    if (!requestDetails.url.includes('8084')) {
      proxy = {
        type: getScheme(),
        host: getHost(),
        port: getPort()
      };
      return proxy;
    }
    if (requestDetails.url.includes(':8084')) {
      proxy = null;
      return proxy;
    }
  }

  function btProxy() {
    proxy = routerProxy();
    if (requestDetails.url.includes(':7662')) {
      proxy = null;
      return proxy;
    }
    console.log('(bt proxy)', proxy);
    return proxy;
  }
  function mainProxy() {
    console.log('(proxy) mainproxy 0');
    proxy = {
      type: getScheme(),
      host: getHost(),
      port: getPort()
    };
    let url = new URL(requestDetails.url);
    if (
      requestDetails.url.startsWith(
        'http://' + getHost() + ':' + getConsolePort() + '/i2psnark/'
      )
    ) {
      //+url.host)) {
      console.log('(proxy) mainproxy 2', url);
      proxy = null;
    }
    return proxy;
  }
  function routerProxy() {
    if (routerHost(requestDetails.url)) {
      proxy = null;
      return proxy;
    } else if (!routerHost(requestDetails.url)) {
      proxy = {
        type: getScheme(),
        host: getHost(),
        port: getPort()
      };
      return proxy;
    }
  }
  try {
    var handleProxyRequest = function(context) {
      proxy = {
        type: getScheme(),
        host: getHost(),
        port: getPort()
      };

      if (context == 'firefox-default' || context == 'firefox-private') {
        proxy = null;
        return proxy;
      }

      if (context != undefined) {
        console.log('(proxy), context', context);
        proxy = routerProxy();
        if (context.name == ircpref) {
          proxy = ircProxy();
          return proxy;
        } else if (context.name == blogpref) {
          proxy = blogProxy();
          return proxy;
        } else if (context.name == titlepref) {
          proxy = mainProxy();
          return proxy;
        } else if (context.name == routerpref) {
          proxy = routerProxy();
          return proxy;
        } else if (context.name == torrentpref) {
          proxy = btProxy();
          return proxy;
        } else if (context.name == mailpref) {
          return proxy;
        } else if (context.name == tunnelpref) {
          return proxy;
        } else if (context.name == muwirepref) {
          return proxy;
        } else if (context.name == botepref) {
          return proxy;
        }
      } else {
        if (!routerHost(requestDetails.url)) {
          if (localHost(requestDetails.url)) {
            if (requestDetails.url.includes(':7669')) {
              proxy = null;
            } else if (requestDetails.url.includes(':7662')) {
              proxy = null;
            } else {
              console.log(
                '(proxy) non-routerconsole localhost url, will not interfere',
                requestDetails.url
              );
            }
          }
        }
        if (i2pHost(requestDetails.url)) {
          proxy = {
            type: getScheme(),
            host: getHost(),
            port: getPort()
          };
        } else {
          proxy = null;
        }
        if (requestDetails.url.includes('rpc')) {
          console.log('(proxy for rpc url)', rpc);
        }
        //var tab = tabGet(requestDetails.tabId);
        //tab.then(handleTabRequest,)
        return proxy;
      }
    };
    var contextGet = async function(tabInfo) {
      try {
        context = await browser.contextualIdentities.get(tabInfo.cookieStoreId);
        return context;
      } catch (error) {
        console.warn(error);
        return 'firefox-default';
      }
    };
    var tabGet = async function(tabId) {
      try {
        let tabInfo = await browser.tabs.get(tabId);
        return tabInfo;
      } catch (error) {
        console.log('(proxy)Tab error', error);
      }
    };
    if (proxyHost(requestDetails.url)) {
      proxy = {
        type: getScheme(),
        host: getHost(),
        port: getPort()
      };
      return proxy;
    }
    if (requestDetails.originUrl == browser.runtime.getURL('security.html')) {
      proxy = {
        type: getScheme(),
        host: getHost(),
        port: getPort()
      };
      return proxy;
    }
    if (
      requestDetails.cookieStoreId == 'firefox-default' ||
      requestDetails.cookieStoreId == 'firefox-private'
    ) {
      if (browser.windows != undefined) {
        return browser.proxy.settings.get({});
      }
    }
    if (requestDetails.tabId > 0) {
      if (requestDetails.url.includes('MuWire')) {
        return;
      }
      if (proxyHost(requestDetails.url)) {
        proxy = {
          type: getScheme(),
          host: getHost(),
          port: getPort()
        };
        return proxy;
      } else if (i2pHost(requestDetails.url)) {
        var tab = tabGet(requestDetails.tabId);
        requestDetails.tabId = tab;
        var context = tab.then(contextGet);
        var proxy = await context.then(handleProxyRequest);
        //console.log('(proxy)Returning I2P Proxy', proxy);
        return proxy;
      } else if (extensionHost(requestDetails)) {
        return;
      } else {
        var tab = tabGet(requestDetails.tabId);
        var context = tab.then(contextGet);
        var proxy = await context.then(handleProxyRequest);
        //console.log("(proxy)Returning I2P Proxy", proxy);
        return proxy;
      }
      /*proxy = {};
      console.log("(proxy)Returning unset Proxy", proxy);
      return proxy;*/
    } else {
      proxy = {
        type: getScheme(),
        host: getHost(),
        port: getPort()
      };
      //console.log('(proxy for rpc url)', rpc);
      return proxy;
    }
  } catch (error) {
    console.log('(proxy)Not using I2P Proxy.', error);
  }
}

function SetupSettings() {
  console.log('Initialising Settings');
  function onSetupError() {
    console.log('Settings initialization error');
  }
  //
  function checkSchemeStoredSettings(storedSettings) {
    if (storedSettings.proxy_scheme == undefined)
      storedSettings.proxy_scheme = 'http';
    else proxy_scheme = storedSettings.proxy_scheme;

    console.log('Initialising Proxy Scheme', storedSettings.proxy_scheme);
    setupProxy();
  }
  var gettingSchemeStoredSettings = browser.storage.local.get('proxy_scheme');
  gettingSchemeStoredSettings.then(checkSchemeStoredSettings, onSetupError);

  //
  function checkHostStoredSettings(storedSettings) {
    if (storedSettings.proxy_host == undefined)
      storedSettings.proxy_host = '127.0.0.1';
    else proxy_host = storedSettings.proxy_host;

    console.log('Initialising Host', storedSettings.proxy_host);
    setupProxy();
  }
  var gettingHostStoredSettings = browser.storage.local.get('proxy_host');
  gettingHostStoredSettings.then(checkHostStoredSettings, onSetupError);

  //
  function checkPortStoredSettings(storedSettings) {
    if (storedSettings.proxy_port == undefined)
      storedSettings.proxy_port = '4444';
    else proxy_port = storedSettings.proxy_port;

    console.log('Initialising Port', storedSettings.proxy_port);
    setupProxy();
  }
  var gettingPortStoredSettings = browser.storage.local.get('proxy_port');
  gettingPortStoredSettings.then(checkPortStoredSettings, onSetupError);

  //
  function checkControlHostStoredSettings(storedSettings) {
    if (storedSettings.control_host == undefined)
      storedSettings.control_host = '127.0.0.1';
    else control_host = storedSettings.control_host;

    console.log('Initialising Control Host', storedSettings.control_host);
    setupProxy();
  }
  var gettingControlHostStoredSettings = browser.storage.local.get(
    'control_host'
  );
  gettingControlHostStoredSettings.then(
    checkControlHostStoredSettings,
    onSetupError
  );

  //
  function checkControlPortStoredSettings(storedSettings) {
    if (storedSettings.control_port == undefined)
      storedSettings.control_port = '7657';
    else control_port = storedSettings.control_port;

    console.log('Initialising Control Port', storedSettings.control_port);
    setupProxy();
  }
  var gettingControlPortStoredSettings = browser.storage.local.get(
    'control_port'
  );
  gettingControlPortStoredSettings.then(
    checkControlPortStoredSettings,
    onSetupError
  );

  //
  function checkHistoryStoredSettings(storedSettings) {
    if (storedSettings.disable_history == undefined)
      storedSettings.disable_history = false;
    else disable_history = storedSettings.disable_history;

    console.log(
      'Initialising Disabled History',
      storedSettings.disable_history
    );
    setupProxy();
  }
  var gettingHistoryStoredSettings = browser.storage.local.get(
    'disable_history'
  );
  gettingHistoryStoredSettings.then(checkHistoryStoredSettings, onSetupError);
}

function getScheme() {
  if (proxy_scheme == 'HTTP') return 'http';
  if (proxy_scheme == 'SOCKS') return 'socks';
  if (proxy_scheme == 'http') return 'http';
  if (proxy_scheme == 'socks') return 'socks';
  else return 'http';
}

function getHost() {
  if (proxy_host == undefined) {
    proxy_host = '127.0.0.1';
  }
  return proxy_host;
}

function getPort() {
  if (proxy_port == undefined) {
    var scheme = getScheme();
    if (scheme == 'socks') proxy_port = '4446';
    else proxy_port = '4444';
  }
  return proxy_port;
}

function getConsolePort() {
  if (control_port == undefined) {
    var scheme = getScheme();
    if (scheme == 'socks') proxy_port = '7657';
    else control_port = '7657';
  }
  return control_port;
}

function setupProxy() {
  console.log('Setting up Firefox WebExtension proxy');
  browser.proxy.onRequest.addListener(handleContextProxyRequest, {
    urls: ['<all_urls>']
  });
  console.log('i2p settings created for WebExtension Proxy');
}

function update() {
  console.log('restoring proxy scheme:', proxy_scheme);
  console.log('restoring proxy host:', proxy_host);
  console.log('restoring proxy port:', proxy_port);
  console.log('restoring control host:', control_host);
  console.log('restoring control port:', control_port);
}

function updateFromStorage() {
  console.log('updating settings from storage');
  chrome.storage.local.get(function() {
    SetupSettings();
    update();
    setupProxy();
  });
}

updateFromStorage();
browser.storage.onChanged.addListener(updateFromStorage);
SetupSettings();
setupProxy();

var gettingListenerInfo = browser.runtime.getPlatformInfo();
gettingListenerInfo.then((got) => {
  if (browser.windows != undefined) {
    browser.windows.onCreated.addListener(() => {
      chrome.storage.local.get(function() {
        setupProxy();
      });
    });
  }
});