/* -*- indent-tabs-mode: nil; js-indent-level: 4 -*- */
/* vim: set ts=4 sts=4 et sw=4 tw=80: */
/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

var CC = Components.Constructor;
const ServerSocket = CC("@mozilla.org/network/server-socket;1",
                        "nsIServerSocket",
                        "init");
var serv;
var ios;

/** Example local IP addresses (literal IP address hostname).
 *
 * Note: for IPv6 Unique Local and Link Local, a wider range of addresses is
 * set aside than those most commonly used. Technically, link local addresses
 * include those beginning with fe80:: through febf::, although in practise
 * only fe80:: is used. Necko code blocks speculative connections for the wider
 * range; hence, this test considers that range too.
 */
var localIPv4Literals =
    [ // IPv4 RFC1918 \
      "10.0.0.1", "10.10.10.10", "10.255.255.255",         // 10/8
      "172.16.0.1", "172.23.172.12", "172.31.255.255",     // 172.16/20
      "192.168.0.1", "192.168.192.168", "192.168.255.255", // 192.168/16
      // IPv4 Link Local
      "169.254.0.1", "169.254.192.154", "169.254.255.255"  // 169.254/16
    ];
var localIPv6Literals =
    [ // IPv6 Unique Local fc00::/7
      "fc00::1", "fdfe:dcba:9876:abcd:ef01:2345:6789:abcd",
      "fdff:ffff:ffff:ffff:ffff:ffff:ffff:ffff",
      // IPv6 Link Local fe80::/10
      "fe80::1", "fe80::abcd:ef01:2345:6789",
      "febf:ffff:ffff:ffff:ffff:ffff:ffff:ffff"
    ];
var localIPLiterals = localIPv4Literals.concat(localIPv6Literals);

/** Test function list and descriptions.
 */
var testList =
    [ test_speculative_connect,
      test_hostnames_resolving_to_local_addresses,
      test_proxies_with_local_addresses
    ];

var testDescription =
    [ "Expect pass with localhost",
      "Expect failure with resolved local IPs",
      "Expect failure for proxies with local IPs"
    ];

var testIdx = 0;
var hostIdx = 0;


/** TestServer
 *
 * Implements nsIServerSocket for test_speculative_connect.
 */
function TestServer() {
    this.listener = ServerSocket(-1, true, -1);
    this.listener.asyncListen(this);
}

TestServer.prototype = {
    QueryInterface: ChromeUtils.generateQI(["nsIServerSocket"]),
    onSocketAccepted(socket, trans) {
        try { this.listener.close(); } catch(e) {}
        Assert.ok(true);
        next_test();
    },

    onStopListening(socket) {}
};

/** TestFailedStreamCallback
 *
 * Implements nsI[Input|Output]StreamCallback for socket layer tests.
 * Expect failure in all cases
 */
function TestFailedStreamCallback(transport, hostname, next) {
    this.transport = transport;
    this.hostname = hostname;
    this.next = next;
    this.dummyContent = "G";
}

TestFailedStreamCallback.prototype = {
    QueryInterface: ChromeUtils.generateQI(["nsIInputStreamCallback", "nsIOutputStreamCallback"]),
    processException(e) {
        do_check_instanceof(e, Ci.nsIException);
        // A refusal to connect speculatively should throw an error.
        Assert.equal(e.result, Cr.NS_ERROR_CONNECTION_REFUSED);
        this.transport.close(Cr.NS_BINDING_ABORTED);
        return true;
    },
    onOutputStreamReady(outstream) {
        info("outputstream handler.");
        Assert.notEqual(typeof(outstream), undefined);
        try {
            outstream.write(this.dummyContent, this.dummyContent.length);
        } catch (e) {
            this.processException(e);
            this.next();
            return;
        }
        info("no exception on write. Wait for read.");
    },
    onInputStreamReady(instream) {
        info("inputstream handler.");
        Assert.notEqual(typeof(instream), undefined);
        try {
            instream.available();
        } catch (e) {
            this.processException(e);
            this.next();
            return;
        }
        do_throw("Speculative Connect should have failed for " +
                 this.hostname);
        this.transport.close(Cr.NS_BINDING_ABORTED);
        this.next();
    },
};

