[Author Prev][Author Next][Thread Prev][Thread Next][Author Index][Thread Index]

[tor-commits] [meek/extension] Handle connections, do JSON, make requests.



commit 10e4dfeb23cddbb6d367d85f536b0d473a163b45
Author: David Fifield <david@xxxxxxxxxxxxxxx>
Date:   Sat Mar 15 20:27:38 2014 -0700

    Handle connections, do JSON, make requests.
---
 firefox/components/main.js |  302 ++++++++++++++++++++++++++++++++++++++------
 1 file changed, 263 insertions(+), 39 deletions(-)

diff --git a/firefox/components/main.js b/firefox/components/main.js
index c38eeda..8bda493 100644
--- a/firefox/components/main.js
+++ b/firefox/components/main.js
@@ -2,31 +2,20 @@
 // https://developer.mozilla.org/en-US/docs/Mozilla/JavaScript_code_modules/XPCOMUtils.jsm
 Components.utils.import("resource://gre/modules/XPCOMUtils.jsm");
 
+// Everything resides within the MeekHTTPHelper namespace. MeekHTTPHelper is
+// also the type from which NSGetFactory is constructed, and it is the top-level
+// nsIServerSocketListener.
 function MeekHTTPHelper() {
     this.wrappedJSObject = this;
 
     const LOCAL_PORT = 7000;
 
-    // Create a "direct" nsIProxyInfo that bypasses the default proxy.
-    // https://developer.mozilla.org/en-US/docs/XPCOM_Interface_Reference/nsIProtocolProxyService
-    var pps = Components.classes["@mozilla.org/network/protocol-proxy-service;1"]
-        .getService(Components.interfaces.nsIProtocolProxyService);
-    // https://developer.mozilla.org/en-US/docs/XPCOM_Interface_Reference/nsIProxyInfo
-    this.directProxyInfo = pps.newProxyInfo("direct", "", 0, 0, 0xffffffff, null);
-
-    // https://developer.mozilla.org/en-US/docs/XPCOM_Interface_Reference/nsIIOService
-    this.ioService = Components.classes["@mozilla.org/network/io-service;1"]
-        .getService(Components.interfaces.nsIIOService);
-    this.httpProtocolHandler = this.ioService.getProtocolHandler("http")
-        .QueryInterface(Components.interfaces.nsIHttpProtocolHandler);
-
     // https://developer.mozilla.org/en-US/docs/XPCOM_Interface_Reference/nsIServerSocket
     var serverSocket = Components.classes["@mozilla.org/network/server-socket;1"]
         .createInstance(Components.interfaces.nsIServerSocket);
     serverSocket.init(LOCAL_PORT, true, -1);
     serverSocket.asyncListen(this);
 }
-
 MeekHTTPHelper.prototype = {
     classDescription: "meek HTTP helper component",
     classID: Components.ID("{e7bc2b9c-f454-49f3-a19f-14848a4d871d}"),
@@ -39,51 +28,286 @@ MeekHTTPHelper.prototype = {
     ]),
 
     // nsIServerSocketListener implementation.
-    onSocketAccepted: function(aServ, aTransport) {
-        dump("onSocketAccepted host " + aTransport.host + "\n");
+    onSocketAccepted: function(server, transport) {
+        dump("onSocketAccepted " + transport.host + ":" + transport.port + "\n");
+        new MeekHTTPHelper.LocalConnectionHandler(transport);
+    },
+    onStopListening: function(server, status) {
+        dump("onStopListening status " + status + "\n");
+    },
+};
 
-        const FRONT_URL = "https://www.google.com/";;
-        const HOST = "meek-reflect.appspot.com";
+// Global variables and functions.
 
