batman-rails-flo 0.0.1

data/vendor/assets/javascripts/batman_rails_flo/node_modules/fb-flo/node_modules/websocket/lib/xor.fallback.js

@@ -0,0 +1,13 @@
+module.exports = {
+    xor: function (payload, maskBytes, maskPos) {
+        var end = payload.length;
+        if (typeof(maskPos) !== 'number') {
+            maskPos = 0;
+        }
+        for (var i=0; i < end; i++) {
+            payload[i] = payload[i] ^ maskBytes[maskPos];
+            maskPos = (maskPos + 1) & 3;
+        }
+        return maskPos;
+    }
+};

data/vendor/assets/javascripts/batman_rails_flo/node_modules/fb-flo/node_modules/websocket/lib/xor.js

@@ -0,0 +1,18 @@
+/*
+ * Buffer xor module
+ * Copyright (c) Agora S.A.
+ * Licensed under the MIT License.
+ * Version: 1.0
+ */
+
+try {
+    module.exports = require('../build/Release/xor');
+} catch (e) { try {
+    module.exports = require('../build/default/xor');
+} catch(e) { try {
+    module.exports = require('./xor.fallback');
+    console.warn("Warning: Native modules not compiled.  XOR performance will be degraded.")
+} catch (e) {
+    console.error("xor.node seems not to have been built. Run npm install.")
+    throw e;
+}}}