/** test_speculative_connect
 *
 * Tests a basic positive case using nsIOService.SpeculativeConnect:
 * connecting to localhost.
 */
function test_speculative_connect() {
    serv = new TestServer();
    var ssm = Cc["@mozilla.org/scriptsecuritymanager;1"]
                .getService(Ci.nsIScriptSecurityManager);
    var URI = ios.newURI("http://localhost:" + serv.listener.port + "/just/a/test");
    var principal = ssm.createCodebasePrincipal(URI, {});

    ios.QueryInterface(Ci.nsISpeculativeConnect)
       .speculativeConnect(URI, principal, null);
}

/* Speculative connections should not be allowed for hosts with local IP
 * addresses (Bug 853423). That list includes:
 *  -- IPv4 RFC1918 and Link Local Addresses.
 *  -- IPv6 Unique and Link Local Addresses.
 *
 * Two tests are required:
 *  1. Verify IP Literals passed to the SpeculativeConnect API.
 *  2. Verify hostnames that need to be resolved at the socket layer.
 */

/** test_hostnames_resolving_to_addresses
 *
 * Common test function for resolved hostnames. Takes a list of hosts, a
 * boolean to determine if the test is expected to succeed or fail, and a
 * function to call the next test case.
 */
function test_hostnames_resolving_to_addresses(host, next) {
    info(host);
    var sts = Cc["@mozilla.org/network/socket-transport-service;1"]
              .getService(Ci.nsISocketTransportService);
    Assert.notEqual(typeof(sts), undefined);
    var transport = sts.createTransport([], host, 80, null);
    Assert.notEqual(typeof(transport), undefined);

    transport.connectionFlags = Ci.nsISocketTransport.DISABLE_RFC1918;
    transport.setTimeout(Ci.nsISocketTransport.TIMEOUT_CONNECT, 1);
    transport.setTimeout(Ci.nsISocketTransport.TIMEOUT_READ_WRITE, 1);
    Assert.equal(1, transport.getTimeout(Ci.nsISocketTransport.TIMEOUT_CONNECT));

    var outStream = transport.openOutputStream(Ci.nsITransport.OPEN_UNBUFFERED,0,0);
    var inStream  = transport.openInputStream(0,0,0);
    Assert.notEqual(typeof(outStream), undefined);
    Assert.notEqual(typeof(inStream), undefined);

    var callback = new TestFailedStreamCallback(transport, host, next);
    Assert.notEqual(typeof(callback), undefined);

    // Need to get main thread pointer to ensure nsSocketTransport::AsyncWait
    // adds callback to ns*StreamReadyEvent on main thread, and doesn't
    // addref off the main thread.
    var gThreadManager = Cc["@mozilla.org/thread-manager;1"]
    .getService(Ci.nsIThreadManager);
    var mainThread = gThreadManager.currentThread;

    try {
        outStream.QueryInterface(Ci.nsIAsyncOutputStream)
            .asyncWait(callback, 0, 0, mainThread);
        inStream.QueryInterface(Ci.nsIAsyncInputStream)
            .asyncWait(callback, 0, 0, mainThread);
    } catch (e) {
        do_throw("asyncWait should not fail!");
    }
}

/**
 * test_hostnames_resolving_to_local_addresses
 *
 * Creates an nsISocketTransport and simulates a speculative connect request
 * for a hostname that resolves to a local IP address.
 * Runs asynchronously; on test success (i.e. failure to connect), the callback
 * will call this function again until all hostnames in the test list are done.
 *
 * Note: This test also uses an IP literal for the hostname. This should be ok,
 * as the socket layer will ask for the hostname to be resolved anyway, and DNS
 * code should return a numerical version of the address internally.
 */
function test_hostnames_resolving_to_local_addresses() {
    if (hostIdx >= localIPLiterals.length) {
        // No more local IP addresses; move on.
        next_test();
        return;
    }
    var host = localIPLiterals[hostIdx++];
    // Test another local IP address when the current one is done.
    var next = test_hostnames_resolving_to_local_addresses;
    test_hostnames_resolving_to_addresses(host, next);
}

