webruby 0.1.0

data/modules/emscripten/third_party/websockify/other/websockify.js

@@ -0,0 +1,196 @@
+#!/usr/bin/env node
+
+// A WebSocket to TCP socket proxy
+// Copyright 2012 Joel Martin
+// Licensed under LGPL version 3 (see docs/LICENSE.LGPL-3)
+
+// Known to work with node 0.8.9
+// Requires node modules: ws, base64, optimist and policyfile
+//     npm install ws base64 optimist policyfile
+//
+// NOTE: 
+// This version requires a patched version of einaros/ws that supports
+// subprotocol negotiation. You can use the patched version like this:
+// 
+//     cd websockify/other
+//     git clone https://github.com/kanaka/ws
+//     npm link ./ws
+
+
+var argv = require('optimist').argv,
+    net = require('net'),
+    http = require('http'),
+    https = require('https'),
+    url = require('url'),
+    path = require('path'),
+    fs = require('fs'),
+    policyfile = require('policyfile'),
+
+    base64 = require('base64/build/Release/base64'),
+    Buffer = require('buffer').Buffer,
+    WebSocketServer = require('ws').Server,
+
+    webServer, wsServer,
+    source_host, source_port, target_host, target_port,
+    web_path = null;
+
+
+// Handle new WebSocket client
+new_client = function(client) {
+    var clientAddr = client._socket.remoteAddress, log;
+    log = function (msg) {
+        console.log(' ' + clientAddr + ': '+ msg);
+    };
+    log('WebSocket connection');
+    log('Version ' + client.protocolVersion + ', subprotocol: ' + client.protocol);
+
+    var target = net.createConnection(target_port,target_host, function() {
+        log('connected to target');
+    });
+    target.on('data', function(data) {
+        //log("sending message: " + data);
+        try {
+            if (client.protocol === 'base64') {
+                client.send(base64.encode(new Buffer(data)));
+            } else {
+                client.send(data,{binary: true});
+            }
+        } catch(e) {
+            log("Client closed, cleaning up target");
+            target.end();
+        }
+    });
+    target.on('end', function() {
+        log('target disconnected');
+    });
+
+    client.on('message', function(msg) {
+        //log('got message: ' + msg);
+        if (client.protocol === 'base64') {
+            target.write(base64.decode(msg),'binary');
+        } else {
+            target.write(msg,'binary');
+        }
+    });
+    client.on('close', function(code, reason) {
+        log('WebSocket client disconnected: ' + code + ' [' + reason + ']');
+        target.end();
+    });
+    client.on('error', function(a) {
+        log('WebSocket client error: ' + a);
+        target.end();
+    });
+};
+
+
+// Send an HTTP error response
+http_error = function (response, code, msg) {
+    response.writeHead(code, {"Content-Type": "text/plain"});
+    response.write(msg + "\n");
+    response.end();
+    return;
+}
+
+// Process an HTTP static file request
+http_request = function (request, response) {
+//    console.log("pathname: " + url.parse(req.url).pathname);
+//    res.writeHead(200, {'Content-Type': 'text/plain'});
+//    res.end('okay');
+
+    if (! argv.web) {
+        return http_error(response, 403, "403 Permission Denied");
+    }
+
+    var uri = url.parse(request.url).pathname
+        , filename = path.join(argv.web, uri);
+    
+    fs.exists(filename, function(exists) {
+        if(!exists) {
+            return http_error(response, 404, "404 Not Found");
+        }
+
+        if (fs.statSync(filename).isDirectory()) {
+            filename += '/index.html';
+        }
+
+        fs.readFile(filename, "binary", function(err, file) {
+            if(err) {
+                return http_error(response, 500, err);
+            }
+
+            response.writeHead(200);
+            response.write(file, "binary");
+            response.end();
+        });
+    });
+};
+
+// Select 'binary' or 'base64' subprotocol, preferring 'binary'
+selectProtocol = function(protocols, callback) {
+    var plist = protocols ? protocols.split(',') : "";
+    var plist = protocols.split(',');
+    if (plist.indexOf('binary') >= 0) {
+        callback(true, 'binary');
+    } else if (plist.indexOf('base64') >= 0) {
+        callback(true, 'base64');
+    } else {
+        console.log("Client must support 'binary' or 'base64' protocol");
+        callback(false);
+    }
+}
+
+// parse source and target arguments into parts
+try {
+    source_arg = argv._[0].toString();
+    target_arg = argv._[1].toString();
+
+    var idx;
+    idx = source_arg.indexOf(":");
+    if (idx >= 0) {
+        source_host = source_arg.slice(0, idx);
+        source_port = parseInt(source_arg.slice(idx+1), 10);
+    } else {
+        source_host = "";
+        source_port = parseInt(source_arg, 10);
+    }
+
+    idx = target_arg.indexOf(":");
+    if (idx < 0) {
+        throw("target must be host:port");
+    }
+    target_host = target_arg.slice(0, idx);
+    target_port = parseInt(target_arg.slice(idx+1), 10);
+
+    if (isNaN(source_port) || isNaN(target_port)) {
+        throw("illegal port");
+    }
+} catch(e) {
+    console.error("websockify.js [--web web_dir] [--cert cert.pem [--key key.pem]] [source_addr:]source_port target_addr:target_port");
+    process.exit(2);
+}
+
+console.log("WebSocket settings: ");
+console.log("    - proxying from " + source_host + ":" + source_port +
+            " to " + target_host + ":" + target_port);
+if (argv.web) {
+    console.log("    - Web server active. Serving: " + argv.web);
+}
+
+if (argv.cert) {
+    argv.key = argv.key || argv.cert;
+    var cert = fs.readFileSync(argv.cert),
+        key = fs.readFileSync(argv.key);
+    console.log("    - Running in encrypted HTTPS (wss://) mode using: " + argv.cert + ", " + argv.key);
+    webServer = https.createServer({cert: cert, key: key}, http_request);
+} else {
+    console.log("    - Running in unencrypted HTTP (ws://) mode");
+    webServer = http.createServer(http_request);
+}
+webServer.listen(source_port, function() {
+    wsServer = new WebSocketServer({server: webServer,
+                                    handleProtocols: selectProtocol});
+    wsServer.on('connection', new_client);
+});
+
+// Attach Flash policyfile answer service
+policyfile.createServer().listen(-1, webServer);