-        var uri = this.ioService.newURI(FRONT_URL, null, null);
+MeekHTTPHelper.LOCAL_READ_TIMEOUT = 2.0;
+MeekHTTPHelper.LOCAL_WRITE_TIMEOUT = 2.0;
+
+// A "direct" nsIProxyInfo that bypasses the default proxy.
+// https://developer.mozilla.org/en-US/docs/XPCOM_Interface_Reference/nsIProtocolProxyService
+// https://developer.mozilla.org/en-US/docs/XPCOM_Interface_Reference/nsIProxyInfo
+MeekHTTPHelper.directProxyInfo = Components.classes["@mozilla.org/network/protocol-proxy-service;1"]
+    .getService(Components.interfaces.nsIProtocolProxyService)
+    .newProxyInfo("direct", "", 0, 0, 0xffffffff, null);
+
+// https://developer.mozilla.org/en-US/docs/XPCOM_Interface_Reference/nsIIOService
+MeekHTTPHelper.ioService = Components.classes["@mozilla.org/network/io-service;1"]
+    .getService(Components.interfaces.nsIIOService);
+MeekHTTPHelper.httpProtocolHandler = MeekHTTPHelper.ioService.getProtocolHandler("http")
+    .QueryInterface(Components.interfaces.nsIHttpProtocolHandler);
+
+// Set the transport to time out at the given absolute deadline.
+MeekHTTPHelper.refreshDeadline = function(transport, deadline) {
+    var timeout;
+    if (deadline === null)
+        timeout = 0xffffffff;
+    else
+        timeout = Math.max(0.0, Math.ceil((deadline - Date.now()) / 1000.0));
+    transport.setTimeout(Components.interfaces.nsISocketTransport.TIMEOUT_READ_WRITE, timeout);
+};
+
+// Reverse-index the Components.results table.
+MeekHTTPHelper.lookupStatus = function(status) {
+    for (var name in Components.results) {
+        if (Components.results[name] === status)
+            return name;
+    }
+    return null;
+};
+
+// LocalConnectionHandler handles each new client connection received on the
+// socket opened by MeekHTTPHelper. It reads a JSON request, makes the request
+// on the Internet, and writes the result back to the socket. Error handling
+// happens within callbacks.
+MeekHTTPHelper.LocalConnectionHandler = function(transport) {
+    dump("LocalConnectionHandler\n");
+    this.transport = transport;
+    this.readRequest(this.makeRequest.bind(this));
+};
+MeekHTTPHelper.LocalConnectionHandler.prototype = {
+    readRequest: function(callback) {
+        dump("readRequest\n");
+        new MeekHTTPHelper.RequestReader(this.transport, this.makeRequest.bind(this));
+    },
+
+    makeRequest: function(req) {
+        dump("makeRequest " + JSON.stringify(req) + "\n");
+        if (!this.requestOk(req)) {
+            this.transport.close(0);
+            return;
+        }
+        var uri = MeekHTTPHelper.ioService.newURI(req.url, null, null);
         // Construct an HTTP channel with the proxy bypass.
         // https://developer.mozilla.org/en-US/docs/XPCOM_Interface_Reference/nsIHttpChannel
-        var channel = this.httpProtocolHandler.newProxiedChannel(uri, this.directProxyInfo, 0, null)
+        var channel = MeekHTTPHelper.httpProtocolHandler.newProxiedChannel(uri, MeekHTTPHelper.directProxyInfo, 0, null)
             .QueryInterface(Components.interfaces.nsIHttpChannel);
-        // Set the host we really want.
-        channel.setRequestHeader("Host", HOST, false);
-        channel.redirectionLimit = 0;
+        if (req.header !== undefined) {
+            for (var key in req.header) {
+                dump("setting header " + key + ": " + req.header[key] + "\n");
+                channel.setRequestHeader(key, req.header[key], false);
+            }
+        }
+        if (req.body !== undefined) {
+            let body = atob(req.body);
+            let inputStream = Components.classes["@mozilla.org/io/string-input-stream;1"]
+                .createInstance(Components.interfaces.nsIStringInputStream);
+            inputStream.setData(body, body.length);
+            let uploadChannel = channel.QueryInterface(Components.interfaces.nsIUploadChannel);
+            uploadChannel.setUploadStream(inputStream, "application/octet-stream", body.length);
+        }
         // https://developer.mozilla.org/en-US/docs/XPCOM_Interface_Reference/nsIUploadChannel
-        // channel.requestMethod = "POST";
+        // says we must set requestMethod after calling setUploadStream.
+        channel.requestMethod = req.method;
+        channel.redirectionLimit = 0;
 
-        channel.asyncOpen(new this.httpResponseStreamListener(), null);
+        channel.asyncOpen(new MeekHTTPHelper.HttpStreamListener(this.returnResponse.bind(this)), channel);
     },
-    onStopListening: function(aServ, aStatus) {
-        dump("onStopListening status " + aStatus + "\n");
+
+    returnResponse: function(resp) {
+        dump("returnResponse " + JSON.stringify(resp) + "\n");
+        outputStream = this.transport.openOutputStream(
+            Components.interfaces.nsITransport.OPEN_BLOCKING | Components.interfaces.nsITransport.OPEN_UNBUFFERED, 0, 0);
+        var output = Components.classes["@mozilla.org/binaryoutputstream;1"]
+            .createInstance(Components.interfaces.nsIBinaryOutputStream);
+        output.setOutputStream(outputStream);
+
+        var converter = Components.classes["@mozilla.org/intl/scriptableunicodeconverter"]
+            .createInstance(Components.interfaces.nsIScriptableUnicodeConverter);
+        converter.charset = "UTF-8";
+        var s = JSON.stringify(resp);
+        var data = converter.convertToByteArray(s);
+
+        var deadline = Date.now() + MeekHTTPHelper.LOCAL_WRITE_TIMEOUT * 1000;
+        try {
+            MeekHTTPHelper.refreshDeadline(this.transport, deadline);
+            output.write32(data.length);
+            MeekHTTPHelper.refreshDeadline(this.transport, deadline);
+            output.writeByteArray(data, data.length);
+        } finally {
+            output.close();
+        }
+    },
+
+    // Enforce restrictions on what requests we are willing to make. These can
+    // probably be loosened up. Try and rule out anything unexpected until we
+    // know we need otherwise.
+    requestOk: function(req) {
+        if (req.method === undefined) {
+            dump("req missing \"method\".\n");
+            return false;
+        }
+        if (req.url === undefined) {
+            dump("req missing \"url\".\n");
+            return false;
+        }
+
+        if (req.method !== "POST") {
+            dump("req.method is " + JSON.stringify(req.method) + ", not \"POST\".\n");
+            return false;
+        }
+        if (!req.url.startsWith("https://";)) {
+            dump("req.url doesn't start with \"https://\".\n";);
+            return false;
+        }
+
+        return true;
     },
 };
 
+// RequestReader reads a JSON-encoded request from the given transport, and
+// calls the given callback with the request as an argument. In case of error,
+// the transport is closed and the callback is not called.
+MeekHTTPHelper.RequestReader = function(transport, callback) {
+    dump("RequestReader\n");
+    this.transport = transport;
+    this.callback = callback;
 
-// https://developer.mozilla.org/en-US/docs/Creating_Sandboxed_HTTP_Connections
-MeekHTTPHelper.prototype.httpResponseStreamListener = function() {
+    this.curThread = Components.classes["@mozilla.org/thread-manager;1"].getService().currentThread;
+    this.inputStream = this.transport.openInputStream(
+        Components.interfaces.nsITransport.OPEN_BLOCKING | Components.interfaces.nsITransport.OPEN_UNBUFFERED, 0, 0);
+
+    this.state = this.STATE_READING_LENGTH;
+    this.buf = new Uint8Array(4);
+    this.bytesToRead = this.buf.length;
+    this.deadline = Date.now() + MeekHTTPHelper.LOCAL_READ_TIMEOUT * 1000;
+    this.asyncWait();
 };
-MeekHTTPHelper.prototype.httpResponseStreamListener.prototype = {
+MeekHTTPHelper.RequestReader.prototype = {
+    STATE_READING_LENGTH: 1,
+    STATE_READING_OBJECT: 2,
+    STATE_DONE: 3,
+
+    // Do an asyncWait and handle the result.
+    asyncWait: function() {
+        MeekHTTPHelper.refreshDeadline(this.transport, this.deadline);
+        this.inputStream.asyncWait(this, 0, 0, this.curThread);
+    },
+
+    // nsIInputStreamCallback implementation.
+    onInputStreamReady: function(inputStream) {
+        var input = Components.classes["@mozilla.org/binaryinputstream;1"]
+            .createInstance(Components.interfaces.nsIBinaryInputStream);
+        input.setInputStream(inputStream);
+        try {
+            switch (this.state) {
+            case this.STATE_READING_LENGTH:
+                this.doStateReadingLength(input);
+                this.asyncWait(inputStream);
+                break;
+            case this.STATE_READING_OBJECT:
+                this.doStateReadingObject(input);
+                if (this.bytesToRead > 0)
+                    this.asyncWait(inputStream);
+                break;
+            }
+        } catch (e) {
+            dump("got exception " + e + "\n");
+            this.transport.close(0);
+            return;
+        }
+    },
+
+    // Read into this.buf (up to its capacity) and decrement this.bytesToRead.
+    readIntoBuf: function(input) {
+        var n = Math.min(input.available(), this.bytesToRead);
+        var data = input.readByteArray(n);
+        this.buf.subarray(this.buf.length - this.bytesToRead, n).set(data)
+        this.bytesToRead -= n;
+    },
+
+    doStateReadingLength: function(input) {
+        this.readIntoBuf(input);
+        if (this.bytesToRead > 0)
+            return;
+
+        this.state = this.STATE_READING_OBJECT;
+        var b = this.buf;
+        this.bytesToRead = (b[0] << 24) | (b[1] << 16) | (b[2] << 8) | b[3];
+        if (this.bytesToRead > 1000000) {
+            dump("Object length is too long (" + this.bytesToRead + "), ignoring.\n");
+            throw Components.results.NS_ERROR_FAILURE;
+        }
+        this.buf = new Uint8Array(this.bytesToRead);
+    },
+
+    doStateReadingObject: function(input) {
+        this.readIntoBuf(input);
+        if (this.bytesToRead > 0)
+            return;
+
+        this.state = this.STATE_DONE;
+        var converter = Components.classes["@mozilla.org/intl/scriptableunicodeconverter"]
+            .createInstance(Components.interfaces.nsIScriptableUnicodeConverter);
+        converter.charset = "UTF-8";
+        var s = converter.convertFromByteArray(this.buf, this.buf.length);
+        var req = JSON.parse(s);
+        this.callback(req);
+    },
+};
+
+// HttpStreamListener makes the requested HTTP request and calls the given
+// callback with a representation of the response. The "error" key of the return
+// value is defined if and only if there was an error.
+MeekHTTPHelper.HttpStreamListener = function(callback) {
+    this.callback = callback;
+    // This is a list of binary strings that is concatenated in onStopRequest.
+    this.body = [];
+    this.length = 0;
+};
+// https://developer.mozilla.org/en-US/docs/Creating_Sandboxed_HTTP_Connections
+MeekHTTPHelper.HttpStreamListener.prototype = {
     // https://developer.mozilla.org/en-US/docs/XPCOM_Interface_Reference/nsIRequestObserver
-    onStartRequest: function(aRequest, aContext) {
+    onStartRequest: function(req, context) {
         dump("onStartRequest\n");
     },
-    onStopRequest: function(aRequest, aContext, aStatus) {
-        dump("onStopRequest\n");
+    onStopRequest: function(req, context, status) {
+        dump("onStopRequest " + status + "\n");
+        var resp = {
+            status: context.responseStatus,
+        };
+        if (Components.isSuccessCode(status)) {
+            resp.body = btoa(this.body.join(""));
+        } else {
+            let err = MeekHTTPHelper.lookupStatus(status);
+            if (err !== null)
+                resp.error = err;
+            else
+                resp.error = "error " + String(status);
+        }
+        this.callback(resp);
     },
+
     // https://developer.mozilla.org/en-US/docs/XPCOM_Interface_Reference/nsIStreamListener
-    onDataAvailable: function(aRequest, aContext, aStream, aSourceOffset, aLength) {
-        dump("onDataAvailable\n");
-        var a = new Uint8Array(aLength);
+    onDataAvailable: function(request, context, stream, sourceOffset, length) {
+        dump("onDataAvailable " + length + " bytes\n");
+        if (this.length + length > 1000000) {
+            request.cancel(Components.results.NS_ERROR_ILLEGAL_VALUE);
+            return;
+        }
+        this.length += length;
         var input = Components.classes["@mozilla.org/binaryinputstream;1"]
             .createInstance(Components.interfaces.nsIBinaryInputStream);
-        input.setInputStream(aStream);
-        input.readByteArray(aLength, a);
-        dump(aLength + ":" + a + "\n");
+        input.setInputStream(stream);
+        this.body.push(String.fromCharCode.apply(null, input.readByteArray(length)));
     },
 };
 



_______________________________________________
tor-commits mailing list
tor-commits@xxxxxxxxxxxxxxxxxxxx
https://lists.torproject.org/cgi-bin/mailman/listinfo/tor-commits