/** test_speculative_connect_with_host_list
 *
 * Common test function for resolved proxy hosts. Takes a list of hosts, a
 * boolean to determine if the test is expected to succeed or fail, and a
 * function to call the next test case.
 */
function test_proxies(proxyHost, next) {
    info("Proxy: " + proxyHost);
    var sts = Cc["@mozilla.org/network/socket-transport-service;1"]
              .getService(Ci.nsISocketTransportService);
    Assert.notEqual(typeof(sts), undefined);
    var pps = Cc["@mozilla.org/network/protocol-proxy-service;1"]
              .getService();
    Assert.notEqual(typeof(pps), undefined);

    var proxyInfo = pps.newProxyInfo("http", proxyHost, 8080, "", "", 0, 1, null);
    Assert.notEqual(typeof(proxyInfo), undefined);

    var transport = sts.createTransport([], "dummyHost", 80, proxyInfo);
    Assert.notEqual(typeof(transport), undefined);

    transport.connectionFlags = Ci.nsISocketTransport.DISABLE_RFC1918;

    transport.setTimeout(Ci.nsISocketTransport.TIMEOUT_CONNECT, 1);
    Assert.equal(1, transport.getTimeout(Ci.nsISocketTransport.TIMEOUT_CONNECT));
    transport.setTimeout(Ci.nsISocketTransport.TIMEOUT_READ_WRITE, 1);

    var outStream = transport.openOutputStream(Ci.nsITransport.OPEN_UNBUFFERED,0,0);
    var inStream  = transport.openInputStream(0,0,0);
    Assert.notEqual(typeof(outStream), undefined);
    Assert.notEqual(typeof(inStream), undefined);

    var callback = new TestFailedStreamCallback(transport, proxyHost, next);
    Assert.notEqual(typeof(callback), undefined);

    // Need to get main thread pointer to ensure nsSocketTransport::AsyncWait
    // adds callback to ns*StreamReadyEvent on main thread, and doesn't
    // addref off the main thread.
    var gThreadManager = Cc["@mozilla.org/thread-manager;1"]
    .getService(Ci.nsIThreadManager);
    var mainThread = gThreadManager.currentThread;

    try {
        outStream.QueryInterface(Ci.nsIAsyncOutputStream)
            .asyncWait(callback, 0, 0, mainThread);
        inStream.QueryInterface(Ci.nsIAsyncInputStream)
            .asyncWait(callback, 0, 0, mainThread);
    } catch (e) {
        do_throw("asyncWait should not fail!");
    }
}

/**
 * test_proxies_with_local_addresses
 *
 * Creates an nsISocketTransport and simulates a speculative connect request
 * for a proxy that resolves to a local IP address.
 * Runs asynchronously; on test success (i.e. failure to connect), the callback
 * will call this function again until all proxies in the test list are done.
 *
 * Note: This test also uses an IP literal for the proxy. This should be ok,
 * as the socket layer will ask for the proxy to be resolved anyway, and DNS
 * code should return a numerical version of the address internally.
 */
function test_proxies_with_local_addresses() {
    if (hostIdx >= localIPLiterals.length) {
        // No more local IP addresses; move on.
        next_test();
        return;
    }
    var host = localIPLiterals[hostIdx++];
    // Test another local IP address when the current one is done.
    var next = test_proxies_with_local_addresses;
    test_proxies(host, next);
}

/** next_test
 *
 * Calls the next test in testList. Each test is responsible for calling this
 * function when its test cases are complete.
 */
function next_test() {
    if (testIdx >= testList.length) {
        // No more tests; we're done.
        do_test_finished();
        return;
    }
    info("SpeculativeConnect: " + testDescription[testIdx]);
    hostIdx = 0;
    // Start next test in list.
    testList[testIdx++]();
}

/** run_test
 *
 * Main entry function for test execution.
 */
function run_test() {
    ios = Cc["@mozilla.org/network/io-service;1"]
        .getService(Ci.nsIIOService);

    Services.prefs.setIntPref("network.http.speculative-parallel-limit", 6);
    registerCleanupFunction(() => {
      Services.prefs.clearUserPref("network.http.speculative-parallel-limit");
    });

    do_test_pending();
    next_test();
}