data/modules/emscripten/third_party/websockify/other/websockify.rb

@@ -0,0 +1,171 @@
+#!/usr/bin/env ruby
+
+# A WebSocket to TCP socket proxy
+# Copyright 2011 Joel Martin
+# Licensed under LGPL version 3 (see docs/LICENSE.LGPL-3)
+
+require 'socket'
+$: << "other"
+$: << "../other"
+require 'websocket'
+require 'optparse'
+
+# Proxy traffic to and from a WebSockets client to a normal TCP
+# socket server target. All traffic to/from the client is base64
+# encoded/decoded to allow binary data to be sent/received to/from
+# the target.
+class WebSocketProxy < WebSocketServer
+
+  @@Traffic_legend = "
+Traffic Legend:
+    }  - Client receive
+    }. - Client receive partial
+    {  - Target receive
+
+    >  - Target send
+    >. - Target send partial
+    <  - Client send
+    <. - Client send partial
+"
+
+
+  def initialize(opts)
+    vmsg "in WebSocketProxy.initialize"
+
+    super(opts)
+    
+    @target_host = opts["target_host"]
+    @target_port = opts["target_port"]
+  end
+
+  # Echo back whatever is received    
+  def new_client(client)
+
+    msg "connecting to: %s:%s" % [@target_host, @target_port]
+    tsock = TCPSocket.open(@target_host, @target_port)
+
+    if @verbose then puts @@Traffic_legend end
+
+    begin
+      do_proxy(client, tsock)
+    rescue
+      tsock.shutdown(Socket::SHUT_RDWR)
+      tsock.close
+      raise
+    end
+  end
+
+  # Proxy client WebSocket to normal target socket.
+  def do_proxy(client, target)
+    cqueue = []
+    c_pend = 0
+    tqueue = []
+    rlist = [client, target]
+
+    loop do
+      wlist = []
+
+      if tqueue.length > 0
+        wlist << target
+      end
+      if cqueue.length > 0 || c_pend > 0
+        wlist << client
+      end
+
+      ins, outs, excepts = IO.select(rlist, wlist, nil, 0.001)
+      if excepts && excepts.length > 0
+        raise Exception, "Socket exception"
+      end
+
+      # Send queued client data to the target
+      if outs && outs.include?(target)
+        dat = tqueue.shift
+        sent = target.send(dat, 0)
+        if sent == dat.length
+          traffic ">"
+        else
+          tqueue.unshift(dat[sent...dat.length])
+          traffic ".>"
+        end
+      end
+
+      # Receive target data and queue for the client
+      if ins && ins.include?(target)
+        buf = target.recv(@@Buffer_size)
+        if buf.length == 0:
+          raise EClose, "Target closed"
+        end
+
+        cqueue << buf
+        traffic "{"
+      end
+
+      # Encode and send queued data to the client
+      if outs && outs.include?(client)
+        c_pend = send_frames(cqueue)
+        cqueue = []
+      end
+
+      # Receive client data, decode it, and send it back
+      if ins && ins.include?(client)
+        frames, closed = recv_frames
+        tqueue += frames
+
+        if closed
+          send_close
+          raise EClose, closed
+        end
+      end
+
+    end  # loop
+  end
+end
+
+# Parse parameters
+opts = {}
+parser = OptionParser.new do |o|
+  o.on('--verbose', '-v') { |b| opts['verbose'] = b }
+  o.parse!
+end
+
+if ARGV.length < 2:
+  puts "Too few arguments"
+  exit 2
+end
+
+# Parse host:port and convert ports to numbers
+if ARGV[0].count(":") > 0
+  opts['listen_host'], _, opts['listen_port'] = ARGV[0].rpartition(':')
+else
+  opts['listen_host'], opts['listen_port'] = nil, ARGV[0]
+end
+
+begin
+  opts['listen_port'] = opts['listen_port'].to_i
+rescue
+  puts "Error parsing listen port"
+  exit 2
+end
+
+if ARGV[1].count(":") > 0
+  opts['target_host'], _, opts['target_port'] = ARGV[1].rpartition(':')
+else
+  puts "Error parsing target"
+  exit 2
+end
+
+begin
+  opts['target_port'] = opts['target_port'].to_i
+rescue
+  puts "Error parsing target port"
+  exit 2
+end
+
+puts "Starting server on #{opts['listen_host']}:#{opts['listen_port']}"
+server = WebSocketProxy.new(opts)
+server.start(100)
+server.join
+
+puts "Server has been terminated"
+
+# vim: sw=2

data/modules/emscripten/third_party/websockify/other/wswrap

@@ -0,0 +1,22 @@
+#!/usr/bin/env bash
+
+usage() {
+    echo "Usage: $(basename $0) PORT CMDLINE"
+    echo
+    echo "    PORT     Port to wrap with WebSockets support"
+    echo "    CMDLINE  Command line to wrap"
+    exit 2
+}
+
+# Parameter defaults
+mydir=$(readlink -f $(dirname ${0}))
+
+# Process parameters
+#while [ "${1}" != "${1#-}" ]; do
+#    param=$1; shift
+#done
+
+export WSWRAP_PORT="${1}"; shift
+
+LD_PRELOAD=${mydir}/wswrapper.so "${@}"
+

data/modules/emscripten/third_party/websockify/rebind

@@ -0,0 +1,18 @@
+#!/usr/bin/env bash
+
+usage() {
+    echo "Usage: $(basename $0) OLD_PORT NEW_PORT COMMAND_LINE"
+    echo
+    echo "Launch COMMAND_LINE, but intercept system calls to bind"
+    echo "to OLD_PORT and instead bind them to localhost:NEW_PORT"
+    exit 2
+}
+
+# Parameter defaults
+mydir=$(readlink -f $(dirname ${0}))
+
+export REBIND_PORT_OLD="${1}"; shift
+export REBIND_PORT_NEW="${1}"; shift
+
+LD_PRELOAD=${mydir}/rebind.so "${@}"
+

data/modules/emscripten/third_party/websockify/rebind.c

@@ -0,0 +1,94 @@
+/*
+ * rebind: Intercept bind calls and bind to a different port
+ * Copyright 2010 Joel Martin
+ * Licensed under LGPL version 3 (see docs/LICENSE.LGPL-3)
+ *
+ * Overload (LD_PRELOAD) bind system call. If REBIND_PORT_OLD and
+ * REBIND_PORT_NEW environment variables are set then bind on the new
+ * port (of localhost) instead of the old port. 
+ *
+ * This allows a proxy (such as wsproxy) to run on the old port and translate
+ * traffic to/from the new port.
+ *
+ * Usage:
+ *     LD_PRELOAD=./rebind.so \
+ *     REBIND_PORT_OLD=23 \
+ *     REBIND_PORT_NEW=2023 \
+ *     program
+ */
+
+//#define DO_DEBUG 1
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#define __USE_GNU 1  // Pull in RTLD_NEXT
+#include <dlfcn.h>
+
+#include <string.h>
+#include <netinet/in.h>
+
+
+#if defined(DO_DEBUG)
+#define DEBUG(...) \
+    fprintf(stderr, "rebind: "); \
+    fprintf(stderr, __VA_ARGS__);
+#else
+#define DEBUG(...)
+#endif
+
+
+int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen)
+{
+    static void * (*func)();
+    int do_move = 0;
+    struct sockaddr_in * addr_in = (struct sockaddr_in *)addr;
+    struct sockaddr_in addr_tmp;
+    socklen_t addrlen_tmp;
+    char * PORT_OLD, * PORT_NEW, * end1, * end2;
+    int ret, oldport, newport, askport = htons(addr_in->sin_port);
+    uint32_t askaddr = htons(addr_in->sin_addr.s_addr);
+    if (!func) func = (void *(*)()) dlsym(RTLD_NEXT, "bind");
+
+    DEBUG(">> bind(%d, _, %d), askaddr %d, askport %d\n",
+          sockfd, addrlen, askaddr, askport);
+
+    /* Determine if we should move this socket */
+    if (addr_in->sin_family == AF_INET) {
+        // TODO: support IPv6
+        PORT_OLD = getenv("REBIND_OLD_PORT");
+        PORT_NEW = getenv("REBIND_NEW_PORT");
+        if (PORT_OLD && (*PORT_OLD != '\0') &&
+            PORT_NEW && (*PORT_NEW != '\0')) {
+            oldport = strtol(PORT_OLD, &end1, 10);
+            newport = strtol(PORT_NEW, &end2, 10);
+            if (oldport && (*end1 == '\0') &&
+                newport && (*end2 == '\0') &&
+                (oldport == askport)) {
+                do_move = 1;
+            }
+        }
+    }
+
+    if (! do_move) {
+        /* Just pass everything right through to the real bind */
+        ret = (long) func(sockfd, addr, addrlen);
+        DEBUG("<< bind(%d, _, %d) ret %d\n", sockfd, addrlen, ret);
+        return ret;
+    }
+
+    DEBUG("binding fd %d on localhost:%d instead of 0x%x:%d\n",
+        sockfd, newport, ntohl(addr_in->sin_addr.s_addr), oldport);
+
+    /* Use a temporary location for the new address information */
+    addrlen_tmp = sizeof(addr_tmp);
+    memcpy(&addr_tmp, addr, addrlen_tmp);
+
+    /* Bind to other port on the loopback instead */
+    addr_tmp.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
+    addr_tmp.sin_port = htons(newport);
+    ret = (long) func(sockfd, &addr_tmp, addrlen_tmp);
+
+    DEBUG("<< bind(%d, _, %d) ret %d\n", sockfd, addrlen, ret);
+    return ret;
+}