data/vendor/assets/javascripts/batman_rails_flo/node_modules/fb-flo/node_modules/websocket/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "websocket",
+  "description": "Websocket Client & Server Library implementing the WebSocket protocol as specified in RFC 6455.",
+  "keywords": [
+    "websocket",
+    "websockets",
+    "socket",
+    "networking",
+    "comet",
+    "push"
+  ],
+  "author": {
+    "name": "Brian McKelvey",
+    "email": "brian@worlize.com",
+    "url": "https://www.worlize.com/"
+  },
+  "version": "1.0.8",
+  "repository": {
+    "type": "git",
+    "url": "http://github.com/Worlize/WebSocket-Node.git"
+  },
+  "engines": {
+    "node": ">=0.6.10"
+  },
+  "config": {
+    "verbose": false
+  },
+  "scripts": {
+    "install": "node install.js"
+  },
+  "main": "index",
+  "directories": {
+    "lib": "./lib"
+  },
+  "readme": "WebSocket Client & Server Implementation for Node\n=================================================\n\nOverview\n--------\nThis is a (mostly) pure JavaScript implementation of the WebSocket protocol versions 8 and 13 for Node.  There are some example client and server applications that implement various interoperability testing protocols in the \"test\" folder.\n\nCurrent News\n------------\n\n- As of version 1.0.7, ***Native modules are now optional.*** If they fail to compile, WebSocket-Node will still work but will not verify that received UTF-8 data is valid, and xor masking/unmasking of payload data for security purposes will not be as efficient as it is performed in JavaScript instead of native code.\n\n- Version 1.0.7 requires node v0.6.10, since that's the first version that I can manage to successfully build the native extensions with node-gyp through npm.  If anyone can figure out how to build native extensions in a way that works with both older and newer versions of Node, I'm happy to accept a patch!\n\n- If you want to support Unicode characters outside the Basic Multilingual Plane (BMP) you must use Node v0.8.x, which added support for representing these characters as surrogate pairs inside JavaScript strings.  Under Node v0.6.x, characters with code points greater than 65535 (greater than a 16-bit unsigned value) will have their code point truncated, resulting in seemingly unpredictable characters being returned.\n\n- WebSocket-Node was already [one of the fastest WebSocket libraries for Node](http://hobbycoding.posterous.com/websockt-binary-data-transfer-benchmark-rsult), and thanks to a small patch from [kazuyukitanimura](https://github.com/kazuyukitanimura), this library is now [up to 200% faster](http://hobbycoding.posterous.com/how-to-make-websocket-work-2x-faster-on-nodej) as of version 1.0.3!\n\nChangelog\n---------\n\nCurrent Version: 1.0.7\n\n[View the changelog](https://github.com/Worlize/WebSocket-Node/blob/master/CHANGELOG.md)\n\nBrowser Support\n---------------\n\n* Firefox 7-9 (Old) (Protocol Version 8)\n* Firefox 10+ (Protocol Version 13)\n* Chrome 14,15 (Old) (Protocol Version 8)\n* Chrome 16+ (Protocol Version 13)\n* Internet Explorer 10 (Preview) (Protocol Version 13)\n* Safari 6 (Protocol Version 13)\n\n***Safari older than 6.0 is not supported since it uses a very old draft of WebSockets***\n\nI made a decision early on to explicitly avoid maintaining multiple slightly different copies of the same code just to support the browsers currently in the wild.  The major browsers that support WebSocket are on a rapid-release schedule (with the exception of Safari) and now that the final version of the protocol has been [published as an official RFC](http://datatracker.ietf.org/doc/rfc6455/), it won't be long before support in the wild stabilizes on that version.  My client application is in Flash/ActionScript 3, so for my purposes I'm not dependent on the browser implementations.  *I made an exception to my stated intention here to support protocol version 8 along with 13, since only one minor thing changed and it was trivial to handle conditionally.*  The library now interoperates with other clients and servers implementing draft -08 all the way up through the final RFC.\n\n***If you need to simultaneously support legacy browser versions that had implemented draft-75/draft-76/draft-00, take a look here: https://gist.github.com/1428579***\n\nFor a WebSocket client written in ActionScript 3, see my [AS3WebScocket](https://github.com/Worlize/AS3WebSocket) project.\n\nBenchmarks\n----------\nThere are some basic benchmarking sections in the Autobahn test suite.  I've put up a [benchmark page](http://worlize.github.com/WebSocket-Node/benchmarks/) that shows the results from the Autobahn tests run against AutobahnServer 0.4.10, WebSocket-Node 1.0.2, WebSocket-Node 1.0.4, and ws 0.3.4.\n\nAutobahn Tests\n--------------\nThe very complete [Autobahn Test Suite](http://www.tavendo.de/autobahn/testsuite.html) is used by most WebSocket implementations to test spec compliance and interoperability.\n\n**Note about failing UTF-8 tests:** There are some UTF-8 validation tests that fail due to the fact that according to the ECMAScript spec, V8 and subsequently Node cannot support Unicode characters outside the BMP (Basic Multilingual Plane.)  JavaScript's String.fromCharCode() function truncates all code points to 16-bit, so you cannot decode higher plane code points in JavaScript.  Google's V8 uses UCS-2 as its internal string representation, and [they have no intention to change that any time soon](http://code.google.com/p/v8/issues/detail?id=761), so it is not possible to decode higher plane code points in C++, to the best of my knowledge, because those characters are not representable in UCS-2 anyway.  The Autobahn Test Suite requires that all valid Unicode code points survive a complete round trip, including code points that represent non-existent characters and characters above the BMP.  Since JavaScript cannot represent any characters with a code point >= 65535, no JavaScript implementation of WebSockets can pass these UTF-8 tests without using a cheat, such as echoing back the original binary data without decoding and re-encoding the UTF-8 data, which is not representative of real-world practical application.  ***I do not consider this to be a problem in the majority of circumstances*** since it is very unlikely to cause major issues in any real-world application as long as you don't need to use characters outside the BMP.\n**Update:** This issue seems to have been resolved in the version of V8 used in Node 0.8.x.  I believe they are using surrogate-pairs to accommodate characters that are outside the BMP, but I haven't looked into it.\n\n- [View Server Test Results](http://worlize.github.com/WebSocket-Node/test-report/servers/)\n- [View Client Test Results](http://worlize.github.com/WebSocket-Node/test-report/clients/)\n\nNotes\n-----\nThis library has been used in production on [worlize.com](https://www.worlize.com) since April 2011 and seems to be stable.  Your mileage may vary.\n\n**Tested with the following node versions:**\n\n- 0.6.18\n- 0.8.6\n\nIt may work in earlier or later versions but I'm not actively testing it outside of the listed versions.  YMMV.\n\nDocumentation\n=============\n\nFor more complete documentation, see the [Documentation Wiki](https://github.com/Worlize/WebSocket-Node/wiki/Documentation).\n\nInstallation\n------------\n\nA few users have reported difficulties building the native extensions without first manually installing node-gyp.  If you have trouble building the native extensions, make sure you've got a C++ compiler, and have done `npm install -g node-gyp` first. \n\nNative extensions are optional, however, and WebSocket-Node will work even if the extensions cannot be compiled.\n\nIn your project root:\n\n    $ npm install websocket\n  \nThen in your code:\n\n```javascript\nvar WebSocketServer = require('websocket').server;\nvar WebSocketClient = require('websocket').client;\nvar WebSocketFrame  = require('websocket').frame;\nvar WebSocketRouter = require('websocket').router;\n```\n\nNote for Windows Users\n----------------------\nBecause there is a small C++ component used for validating UTF-8 data, you will need to install a few other software packages in addition to Node to be able to build this module:\n\n- [Microsoft Visual C++](http://www.microsoft.com/visualstudio/en-us/products/2010-editions/visual-cpp-express)\n- [Python 2.7](http://www.python.org/download/) (NOT Python 3.x)\n\n\nCurrent Features:\n-----------------\n- Licensed under the Apache License, Version 2.0\n- Protocol version \"8\" and \"13\" (Draft-08 through the final RFC) framing and handshake\n- Can handle/aggregate received fragmented messages\n- Can fragment outgoing messages\n- Router to mount multiple applications to various path and protocol combinations\n- TLS supported for outbound connections via WebSocketClient\n- TLS supported for server connections (use https.createServer instead of http.createServer)\n  - Thanks to [pors](https://github.com/pors) for confirming this!\n- Cookie setting and parsing\n- Tunable settings\n  - Max Receivable Frame Size\n  - Max Aggregate ReceivedMessage Size\n  - Whether to fragment outgoing messages\n  - Fragmentation chunk size for outgoing messages\n  - Whether to automatically send ping frames for the purposes of keepalive\n  - Keep-alive ping interval\n  - Whether or not to automatically assemble received fragments (allows application to handle individual fragments directly)\n  - How long to wait after sending a close frame for acknowledgment before closing the socket.\n\n\nKnown Issues/Missing Features:\n------------------------------\n- No API for user-provided protocol extensions.\n\n\nUsage Examples\n==============\n\nServer Example\n--------------\n\nHere's a short example showing a server that echos back anything sent to it, whether utf-8 or binary.\n\n```javascript\n#!/usr/bin/env node\nvar WebSocketServer = require('websocket').server;\nvar http = require('http');\n\nvar server = http.createServer(function(request, response) {\n    console.log((new Date()) + ' Received request for ' + request.url);\n    response.writeHead(404);\n    response.end();\n});\nserver.listen(8080, function() {\n    console.log((new Date()) + ' Server is listening on port 8080');\n});\n\nwsServer = new WebSocketServer({\n    httpServer: server,\n    // You should not use autoAcceptConnections for production\n    // applications, as it defeats all standard cross-origin protection\n    // facilities built into the protocol and the browser.  You should\n    // *always* verify the connection's origin and decide whether or not\n    // to accept it.\n    autoAcceptConnections: false\n});\n\nfunction originIsAllowed(origin) {\n  // put logic here to detect whether the specified origin is allowed.\n  return true;\n}\n\nwsServer.on('request', function(request) {\n    if (!originIsAllowed(request.origin)) {\n      // Make sure we only accept requests from an allowed origin\n      request.reject();\n      console.log((new Date()) + ' Connection from origin ' + request.origin + ' rejected.');\n      return;\n    }\n    \n    var connection = request.accept('echo-protocol', request.origin);\n    console.log((new Date()) + ' Connection accepted.');\n    connection.on('message', function(message) {\n        if (message.type === 'utf8') {\n            console.log('Received Message: ' + message.utf8Data);\n            connection.sendUTF(message.utf8Data);\n        }\n        else if (message.type === 'binary') {\n            console.log('Received Binary Message of ' + message.binaryData.length + ' bytes');\n            connection.sendBytes(message.binaryData);\n        }\n    });\n    connection.on('close', function(reasonCode, description) {\n        console.log((new Date()) + ' Peer ' + connection.remoteAddress + ' disconnected.');\n    });\n});\n```\n\nClient Example\n--------------\n\nThis is a simple example client that will print out any utf-8 messages it receives on the console, and periodically sends a random number.\n\n*This code demonstrates a client in Node.js, not in the browser*\n\n```javascript\n#!/usr/bin/env node\nvar WebSocketClient = require('websocket').client;\n\nvar client = new WebSocketClient();\n\nclient.on('connectFailed', function(error) {\n    console.log('Connect Error: ' + error.toString());\n});\n\nclient.on('connect', function(connection) {\n    console.log('WebSocket client connected');\n    connection.on('error', function(error) {\n        console.log(\"Connection Error: \" + error.toString());\n    });\n    connection.on('close', function() {\n        console.log('echo-protocol Connection Closed');\n    });\n    connection.on('message', function(message) {\n        if (message.type === 'utf8') {\n            console.log(\"Received: '\" + message.utf8Data + \"'\");\n        }\n    });\n    \n    function sendNumber() {\n        if (connection.connected) {\n            var number = Math.round(Math.random() * 0xFFFFFF);\n            connection.sendUTF(number.toString());\n            setTimeout(sendNumber, 1000);\n        }\n    }\n    sendNumber();\n});\n\nclient.connect('ws://localhost:8080/', 'echo-protocol');\n```\n    \nRequest Router Example\n----------------------\n\nFor an example of using the request router, see `libwebsockets-test-server.js` in the `test` folder.\n\n\nResources\n---------\n\nA presentation on the state of the WebSockets protocol that I gave on July 23, 2011 at the LA Hacker News meetup.  [WebSockets: The Real-Time Web, Delivered](http://www.scribd.com/doc/60898569/WebSockets-The-Real-Time-Web-Delivered)",
+  "readmeFilename": "README.md",
+  "bugs": {
+    "url": "https://github.com/Worlize/WebSocket-Node/issues"
+  },
+  "homepage": "https://github.com/Worlize/WebSocket-Node",
+  "_id": "websocket@1.0.8",
+  "_from": "websocket@~1.0.8"
+}