data/modules/emscripten/third_party/websockify/run

@@ -0,0 +1,5 @@
+#!/usr/bin/python2
+
+import websockify
+
+websockify.websocketproxy.websockify_init()

data/modules/emscripten/third_party/websockify/setup.py

@@ -0,0 +1,30 @@
+from setuptools import setup, find_packages
+
+version = '0.2.1'
+name = 'websockify'
+long_description = open("README.md").read() + "\n" + \
+    open("CHANGES.txt").read() + "\n"
+
+setup(name=name,
+      version=version,
+      description="Websockify.",
+      long_description=long_description,
+      classifiers=[
+          "Programming Language :: Python",
+        ],
+      keywords='noVNC websockify',
+      license='LGPLv3',
+      url="https://github.com/kanaka/websockify",
+      author="Joel Martin",
+      author_email="github@martintribe.org",
+
+      packages=['websockify'],
+      include_package_data=True,
+      install_requires=['numpy'],
+      zip_safe=False,
+      entry_points={
+        'console_scripts': [
+            'websockify = websockify.websocketproxy:websockify_init',
+        ]
+      },
+    )

data/modules/emscripten/third_party/websockify/tests/b64_vs_utf8.py

@@ -0,0 +1,29 @@
+#!/usr/bin/env python
+
+from base64 import b64encode, b64decode
+from codecs import (utf_8_encode, utf_8_decode,
+                    latin_1_encode, latin_1_decode)
+import random, time
+
+buf_len = 10000
+iterations = 10000
+
+print "Generating random input buffer"
+r = random.Random()
+buf = "".join([chr(r.randint(0, 255)) for i in range(buf_len)])
+
+tests = {'UTF8 encode': lambda: utf_8_encode(unicode(buf, 'latin-1'))[0],
+         'B64 encode': lambda: b64encode(buf)}
+utf8_buf = tests['UTF8 encode']()
+b64_buf = tests['B64 encode']()
+tests.update({'UTF8 decode': lambda: latin_1_encode(utf_8_decode(utf8_buf)[0])[0],
+              'B64 decode': lambda: b64decode(b64_buf)})
+
+print "Running tests"
+for test in 'UTF8 encode', 'B64 encode', 'UTF8 decode', 'B64 decode':
+    start = time.time()
+    for i in range(iterations):
+        res_buf = tests[test]()
+    print "%s took %s seconds (result size %s)" % (
+            test, (time.time() -  start), len(res_buf))
+

data/modules/emscripten/third_party/websockify/tests/base64.html

@@ -0,0 +1,91 @@
+<!DOCTYPE html> 
+<html xmlns="http://www.w3.org/1999/xhtml"> 
+  <head> 
+    <title>Native Base64 Tests</title> 
+    <script src="include/util.js"></script> 
+    <script src="include/webutil.js"></script> 
+    <script src="include/base64.js"></script> 
+  </head> 
+  <body> 
+        <h1>Native Base64 Tests</h1> 
+ 
+        <br> 
+        Messages:<br> 
+        <textarea id="debug" style="font-size: 9px;" cols=80 rows=25></textarea> 
+    
+        <br>
+  </body> 
+ 
+<script> 
+    function debug(str) {
+        console.log(str);
+        cell = $D('debug');
+        cell.innerHTML += str + "\n";
+        cell.scrollTop = cell.scrollHeight;
+    }
+
+    function assertRun(code, result) {
+        try {
+            var actual = eval(code);
+        } catch (exc) {
+            debug("FAIL: '" + code + "' threw an exception");
+            fail += 1;
+            return false;
+        }
+        if (actual !== result) {
+            debug("FAIL: '" + code + "' returned '" + actual + "', expected '" + result + "'");
+            fail += 1;
+            return false;
+        }
+        debug("PASS: '" + code + "' returned expected '" + result +"'");
+        pass += 1;
+        return true;
+    }
+
+    function Base64_decode(data) {
+        var arr = Base64.decode (data);
+        return arr.map(function (num) {
+            return String.fromCharCode(num); } ).join('');
+
+    }
+
+    window.onload = function() {
+        var str;
+        debug('onload');
+        fail = 0;
+        pass = 0;
+        assertRun('window.btoa("hello world")', 'aGVsbG8gd29ybGQ=');
+        assertRun('window.btoa("a")', 'YQ==');
+        assertRun('window.btoa("ab")', 'YWI=');
+        assertRun('window.btoa("abc")', 'YWJj');
+        assertRun('window.btoa("abcd")', 'YWJjZA==');
+        assertRun('window.btoa("abcde")', 'YWJjZGU=');
+        assertRun('window.btoa("abcdef")', 'YWJjZGVm');
+        assertRun('window.btoa("abcdefg")', 'YWJjZGVmZw==');
+        assertRun('window.btoa("abcdefgh")', 'YWJjZGVmZ2g=');
+
+        assertRun('window.atob("aGVsbG8gd29ybGQ=")', 'hello world');
+        assertRun('Base64_decode("aGVsbG8gd29ybGQ=")', 'hello world');
+        assertRun('window.atob("YQ==")', 'a');
+        assertRun('Base64_decode("YQ==")', 'a');
+        assertRun('window.atob("YWI=")', 'ab');
+        assertRun('Base64_decode("YWI=")', 'ab');
+        assertRun('window.atob("YWJj")', 'abc');
+        assertRun('Base64_decode("YWJj")', 'abc');
+        assertRun('window.atob("YWJjZA==")', 'abcd');
+        assertRun('Base64_decode("YWJjZA==")', 'abcd');
+        assertRun('window.atob("YWJjZGU=")', 'abcde');
+        assertRun('Base64_decode("YWJjZGU=")', 'abcde');
+        assertRun('window.atob("YWJjZGVm")', 'abcdef');
+        assertRun('Base64_decode("YWJjZGVm")', 'abcdef');
+
+        assertRun('typeof window.btoa', 'function');
+        assertRun('window.btoa("")', '');
+        assertRun('window.btoa(null)', '');
+        assertRun('window.atob(window.btoa(window))', window.toString()); // "[object DOMWindow]"
+        assertRun('window.btoa("\\u0080\\u0081")', 'gIE=');
+
+        debug("Tests failed: " + fail);
+        debug("Tests passed: " + pass);
+    }
+</script> 

data/modules/emscripten/third_party/websockify/tests/base64.js

@@ -0,0 +1,12 @@
+// The following results in 'hello [MANGLED]'
+//
+// Filed as https://github.com/ry/node/issues/issue/402
+
+var sys = require("sys"),
+    buf = new Buffer(1024), len,
+    str1 = "aGVsbG8g",  // 'hello '
+    str2 = "d29ybGQ=",  // 'world'
+
+len = buf.write(str1, 0, 'base64');
+len += buf.write(str2, len, 'base64');
+sys.log("decoded result: " + buf.toString('binary', 0, len));