data/vendor/assets/javascripts/batman_rails_flo/node_modules/fb-flo/node_modules/websocket/src/validation.cc

@@ -0,0 +1,144 @@
+/*!
+ * UTF-8 Validation Code originally from:
+ * ws: a node.js websocket client
+ * Copyright(c) 2011 Einar Otto Stangvik <einaros@gmail.com>
+ * MIT Licensed
+ */
+
+#include <v8.h>
+#include <node.h>
+#include <node_buffer.h>
+#include <node_object_wrap.h>
+#include <stdlib.h>
+#include <wchar.h>
+#include <stdio.h>
+
+using namespace v8;
+using namespace node;
+
+#define UNI_SUR_HIGH_START   (uint32_t) 0xD800
+#define UNI_SUR_LOW_END    (uint32_t) 0xDFFF
+#define UNI_REPLACEMENT_CHAR (uint32_t) 0x0000FFFD
+#define UNI_MAX_LEGAL_UTF32  (uint32_t) 0x0010FFFF
+
+static const uint8_t trailingBytesForUTF8[256] = {
+  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+  1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+  2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2, 3,3,3,3,3,3,3,3,4,4,4,4,5,5,5,5
+};
+
+static const uint32_t offsetsFromUTF8[6] = {
+  0x00000000, 0x00003080, 0x000E2080,
+  0x03C82080, 0xFA082080, 0x82082080
+};
+
+static int isLegalUTF8(const uint8_t *source, const int length)
+{
+  uint8_t a;
+  const uint8_t *srcptr = source+length;
+  switch (length) {
+  default: return 0;
+  /* Everything else falls through when "true"... */
+  /* RFC3629 makes 5 & 6 bytes UTF-8 illegal
+  case 6: if ((a = (*--srcptr)) < 0x80 || a > 0xBF) return 0; 
+  case 5: if ((a = (*--srcptr)) < 0x80 || a > 0xBF) return 0; */
+  case 4: if ((a = (*--srcptr)) < 0x80 || a > 0xBF) return 0;
+  case 3: if ((a = (*--srcptr)) < 0x80 || a > 0xBF) return 0;
+  case 2: if ((a = (*--srcptr)) > 0xBF) return 0;
+    switch (*source) {
+      /* no fall-through in this inner switch */
+      case 0xE0: if (a < 0xA0) return 0; break;
+      case 0xED: if (a > 0x9F) return 0; break;
+      case 0xF0: if (a < 0x90) return 0; break;
+      case 0xF4: if (a > 0x8F) return 0; break;
+      default:   if (a < 0x80) return 0;
+    }
+
+  case 1: if (*source >= 0x80 && *source < 0xC2) return 0;
+  }
+  if (*source > 0xF4) return 0;
+  return 1;
+}
+
+int is_valid_utf8 (size_t len, char *value)
+{
+  /* is the string valid UTF-8? */
+  for (size_t i = 0; i < len; i++) {
+    uint32_t ch = 0;
+    uint8_t  extrabytes = trailingBytesForUTF8[(uint8_t) value[i]];
+
+    if (extrabytes + i >= len)
+      return 0;
+
+    if (isLegalUTF8 ((uint8_t *) (value + i), extrabytes + 1) == 0) return 0;      
+
+    switch (extrabytes) {
+      case 5 : ch += (uint8_t) value[i++]; ch <<= 6;
+      case 4 : ch += (uint8_t) value[i++]; ch <<= 6;
+      case 3 : ch += (uint8_t) value[i++]; ch <<= 6;
+      case 2 : ch += (uint8_t) value[i++]; ch <<= 6;
+      case 1 : ch += (uint8_t) value[i++]; ch <<= 6;
+      case 0 : ch += (uint8_t) value[i];
+    }
+
+    ch -= offsetsFromUTF8[extrabytes];
+
+    if (ch <= UNI_MAX_LEGAL_UTF32) {
+      if (ch >= UNI_SUR_HIGH_START && ch <= UNI_SUR_LOW_END)
+        return 0;
+    } else {
+      return 0;
+    }
+  }
+
+  return 1;
+}
+
+class Validation : public ObjectWrap
+{
+public:
+  
+  static void Initialize(v8::Handle<v8::Object> target)
+  {
+    HandleScope scope;
+    Local<FunctionTemplate> t = FunctionTemplate::New(New);
+    t->InstanceTemplate()->SetInternalFieldCount(1);
+    NODE_SET_METHOD(t->GetFunction(), "isValidUTF8", Validation::IsValidUTF8);
+    target->Set(String::NewSymbol("Validation"), t->GetFunction());
+  }
+  
+protected:
+  
+  static Handle<Value> New(const Arguments& args)
+  {
+    HandleScope scope;
+    Validation* validation = new Validation();
+    validation->Wrap(args.This());
+    return args.This();
+  }
+  
+  static Handle<Value> IsValidUTF8(const Arguments& args)
+  {
+    HandleScope scope;
+    if (!Buffer::HasInstance(args[0])) {
+      return ThrowException(Exception::Error(String::New("First argument needs to be a buffer")));
+    }
+    Local<Object> buffer_obj = args[0]->ToObject();
+    char *buffer_data = Buffer::Data(buffer_obj);
+    size_t buffer_length = Buffer::Length(buffer_obj);    
+    return is_valid_utf8(buffer_length, buffer_data) == 1 ? scope.Close(True()) : scope.Close(False());
+   }  
+};
+
+extern "C" void init (Handle<Object> target)
+{
+  HandleScope scope;
+  Validation::Initialize(target);
+}
+
+NODE_MODULE(validation, init);

data/vendor/assets/javascripts/batman_rails_flo/node_modules/fb-flo/node_modules/websocket/src/xor.cpp

@@ -0,0 +1,86 @@
+/*!
+ * Buffer xor module
+ * Copyright (c) Agora S.A.
+ * Licensed under the MIT License.
+ * Version: 1.0
+ */
+
+#include <v8.h>
+#include <node_buffer.h>
+#include <cstring>
+
+using namespace node;
+using namespace v8;
+
+namespace {
+  #define XOR_BUFFER_THROW_EXCEPTION(name, msg) { \
+    static Persistent<String> name = Persistent<String>::New(String::New(msg)); \
+    return ThrowException(Exception::TypeError(name)); }
+
+  static Handle<Value> xorBuffer(const Arguments &args) {
+    if (args.Length() < 2) {
+      XOR_BUFFER_THROW_EXCEPTION(illegalArgumentCountException, "Expected 2 arguments")
+    }
+
+    if (!Buffer::HasInstance(args[0])) {
+      XOR_BUFFER_THROW_EXCEPTION(illegalFirstArgumentException, "First argument must be a Buffer.")
+    }
+    Handle<Object> payload = args[0]->ToObject();
+
+    if (!Buffer::HasInstance(args[1])) {
+      XOR_BUFFER_THROW_EXCEPTION(illegalArgumentException, "Second argument must be a Buffer.")
+    }
+    Handle<Object> mask = args[1]->ToObject();
+    size_t maskSize = Buffer::Length(mask);
+
+    if (maskSize != 4) {
+      XOR_BUFFER_THROW_EXCEPTION(illegalStringArgumentException, "Second argument must be a 4 byte Buffer.")
+    }
+
+    size_t maskOffset = 0;
+    if (args.Length() == 3) {
+      if (!args[2]->IsUint32()) {
+        XOR_BUFFER_THROW_EXCEPTION(illegalThirdArgumentException, "Third argument must be an unsigned number.")
+      }
+      maskOffset = args[2]->ToUint32()->Uint32Value();
+    }
+
+    if (maskOffset > 3) {
+      XOR_BUFFER_THROW_EXCEPTION(illegalStringArgumentException, "Third argument must be less than 4.")
+    }
+
+    size_t payloadLength = Buffer::Length(payload);
+    uint8_t* payloadData = (uint8_t*) Buffer::Data(payload);
+    uint8_t* maskData = (uint8_t*) Buffer::Data(mask);
+
+    uint8_t rotatedMask[4];
+    memcpy(rotatedMask, maskData + maskOffset, 4 - maskOffset);
+    if (maskOffset > 0) {
+      memcpy(rotatedMask + 4 - maskOffset, maskData, maskOffset);
+    }
+
+    uint32_t* pos32 = (uint32_t*) payloadData;
+    uint32_t* end32 = pos32 + (payloadLength >> 2);
+    uint32_t* mask32 = (uint32_t*) rotatedMask;
+
+    while (pos32 < end32) {
+      *(pos32++) ^= *mask32;
+    }
+
+    uint8_t* pos8 = (uint8_t*)pos32;
+    uint8_t* end8 = payloadData + payloadLength;
+    uint8_t* mask8 = rotatedMask;
+
+    while (pos8 < end8) {
+      *(pos8++) ^= *(mask8++);
+    }
+
+    return Integer::NewFromUnsigned((mask8 - rotatedMask + maskOffset) & 3);
+  }
+
+  void RegisterModule(Handle<Object> target) {
+    NODE_SET_METHOD(target, "xor", xorBuffer);
+  }
+}
+
+NODE_MODULE(xor, RegisterModule);

data/vendor/assets/javascripts/batman_rails_flo/node_modules/fb-flo/node_modules/websocket/vendor/FastBufferList.js

@@ -0,0 +1,192 @@
+// This file was copied from https://github.com/substack/node-bufferlist
+// and modified to be able to copy bytes from the bufferlist directly into
+// a pre-existing fixed-size buffer without an additional memory allocation.
+
+// bufferlist.js
+// Treat a linked list of buffers as a single variable-size buffer.
+var Buffer = require('buffer').Buffer;
+var EventEmitter = require('events').EventEmitter;
+
+module.exports = BufferList;
+module.exports.BufferList = BufferList; // backwards compatibility
+
+function BufferList(opts) {
+    if (!(this instanceof BufferList)) return new BufferList(opts);
+    EventEmitter.call(this);
+    var self = this;
+    
+    if (typeof(opts) == 'undefined') opts = {};
+    
+    // default encoding to use for take(). Leaving as 'undefined'
+    // makes take() return a Buffer instead.
+    self.encoding = opts.encoding;
+    
+    // constructor to use for Buffer-esque operations
+    self.construct = opts.construct || Buffer;
+    
+    var head = { next : null, buffer : null };
+    var last = { next : null, buffer : null };
+    
+    // length can get negative when advanced past the end
+    // and this is the desired behavior
+    var length = 0;
+    self.__defineGetter__('length', function () {
+        return length;
+    });
+    
+    // keep an offset of the head to decide when to head = head.next
+    var offset = 0;
+    
+    // Write to the bufferlist. Emits 'write'. Always returns true.
+    self.write = function (buf) {
+        if (!head.buffer) {
+            head.buffer = buf;
+            last = head;
+        }
+        else {
+            last.next = { next : null, buffer : buf };
+            last = last.next;
+        }
+        length += buf.length;
+        self.emit('write', buf);
+        return true;
+    };
+    
+    self.end = function (buf) {
+        if (Buffer.isBuffer(buf)) self.write(buf);
+    };
+    
+    // Push buffers to the end of the linked list. (deprecated)
+    // Return this (self).
+    self.push = function () {
+        var args = [].concat.apply([], arguments);
+        args.forEach(self.write);
+        return self;
+    };
+    
+    // For each buffer, perform some action.
+    // If fn's result is a true value, cut out early.
+    // Returns this (self).
+    self.forEach = function (fn) {
+        if (!head.buffer) return new self.construct(0);
+        
+        if (head.buffer.length - offset <= 0) return self;
+        var firstBuf = head.buffer.slice(offset);
+        
+        var b = { buffer : firstBuf, next : head.next };
+        
+        while (b && b.buffer) {
+            var r = fn(b.buffer);
+            if (r) break;
+            b = b.next;
+        }
+        
+        return self;
+    };
+    
+    // Create a single Buffer out of all the chunks or some subset specified by
+    // start and one-past the end (like slice) in bytes.
+    self.join = function (start, end) {
+        if (!head.buffer) return new self.construct(0);
+        if (start == undefined) start = 0;
+        if (end == undefined) end = self.length;
+        
+        var big = new self.construct(end - start);
+        var ix = 0;
+        self.forEach(function (buffer) {
+            if (start < (ix + buffer.length) && ix < end) {
+                // at least partially contained in the range
+                buffer.copy(
+                    big,
+                    Math.max(0, ix - start),
+                    Math.max(0, start - ix),
+                    Math.min(buffer.length, end - ix)
+                );
+            }
+            ix += buffer.length;
+            if (ix > end) return true; // stop processing past end
+        });
+        
+        return big;
+    };
+    
+    self.joinInto = function (targetBuffer, targetStart, sourceStart, sourceEnd) {
+        if (!head.buffer) return new self.construct(0);
+        if (sourceStart == undefined) sourceStart = 0;
+        if (sourceEnd == undefined) sourceEnd = self.length;
+        
+        var big = targetBuffer;
+        if (big.length - targetStart < sourceEnd - sourceStart) {
+            throw new Error("Insufficient space available in target Buffer.");
+        }
+        var ix = 0;
+        self.forEach(function (buffer) {
+            if (sourceStart < (ix + buffer.length) && ix < sourceEnd) {
+                // at least partially contained in the range
+                buffer.copy(
+                    big,
+                    Math.max(targetStart, targetStart + ix - sourceStart),
+                    Math.max(0, sourceStart - ix),
+                    Math.min(buffer.length, sourceEnd - ix)
+                );
+            }
+            ix += buffer.length;
+            if (ix > sourceEnd) return true; // stop processing past end
+        });
+        
+        return big;
+    };
+    
+    // Advance the buffer stream by n bytes.
+    // If n the aggregate advance offset passes the end of the buffer list,
+    // operations such as .take() will return empty strings until enough data is
+    // pushed.
+    // Returns this (self).
+    self.advance = function (n) {
+        offset += n;
+        length -= n;
+        while (head.buffer && offset >= head.buffer.length) {
+            offset -= head.buffer.length;
+            head = head.next
+                ? head.next
+                : { buffer : null, next : null }
+            ;
+        }
+        self.emit('advance', n);
+        return self;
+    };
+    
+    // Take n bytes from the start of the buffers.
+    // Returns a string.
+    // If there are less than n bytes in all the buffers or n is undefined,
+    // returns the entire concatenated buffer string.
+    self.take = function (n, encoding) {
+        if (n == undefined) n = self.length;
+        else if (typeof n !== 'number') {
+            encoding = n;
+            n = self.length;
+        }
+        var b = head;
+        if (!encoding) encoding = self.encoding;
+        if (encoding) {
+            var acc = '';
+            self.forEach(function (buffer) {
+                if (n <= 0) return true;
+                acc += buffer.toString(
+                    encoding, 0, Math.min(n,buffer.length)
+                );
+                n -= buffer.length;
+            });
+            return acc;
+        } else {
+            // If no 'encoding' is specified, then return a Buffer.
+            return self.join(0, n);
+        }
+    };
+    
+    // The entire concatenated buffer as a string.
+    self.toString = function () {
+        return self.take('binary');
+    };
+}
+require('util').inherits(BufferList, EventEmitter);