diff --git a/README.md b/README.md
index 0ae3764..eb8b09f 100644
--- a/README.md
+++ b/README.md
@@ -8,26 +8,17 @@ Table of Contents
   * [Overview](#overview)
     * [Introduction](#introduction)
     * [Contributing](#contributing)
-    * [I still like Burp, but Pappy looks interesting, can I use both?](#i-still-like-burp-but-pappy-looks-interesting-can-i-use-both)
   * [How to Use It](#how-to-use-it)
     * [Installation](#installation)
     * [Quickstart](#quickstart)
     * [Lite Mode](#lite-mode)
     * [Adding The CA Cert to Your Browser](#adding-the-ca-cert-to-your-browser)
-      * [Firefox](#firefox)
-      * [Chrome](#chrome)
-      * [Safari](#safari)
-      * [Internet Explorer](#internet-explorer)
     * [Configuration](#configuration)
     * [General Console Techniques](#general-console-techniques)
-      * [Run a shell command](#run-a-shell-command)
-      * [Running Python Code](#running-python-code)
-      * [Redirect Output To File](#redirect-output-to-file)
     * [Generating Pappy's CA Cert](#generating-pappys-ca-cert)
     * [Browsing Recorded Requests/Responses](#browsing-recorded-requestsresponses)
     * [Tags](#tags)
     * [Request IDs](#request-ids)
-      * [Passing Multiple Request IDs to a Command](#passing-multiple-request-ids-to-a-command)
     * [Context](#context)
     * [Filter Strings](#filter-strings)
       * [List of fields](#list-of-fields)
@@ -39,19 +30,14 @@ Table of Contents
     * [Interceptor](#interceptor)
     * [Repeater](#repeater)
     * [Macros](#macros)
-      * [Generating Macros From Requests](#generating-macros-from-requests)
-      * [Request Objects](#request-objects)
-      * [Useful Functions](#useful-functions)
     * [Intercepting Macros](#intercepting-macros)
-      * [Enabling/Disabling Intercepting Macros](#enablingdisabling-intercepting-macros)
     * [Macro Templates](#macro-templates)
     * [Resubmitting Groups of Requests](#resubmitting-groups-of-requests)
     * [Logging](#logging)
     * [Additional Commands and Features](#additional-commands-and-features)
-      * [Response streaming](#response-streaming)
     * [Viewing Responses In Browser](#viewing-responses-in-browser)
+    * [Websockets](#websockets)
     * [Plugins](#plugins)
-      * [Should I Write a Plugin or a Macro?](#should-i-write-a-plugin-or-a-macro)
     * [Global Settings](#global-settings)
     * [Using an HTTP Proxy](#using-an-http-proxy)
     * [Using a SOCKS Proxy](#using-a-socks-proxy)
@@ -99,12 +85,15 @@ How to Use It
 Installation
 ------------
 Pappy supports OS X and Linux (sorry Windows). Installation requires `pip` or some other command that can handle a `setup.py` with requirements. Once the requirements are installed, you can check that it installed correctly by running `pappy -l` to start the proxy.
+
 ```
 $ git clone --recursive https://github.com/roglew/pappy-proxy.git
 $ cd pappy-proxy
 $ pip install .
 ```
 
+It is also possible (and encouraged!) to install pappy into a [virtual environment](http://docs.python-guide.org/en/latest/dev/virtualenvs/). After installing into a virtual environment, you will have to enter the virtual environment each time you want to run Pappy.
+
 Quickstart
 ----------
 Pappy projects take up an entire directory. Any generated scripts, exported responses, plugin data, etc. will be placed in the current directory so it's good to give your project a directory of its own. To start a project, do something like:
@@ -313,8 +302,9 @@ The following commands can be used to view requests and responses
 | Command | Aliases | Description |
 |:--------|:--------|:------------|
 | `ls [a|<num>]`| list, ls |List requests that are in the current context (see Context section). Has information like the host, target path, and status code. With no arguments, it will print the 25 most recent requests in the current context. If you pass 'a' or 'all' as an argument, it will print all the requests in the current context. If you pass a number "n" as an argument, it will print the n most recent requests in the current context. |
-| `sm [p]` | sm, site_map | Print a tree showing the site map. It will display all requests in the current context that did not have a 404 response. This has to go through all of the requests in the current context so it may be slow. If the `p` option is given, it will print the paths as paths rather than as a tree. | | `viq <id(s)>` | view_request_info, viq | View additional information about requests. Includes the target port, if SSL was used, applied tags, and other information. |
-| `vfq <id(s)>` | view_full_request, vfq, kjq | [V]iew [F]ull Re[Q]uest, prints the full request including headers and data. |
+| `sm [p]` | sm, site_map | Print a tree showing the site map. It will display all requests in the current context that did not have a 404 response. This has to go through all of the requests in the current context so it may be slow. If the `p` option is given, it will print the paths as paths rather than as a tree. |
+| `viq <id(s)>` | view_request_info, viq | View additional information about requests. Includes the target port, if SSL was used, applied tags, and other information. |
+| `vfq <id(s)>` | view_full_request, vfq, kjq | [V]iew [F]ull Re[Q]uest, prints the full request including headers and data. If the request is part of a websocket handshake, it will also print the messages sent over the websocket. |
 | `vbq <id(s)>` | view_request_bytes, vbq | [V]iew [B]ytes of Re[Q]uest, prints the full request including headers and data without coloring or additional newlines. Use this if you want to write a request to a file. |
 | `ppq <format> <id(s)> ` | pretty_print_request, ppq | Pretty print a request with a specific format. See the table below for a list of formats. |
 | `vhq <id(s)>` | view_request_headers, vhq | [V]iew [H]eaders of a Re[Q]uest. Prints just the headers of a request. |
@@ -324,6 +314,7 @@ The following commands can be used to view requests and responses
 | `pps <format> <id(s)>` | pretty_print_response, pps | Pretty print a response with a specific format. See the table below for a list of formats. |
 | `pprm <id(s)>` | print_params, pprm | Print a summary of the parameters submitted with the request. It will include URL params, POST params, and/or cookies |
 | `pri [ct] [key(s)]` | param_info, pri | Print a summary of the parameters and values submitted by in-context requests. You can pass in keys to limit which values will be shown. If you also provide `ct` as the first argument, it will include any keys that are passed as arguments. |
+| `urls <id(s)>` | urls | Search the full request and response of the given IDs for urls and prints them. Especially useful with a wildcard (`*`) to find URLs from all history. |
 | `watch` | watch | Print requests and responses in real time as they pass through the proxy. |
 
 Available formats for `ppq` and `pps` commands:
@@ -402,6 +393,98 @@ The context is a set of filters that define which requests are considered "activ
 | `fls` | filter_list, fls | Print the filters that make up the current context |
 | `filter_prune` | filter_prune | Delete all the requests that aren't in the current context from the data file |
 
+You are also able to save and load contexts. When saving a context you pass the command a name. The context can then be loaded with that name. Whenever you load a context, the current context is saved with the name `_` to make it easier to quickly load a context, view requests, then return to the original context.
+
+| Command | Aliases | Description |
+|:--------|:------------|:---|
+| `sc <name>` | `sc`, `save_context` | Save the current filters with the provided name. |
+| `lc <name>` | `lc`, `load_context` | Load a saved context by its name. |
+| `dc <name>` | `dc`, `delete_context` | Delete a saved context by its name. |
+| `cls` | `cls`, `list_contexts` | Show a list of saved contexts and the filters for each of them. |
+
+Here is an example session demonstrating saving/loading contexts:
+
+```
+pappy> ls
+ID  Verb  Host                 Path                                      S-Code         Req Len  Rsp Len  Time  Mngl
+16  GET   cdn.sstatic.net      /img/developer-story/announcement_ban...  200 OK         0        10515    0.06  --
+15  GET   cdn.sstatic.net      /Sites/stackoverflow/img/sprites.svg?...  200 OK         0        8131     0.05  --
+14  GET   i.stack.imgur.com    /eoNf5.png                                403 Forbidden  0        173      0.07  --
+13  GET   cdn.sstatic.net      /img/developer-story/announcement_ban...  200 OK         0        12919    0.07  --
+12  GET   cdn.sstatic.net      /img/favicons-sprite16.png?v=4b071e01...  200 OK         0        66460    0.09  --
+11  GET   i.stack.imgur.com    /xqoqk.png                                403 Forbidden  0        173      0.07  --
+10  GET   i.stack.imgur.com    /6HFc3.png                                403 Forbidden  0        173      0.06  --
+9   GET   i.stack.imgur.com    /tKsDb.png                                403 Forbidden  0        173      0.06  --
+8   GET   i.stack.imgur.com    /5d55j.png                                403 Forbidden  0        173      0.08  --
+7   GET   cdn.sstatic.net      /Js/full-anon.en.js?v=a65ef7e053bb        200 OK         0        116828   0.27  --
+6   GET   cdn.sstatic.net      /img/share-sprite-new.svg?v=78be252218f3  200 OK         0        34771    0.93  --
+5   GET   cdn.sstatic.net      /clc/clc.min.js?v=6f49b407ccbc            200 OK         0        6969     0.92  --
+4   GET   cdn.sstatic.net      /Sites/stackoverflow/all.css?v=40629f...  200 OK         0        476855   0.07  --
+3   GET   cdn.sstatic.net      /Js/stub.en.js?v=5cc84a62e045             200 OK         0        38661    0.08  --
+2   GET   ajax.googleapis.com  /ajax/libs/jquery/1.12.4/jquery.min.js    200 OK         0        97163    0.09  --
+1   GET   stackoverflow.com    /                                         200 OK         0        244280   0.43  --
+pappy> fbi not_jscss
+path nctr "(\.js$|\.css$)"
+pappy> fbi not_image
+path nctr "(\.png$|\.jpg$|\.gif$)"
+pappy> sc clean
+Filters saved to clean:
+  path nctr "(\.js$|\.css$)"
+  path nctr "(\.png$|\.jpg$|\.gif$)"
+pappy> cls
+Saved contexts:
+clean
+  path nctr "(\.js$|\.css$)"
+  path nctr "(\.png$|\.jpg$|\.gif$)"
+
+pappy> sr
+pappy> fls
+pappy> f host ct sstatic
+pappy> ls
+ID  Verb  Host             Path                                      S-Code  Req Len  Rsp Len  Time  Mngl
+16  GET   cdn.sstatic.net  /img/developer-story/announcement_ban...  200 OK  0        10515    0.06  --
+15  GET   cdn.sstatic.net  /Sites/stackoverflow/img/sprites.svg?...  200 OK  0        8131     0.05  --
+13  GET   cdn.sstatic.net  /img/developer-story/announcement_ban...  200 OK  0        12919    0.07  --
+12  GET   cdn.sstatic.net  /img/favicons-sprite16.png?v=4b071e01...  200 OK  0        66460    0.09  --
+7   GET   cdn.sstatic.net  /Js/full-anon.en.js?v=a65ef7e053bb        200 OK  0        116828   0.27  --
+6   GET   cdn.sstatic.net  /img/share-sprite-new.svg?v=78be252218f3  200 OK  0        34771    0.93  --
+5   GET   cdn.sstatic.net  /clc/clc.min.js?v=6f49b407ccbc            200 OK  0        6969     0.92  --
+4   GET   cdn.sstatic.net  /Sites/stackoverflow/all.css?v=40629f...  200 OK  0        476855   0.07  --
+3   GET   cdn.sstatic.net  /Js/stub.en.js?v=5cc84a62e045             200 OK  0        38661    0.08  --
+pappy> lc clean
+Set the context to:
+  path nctr "(\.js$|\.css$)"
+  path nctr "(\.png$|\.jpg$|\.gif$)"
+pappy> ls
+ID  Verb  Host               Path                                      S-Code  Req Len  Rsp Len  Time  Mngl
+16  GET   cdn.sstatic.net    /img/developer-story/announcement_ban...  200 OK  0        10515    0.06  --
+15  GET   cdn.sstatic.net    /Sites/stackoverflow/img/sprites.svg?...  200 OK  0        8131     0.05  --
+13  GET   cdn.sstatic.net    /img/developer-story/announcement_ban...  200 OK  0        12919    0.07  --
+6   GET   cdn.sstatic.net    /img/share-sprite-new.svg?v=78be252218f3  200 OK  0        34771    0.93  --
+1   GET   stackoverflow.com  /                                         200 OK  0        244280   0.43  --
+pappy> cls
+Saved contexts:
+_
+  host ct sstatic
+
+clean
+  path nctr "(\.js$|\.css$)"
+  path nctr "(\.png$|\.jpg$|\.gif$)"
+
+pappy> lc _
+Set the context to:
+  host ct sstatic
+pappy> fls
+host ct sstatic
+pappy> dc clean
+pappy> cls
+Saved contexts:
+_
+  path nctr "(\.js$|\.css$)"
+  path nctr "(\.png$|\.jpg$|\.gif$)"
+
+```
+
 Filter Strings
 --------------
 Filter strings define a condition that a request/response pair must pass to be part of the context. Most filter strings have the following format:
@@ -497,6 +580,7 @@ A few filters don't conform to the field, comparer, value format. You can still
 | before <reqid> | before, bf, b4 | Filters out any request that is not before the given request. Filters out any request without a time. |
 | after <reqid> | after, af | Filters out any request that is not before the given request. Filters out any request without a time. |
 | inv <filter string> | inf | Inverts a filter string. Anything that matches the filter string will not pass the filter. |
+| ws | websocket, ws | Filters out any request that is not part of a websocket connection. |
 
 Examples:
 
@@ -935,6 +1019,7 @@ Wrote script to int_headers.py
 ```
 
 Command information:
+
 | Command | Aliases | Description |
 |:--------|:--------|:------------|
 | `gtma <name> <template name> [template arguments]` | `generate_template_macro`, `gtma` | Generate a macro using a template. |
@@ -973,6 +1058,7 @@ There are a few simple parameters you can pass to the command to modify requests
 | `-m` | Store requests in memory instead of saving to the data file. |
 | `-u` | Only submit one request per endpoint. Will count requests with the same path but different url params as *different* endpoints. |
 | `-p` | Only submit one request per endpoint. Will count requests with the same path but different url params as *the same* endpoints. |
+| `-o <id>` | Copy the cookies used in another request |
 
 Examples:
 ```
@@ -1012,6 +1098,90 @@ Viewing Responses In Browser
 ----------------------------
 You can view responses in your browser by visiting `http://pappy/rsp/<rspid>` (NOT pappy.com) in your browser while connected to the proxy. For example, if you want to view the response to request 123, you can visit `http://pappy/rsp/123` to view the response. Pappy will return a response with the same body as the original response and will not make a request to the server. The response will not have the same headers as the original response (aside from the Content-Type header). In addition, Pappy doesn't modify any URLs in the page which means your browser will still fetch external resources like images, JavaScript etc from external servers.
 
+Websockets
+----------
+While information on websockets is scattered throughout the readme, this section will collect it all into one place. Websockets can be intercepted/modified, viewed, etc just like regular requests and responses.
+
+### Viewing a WebSocket Session
+
+Websocket sessions are referred to by the request that was used to initiate their handshake. In the following example, we look at all our websocket connections to an echo websocket server. In both connections, we send "Hello" from the browser. In the second connection, we sent "Hello" twice and used the interceptor to change the second "Hello" message to say "HelloFool" instead.
+
+```
+pappy> f ws
+pappy> ls
+ID  Verb  Host            Path               S-Code            Req Len  Rsp Len  Time  Mngl
+6   GET   localhost:9000  /?compressed=true  101 Switching...  0        0        0.34  --
+1   GET   localhost:9000  /?compressed=true  101 Switching...  0        0        0.32  --
+pappy> vfq 1
+Websocket session handshake
+GET /?compressed=true HTTP/1.1
+Host: localhost:9000
+User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.10; rv:49.0) Gecko/20100101 Firefox/49.0
+Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
+Accept-Language: en-US,en;q=0.5
+Accept-Encoding: gzip, deflate
+Sec-WebSocket-Version: 13
+Origin: null
+Sec-WebSocket-Extensions: permessage-deflate
+Sec-WebSocket-Key: 8rdZsJpDn7FAbdDE6IkHnw==
+Connection: keep-alive, Upgrade
+Pragma: no-cache
+Cache-Control: no-cache
+Upgrade: websocket
+
+Websocket session
+> Outgoing, binary = True
+Hello
+< Incoming, binary = True
+Hello
+
+pappy> vfq 6
+Websocket session handshake
+GET /?compressed=true HTTP/1.1
+Host: localhost:9000
+User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.10; rv:49.0) Gecko/20100101 Firefox/49.0
+Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
+Accept-Language: en-US,en;q=0.5
+Accept-Encoding: gzip, deflate
+Sec-WebSocket-Version: 13
+Origin: http://localhost:8090
+Sec-WebSocket-Extensions: permessage-deflate
+Sec-WebSocket-Key: 0oPJkDuwP5rrBYyCM7Hh0A==
+Connection: keep-alive, Upgrade
+Pragma: no-cache
+Cache-Control: no-cache
+Upgrade: websocket
+
+Websocket session
+> Outgoing, binary = True
+Hello
+< Incoming, binary = True
+Hello
+> Outgoing, mangled, binary = True
+HelloFool
+---------- ^^ UNMANGLED ^^ ----------
+> Outgoing, binary = True
+Hello
+-------------------------------------
+< Incoming, binary = True
+HelloFool
+
+pappy>
+```
+
+### Intercepting WebSocket Messages
+
+You can intercept websocket messages by running `ic` with a `ws` argument:
+
+```
+pappy> ic ws
+```
+
+### Intercepting Macros
+
+You can automatically mangle websocket messages similarly to requests and responses. Just define a `mangle_ws` function or an `async_mangle_ws` (see the [Intercepting Macros](#intercepting-macros) section for more details).
+
+
 Plugins
 -------
 Note that this section is a very quick overview of plugins. For a full description of how to write them, please see [the official docs](https://roglew.github.io/pappy-proxy/pappyplugins.html).
@@ -1225,7 +1395,7 @@ pappy> !pwd
 /tmp/exampleproj/crypt
 
 # Switch to another terminal window
-/templates/ $ echo "Hello World" >  /tmp/exampleproj/crypt/hello.txt
+$ echo "Hello World" >  /tmp/exampleproj/crypt/hello.txt
 
 # Back to Pappy
 pappy> !cat hello.txt
@@ -1248,6 +1418,7 @@ pappy>
 ```
 
 Example of recovering after crash:
+
 ```
 $ ls
 crypt           project.archive
@@ -1284,6 +1455,12 @@ Changelog
 ---------
 The boring part of the readme
 
+* 0.2.13
+    * Refactor proxy core
+    * WEBSOCKETS
+    * Saved contexts
+    * New features in `submit` command
+    * Fixed bugs, added bugs
 * 0.2.12
     * Add error handling for if creating a connection fails
     * Minor bugfixes
diff --git a/pappyproxy/comm.py b/pappyproxy/comm.py
index e8f4141..9ac3028 100644
--- a/pappyproxy/comm.py
+++ b/pappyproxy/comm.py
@@ -54,7 +54,7 @@ class CommServer(LineReceiver):
     def action_error_handler(self, error, result):
         if debug:
             print error.getTraceback()
-        return_data = {'success': False, 'message': str(error.getErrorMessage())}
+        return_data = {'success': False, 'message': str(error.getTraceback())}
         result.update(result)
         error.trap(Exception)
         self.sendLine(json.dumps(return_data))
@@ -85,7 +85,7 @@ class CommServer(LineReceiver):
             raise PappyException("Request with given ID does not exist, cannot fetch associated response.")
 
         if req.response:
-            rsp = yield Response.load_response(req.response.rspid)
+            rsp = req.response
             dat = json.loads(rsp.to_json())
         else:
             dat = {}
@@ -100,9 +100,7 @@ class CommServer(LineReceiver):
         req.host = data['host'].encode('utf-8')
         req.port = data['port']
         req.is_ssl = data['is_ssl']
-        yield Request.submit_request(req,
-                                     save_request=True,
-                                     intercepting_macros=active_intercepting_macros())
+        yield req.async_submit(mangle=True)
         if 'tags' in data:
             req.tags = set(data['tags'])
         yield req.async_deep_save()
diff --git a/pappyproxy/config.py b/pappyproxy/config.py
index 6619c30..f0a2bb6 100644
--- a/pappyproxy/config.py
+++ b/pappyproxy/config.py
@@ -48,10 +48,10 @@ class PappyConfig(object):
     
     .. data:: listeners
     
-    The list of active listeners. It is a list of tuples of the format (port, interface)
+    The list of active listeners. It is a list of dictionaries of the form `{"port": 8000, "interface": "127.0.0.1"}`
     Not modifiable after startup. Configured in the ``config.json`` file for the project.
     
-    :Default: ``[(8000, '127.0.0.1')]``
+    :Default: ``[]``
     
     .. data:: socks_proxy
     
@@ -149,7 +149,7 @@ class PappyConfig(object):
         self.debug_to_file = False
         self.debug_verbosity = 0
 
-        self.listeners = [(8000, '127.0.0.1')]
+        self.listeners = []
         self.socks_proxy = None
         self.http_proxy = None
 
diff --git a/pappyproxy/context.py b/pappyproxy/context.py
index c26eaf2..7214fb4 100644
--- a/pappyproxy/context.py
+++ b/pappyproxy/context.py
@@ -1,8 +1,9 @@
 import crochet
 import re
 import shlex
+import json
 
-from .http import Request, RepeatableDict
+from .http import Request, Response, RepeatableDict
 from twisted.internet import defer
 from util import PappyException
 
@@ -53,6 +54,15 @@ class Context(object):
         self.active_filters.append(filt)
         self.cache_reset()
 
+    @defer.inlineCallbacks
+    def add_filter_string(self, filtstr):
+        """
+        Add a filter to the context by filter string
+        """
+        f = Filter(filtstr)
+        yield f.generate()
+        self.add_filter(f)
+
     def filter_up(self):
         """
         Removes the last filter that was applied to the context.
@@ -452,6 +462,15 @@ def gen_filter_by_inverse(args):
     def f(req):
         return not filt(req)
     defer.returnValue(f)
+    
+def gen_filter_by_websocket(args):
+    def f(req):
+        if not req.response:
+            return False
+        if Response.is_ws_upgrade(req.response):
+            return True
+        return False
+    return f
 
 @defer.inlineCallbacks
 def filter_reqs(reqids, filters):
@@ -568,6 +587,64 @@ def async_set_tag(tag, reqs):
         Request.cache.add(req)
     reset_context_caches()
 
+@defer.inlineCallbacks
+def save_context(name, filter_strings, dbpool):
+    """
+    Saves the filter strings to the datafile using their name
+    """
+    rows = yield dbpool.runQuery(
+        """
+        SELECT id FROM saved_contexts WHERE context_name=?;
+        """, (name,)
+    )
+    list_str = json.dumps(filter_strings)
+    if len(rows) > 0:
+        yield dbpool.runQuery(
+            """
+            UPDATE saved_contexts SET filter_strings=?
+            WHERE context_name=?;
+            """, (list_str, name)
+        )
+    else:
+        yield dbpool.runQuery(
+            """
+            INSERT INTO saved_contexts (context_name, filter_strings)
+            VALUES (?,?);
+            """, (name, list_str)
+        )
+        
+@defer.inlineCallbacks
+def delete_saved_context(name, dbpool):
+    yield dbpool.runQuery(
+        """
+        DELETE FROM saved_contexts WHERE context_name=?;
+        """, (name,)
+    )
+    
+@defer.inlineCallbacks
+def get_saved_context(name, dbpool):
+    rows = yield dbpool.runQuery(
+        """
+        SELECT filter_strings FROM saved_contexts WHERE context_name=?;
+        """, (name,)
+    )
+    if len(rows) == 0:
+        raise PappyException("Saved context with name %s does not exist" % name)
+    filter_strs = json.loads(rows[0][0])
+    defer.returnValue(filter_strs)
+
+@defer.inlineCallbacks
+def get_all_saved_contexts(dbpool):
+    rows = yield dbpool.runQuery(
+        """
+        SELECT context_name, filter_strings FROM saved_contexts;
+        """,
+    )
+    all_strs = {}
+    for row in rows:
+        all_strs[row[0]] = json.loads(row[1])
+    defer.returnValue(all_strs)
+
 @crochet.wait_for(timeout=180.0)
 @defer.inlineCallbacks
 def set_tag(tag, reqs):
@@ -660,6 +737,9 @@ class Filter(object):
         
         "saved": gen_filter_by_saved,
         "svd": gen_filter_by_saved,
+
+        "websocket": gen_filter_by_websocket,
+        "ws": gen_filter_by_websocket,
     }
 
     _async_filter_functions = {
diff --git a/pappyproxy/http.py b/pappyproxy/http.py
index d5be632..11bb9a2 100644
--- a/pappyproxy/http.py
+++ b/pappyproxy/http.py
@@ -11,13 +11,18 @@ import time
 import urlparse
 import zlib
 import weakref
+import Queue
 
-from .util import PappyException, printable_data
+from .util import PappyException, printable_data, short_data, PappyStringTransport, sha1, print_traceback
 from .requestcache import RequestCache
 from .colors import Colors, host_color, path_formatter
+from .proxy import ProtocolProxy, make_proxied_connection, get_http_proxy_addr, start_maybe_tls
 from pygments.formatters import TerminalFormatter
 from pygments.lexers import get_lexer_for_mimetype, HttpLexer
 from twisted.internet import defer
+from autobahn.twisted.websocket import WebSocketServerFactory, WebSocketClientFactory, WebSocketServerProtocol, WebSocketClientProtocol
+from autobahn.websocket.protocol import WebSocketProtocol
+from autobahn.websocket.compress import PERMESSAGE_COMPRESSION_EXTENSION
 
 ENCODE_NONE = 0
 ENCODE_DEFLATE = 1
@@ -28,6 +33,7 @@ PATH_ABSOLUTE = 1
 PATH_HOST = 2
 
 dbpool = None
+web_server = None
 
 def init(pool):
     """
@@ -36,9 +42,13 @@ def init(pool):
     :param pool: The ConnectionPool to use to store the request/response objects
     :type pool: SQLite ConnectionPool
     """
+    from .site import PappyWebServer
+
     global dbpool
+    global web_server
     if dbpool is None:
         dbpool = pool
+    web_server = PappyWebServer()
     assert(dbpool)
 
 def destruct():
@@ -131,25 +141,54 @@ def request_by_id(reqid):
     defer.returnValue(req)
     
 @defer.inlineCallbacks
-def async_submit_requests(reqs, mangle=False, save=False):
+def async_submit_requests(reqs, mangle=False, save=False, save_in_mem=False, unique_paths=False,
+                          unique_path_and_args=False, use_cookie_jar=False, tag=None):
     """
     async_submit_requests(reqs, mangle=False)
     :param mangle: Whether to pass the requests through intercepting macros
     :type mangle: Bool
     :rtype: DeferredList
 
-    Submits a list of requests at the same time asynchronously.
+    Copies and submits a list of requests at the same time asynchronously.
     Responses/unmangled versions will be attached to the request objects in the list.
     Prints progress to stdout.
+    Returns list of submitted requests
     """
-    print 'Submitting %d request(s)' % len(reqs)
+    import sys
+    from pappyproxy.plugin import add_to_history
+
+    if unique_paths and unique_path_and_args:
+        raise PappyException("Cannot use both unique_paths and unique_paths_and_argts")
+    if save and save_in_mem:
+        raise PappyException("Cannot use both save and save_in_mem")
+
+    to_submit = [r.copy() for r in reqs]
+
+    if unique_paths or unique_path_and_args:
+        endpoints = set()
+        new_reqs = []
+        for r in reqs:
+            if unique_path_and_args:
+                s = r.url
+            else:
+                s = r.path
+
+            if not s in endpoints:
+                new_reqs.append(r)
+                endpoints.add(s)
+        to_submit = new_reqs
+
+    print 'Submitting %d request(s)' % len(to_submit)
+    sys.stdout.flush()
 
     dones = 0
     errors = 0
     list_deferred = defer.Deferred()
 
     deferreds = []
-    for r in reqs:
+    for r in to_submit:
+        if tag is not None:
+            r.tags.add(tag)
         d = r.async_submit(mangle=mangle)
         deferreds.append(d)
 
@@ -165,17 +204,21 @@ def async_submit_requests(reqs, mangle=False, save=False):
 
         finished = dones+errors
         
-        if finished % 30 == 0 or finished == len(reqs):
+        if finished % 30 == 0 or finished == len(to_submit):
             if errors > 0:
-                print '{0}/{1} complete with {3} errors ({2:.2f}%)'.format(finished, len(reqs), (float(finished)/len(reqs))*100, errors)
+                print '{0}/{1} complete with {3} errors ({2:.2f}%)'.format(finished, len(to_submit), (float(finished)/len(to_submit))*100, errors)
             else:
-                print '{0}/{1} complete ({2:.2f}%)'.format(finished, len(reqs), (float(finished)/len(reqs))*100)
-        if finished == len(reqs):
+                print '{0}/{1} complete ({2:.2f}%)'.format(finished, len(to_submit), (float(finished)/len(to_submit))*100)
+        sys.stdout.flush()
+        if finished == len(to_submit):
             list_deferred.callback(None)
 
     if save:
-        for r in reqs:
+        for r in to_submit:
             yield r.async_deep_save()
+    elif save_in_mem:
+        for r in to_submit:
+            add_to_history(r)
 
 @crochet.wait_for(timeout=180.0)
 @defer.inlineCallbacks
@@ -183,6 +226,21 @@ def submit_requests(*args, **kwargs):
     ret = yield async_submit_requests(*args, **kwargs)
     defer.returnValue(ret)
 
+def apply_http_proxy_creds(req):
+    from pappyproxy import pappy
+
+    if not pappy.session.config.http_proxy:
+        return
+    if 'username' in pappy.session.config.http_proxy and \
+       'password' in pappy.session.config.http_proxy:
+        req.proxy_creds = (pappy.session.config.http_proxy['username'],
+                           pappy.session.config.http_proxy['password'])
+
+@defer.inlineCallbacks
+def handle_webserver_request(req):
+    global web_server
+    yield web_server.handle_request(req)
+
 ##########
 ## Classes
 
@@ -231,7 +289,7 @@ class RepeatableDict:
         self.set_val(key, val)
 
     def __delitem__(self, key):
-        self._keys.remove(key)
+        self._remove_key(key)
         self._pairs = [p for p in self._pairs if self._ef_key(p[0]) != self._ef_key(key)]
         self._mod_callback()
 
@@ -366,19 +424,23 @@ class LengthData:
         self.complete = False
         self.length = length or 0
 
-        if self.length == 0:
+        if self.length == 0 or self.length == -1:
             self.complete = True
 
     def add_data(self, data):
-        if self.complete:
+        if self.complete and self.length != -1:
             raise PappyException("Data already complete!")
         remaining_length = self.length-len(self.body)
-        if len(data) >= remaining_length:
-            self.body += data[:remaining_length]
-            assert(len(self.body) == self.length)
-            self.complete = True
-        else:
+        if self.length == -1:
             self.body += data
+            complete = True
+        else:
+            if len(data) >= remaining_length:
+                self.body += data[:remaining_length]
+                assert(len(self.body) == self.length)
+                self.complete = True
+            else:
+                self.body += data
 
 class ChunkedData:
 
@@ -570,6 +632,464 @@ class ResponseCookie(object):
                 self._parse_cookie_av(cookie_av)
         else:
             self.key, self.val = set_cookie_string.split('=',1)
+            
+class WebSocketMessage(object):
+    """
+    A class representing a websocket message
+    """
+
+    DIRECTION_OUTGOING = 0
+    DIRECTION_INCOMING = 1
+
+    TYPE_MESSAGE = 0
+
+    def __init__(self, direction=None, contents=None, message_type=None, time_sent=None, is_binary=None):
+        self.direction = None
+        self.contents = None
+        self.message_type = WebSocketMessage.TYPE_MESSAGE
+        self.time_sent = None
+        self.unmangled = None
+        self.parent_request = None
+        self.is_unmangled_version = False
+        self.is_binary = False
+        self.msgid = '--'
+
+    def __eq__(self, other):
+        if self.contents != other.contents:
+            return False
+        if self.is_binary != other.is_binary:
+            return False
+        return True
+
+    def __copy__(self):
+        new_msg = WebSocketMessage()
+        new_msg.direction = self.direction
+        new_msg.contents = self.contents
+        new_msg.message_type = self.message_type
+        new_msg.is_binary = self.is_binary
+        return new_msg
+
+    def copy(self):
+        return self.__copy__()
+
+    def duplicate(self):
+        m = self.copy()
+        m.msgid = self.msgid
+        m.time_sent = self.time_sent
+        if self.unmangled:
+            m.unmangled = self.unmangled.duplicate()
+        return m
+
+    @defer.inlineCallbacks
+    def async_save(self, cust_dbpool=None):
+        from .pappy import main_context
+
+        global dbpool
+        if cust_dbpool:
+            use_dbpool = cust_dbpool
+        else:
+            use_dbpool = dbpool
+
+        assert(use_dbpool)
+        if not self.msgid:
+            self.msgid = '--'
+        try:
+            # Check for intyness
+            _ = int(self.msgid)
+
+            # If we have msgid, we're updating
+            yield use_dbpool.runInteraction(self._update)
+            assert(self.msgid is not None)
+        except (ValueError, TypeError):
+            # Either no id or in-memory
+            yield use_dbpool.runInteraction(self._insert)
+            assert(self.msgid is not None)
+        main_context.cache_reset()
+
+    @defer.inlineCallbacks
+    def async_deep_save(self):
+        if self.unmangled:
+            yield self.unmangled.async_deep_save()
+        yield self.async_save()
+
+    def _update(self, txn):
+        setnames = ['is_binary=?', 'contents=?']
+        queryargs = [self.is_binary, self.contents]
+
+        # Direction
+        if self.direction == 'OUTGOING':
+            setnames.append('direction=?')
+            queryargs.append(0)
+        elif self.direction == 'INCOMING':
+            setnames.append('direction=?')
+            queryargs.append(1)
+        else:
+            setnames.append('direction=?')
+            queryargs.append(-1)
+
+        # Unmangled
+        if self.unmangled:
+            setnames.append('unmangled_id=?')
+            assert(self.unmangled.msgid is not None) # should be saved first
+            queryargs.append(self.unmangled.msgid)
+
+        # Message time
+        if self.time_sent:
+            setnames.append('time_sent=?')
+            queryargs.append((self.time_sent-datetime.datetime(1970,1,1)).total_seconds())
+
+        # Parent request
+        if self.parent_request:
+            assert(self.parent_request.reqid)
+            setnames.append('parent_request=?')
+            queryargs.append(self.parent_request.reqid)
+
+        queryargs.append(self.msgid)
+        txn.execute(
+            """
+            UPDATE websocket_messages SET %s WHERE id=?;
+            """ % ','.join(setnames),
+            tuple(queryargs)
+        )
+
+    def _insert(self, txn):
+        colnames = ['is_binary', 'contents']
+        colvals = [self.is_binary, self.contents]
+        
+        # Direction
+        if self.direction == 'OUTGOING':
+            colnames.append('direction')
+            colvals.append(0)
+        elif self.direction == 'INCOMING':
+            colnames.append('direction')
+            colvals.append(1)
+        else:
+            colnames.append('direction')
+            colvals.append(-1)
+
+        # Unmangled
+        if self.unmangled:
+            colnames.append('unmangled_id')
+            assert(self.unmangled.msgid is not None) # should be saved first
+            colvals.append(self.unmangled.msgid)
+
+        # Message time
+        if self.time_sent:
+            colnames.append('time_sent')
+            colvals.append((self.time_sent-datetime.datetime(1970,1,1)).total_seconds())
+
+        # Parent request
+        if self.parent_request:
+            assert(self.parent_request.reqid)
+            colnames.append('parent_request')
+            colvals.append(self.parent_request.reqid)
+        txn.execute(
+            """
+            INSERT INTO websocket_messages (%s) VALUES (%s);
+            """ % (','.join(colnames), ','.join(['?']*len(colvals))),
+            tuple(colvals)
+        )
+        self.msgid = str(txn.lastrowid)
+        
+class WebSocketProxy(object):
+
+    def __init__(self, server_transport, client_transport, client_handshake, server_handshake, parent_proxy, log_id=None):
+        self.message_callback = None
+        self.close_callback = None
+        self.log_id = log_id
+        self.intercepting_macros = None
+        self.parent_http_proxy = parent_proxy
+
+        # The raw http messages from the handshake
+        self.client_handshake = client_handshake
+        self.server_handshake = server_handshake
+
+        self.server_factory = WebSocketServerFactory()
+        self.server_factory.protocol = WebSocketServerProtocol
+        self.server_transport = server_transport
+
+        self.client_factory = WebSocketClientFactory()
+        self.client_factory.protocol = WebSocketClientProtocol
+        self.client_transport = client_transport
+
+        self._fake_handshake()
+
+    def log(self, message, symbol='*', verbosity_level=3):
+        from pappyproxy.proxy import log
+
+        if self.log_id:
+            log(message, id=log_id, symbol=symbol, verbosity_level=verbosity_level)
+        else:
+            log(message, symbol=symbol, verbosity_level=verbosity_level)
+
+    def _build_server_protocol(self):
+        self.server_protocol = self.server_factory.buildProtocol(None)
+        self.server_protocol.makeConnection(self.server_transport)
+        self._patch_server_protocol()
+
+    def _build_client_protocol(self):
+        """
+        Builds the client protocol then returns the bytes written to the
+        transport after creation
+        """
+        self.client_protocol = self.client_factory.buildProtocol(None)
+        tr = PappyStringTransport()
+        self.client_protocol.makeConnection(tr)
+        tval = tr.pop_value()
+        self.client_protocol.transport = self.client_transport
+        self._patch_client_protocol()
+        return tval
+
+    def _patch_server_protocol(self):
+        self.log("Patching server protocol")
+        self._add_hook(self.server_protocol, 'onMessage', '_on_server_message')
+
+    def _patch_client_protocol(self):
+        self.log("Patching client protocol")
+        self._add_hook(self.client_protocol, 'onMessage', '_on_client_message')
+
+    def _add_hook(self, c, their_method, my_method):
+        """
+        Make it so that c.their_method(*args, **kwargs) calls self.my_method(*args, **kwargs)
+        before calling their method
+        """
+        old = getattr(c, their_method)
+        def patched(*args, **kwargs):
+            getattr(self, my_method)(*args, **kwargs)
+            old(*args, **kwargs)
+        setattr(c, their_method, patched)
+
+    @staticmethod
+    def _gen_sec_websocket_accept(token):
+        MAGIC_STRING = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"
+        concatenated = token + MAGIC_STRING
+        hashed = sha1(concatenated)
+        reencoded = base64.b64encode(hashed)
+        return reencoded
+
+    def _parse_extension_header(self, hd):
+        """
+        Parses the extension header and returns a list of offers
+        """
+        offers = []
+        extensions = self.server_protocol._parseExtensionsHeader(hd)
+        for (extension, params) in extensions:
+            if extension in PERMESSAGE_COMPRESSION_EXTENSION:
+
+                PMCE = PERMESSAGE_COMPRESSION_EXTENSION[extension]
+
+                try:
+                    offer = PMCE['Offer'].parse(params)
+                    offers.append(offer)
+                except Exception as e:
+                    raise PappyException(str(e))
+            else:
+                self.log("Bad extension: %s" % extension)
+        return offers
+
+    def _set_up_ws_client(self, ws_server_factory, ws_client_factory, hs_req, hs_rsp):
+        """
+        Sets up a WebSocketClientProtocolFactory from a WebSocketServerProtocolFactory
+        """
+        self.log("Setting up websocket client")
+        client_settings = {}
+
+        # Common attributes
+        skip_attrs = ('logFrames','trackTimings','logOctets')
+        for attr in WebSocketProtocol.CONFIG_ATTRS_COMMON:
+            if attr not in skip_attrs:
+                client_settings[attr] = getattr(ws_server_factory, attr)
+
+        def accept(response):
+            from autobahn.websocket.compress import PerMessageDeflateResponse, \
+                   PerMessageDeflateResponseAccept, \
+                   PerMessageBzip2Response, \
+                   PerMessageBzip2ResponseAccept, \
+                   PerMessageSnappyResponse, \
+                   PerMessageSnappyResponseAccept
+            if isinstance(response, PerMessageDeflateResponse):
+                return PerMessageDeflateResponseAccept(response)
+
+            elif isinstance(response, PerMessageBzip2Response):
+                return PerMessageBzip2ResponseAccept(response)
+
+            elif isinstance(response, PerMessageSnappyResponse):
+                return PerMessageSnappyResponseAccept(response)
+
+        # Client specific attributes
+        client_settings['version'] = int(hs_req.headers['Sec-WebSocket-Version'])
+        client_settings['acceptMaskedServerFrames'] = True
+        client_settings['maskClientFrames'] = True
+        #client_settings['serverConnectionDropTimeout'] = None
+
+        offers = self._parse_extension_header(hs_req.headers['Sec-WebSocket-Extensions'])
+        client_settings['perMessageCompressionOffers'] = offers
+        client_settings['perMessageCompressionAccept'] = accept
+
+        # debug
+        client_settings['openHandshakeTimeout'] = 8
+
+        self.log("Setting client options: %s" % client_settings)
+        ws_client_factory.setProtocolOptions(**client_settings)
+
+    def _fake_handshake(self):
+        self.log("Performing fake handshake")
+
+        # Set up our server listener
+        self._build_server_protocol()
+        old_server_transport = self.server_protocol.transport
+        self.server_protocol.transport = PappyStringTransport()
+        self.log("Sending fake handshake response to server protocol:")
+        self.log("pf> %s" % printable_data(self.server_handshake.full_message))
+        self.server_protocol.dataReceived(self.server_handshake.full_message)
+        tval = self.server_protocol.transport.pop_value()
+        self.log("<fp %s" % printable_data(tval))
+        assert tval
+        self.server_protocol.transport = old_server_transport
+
+        # Set up our client
+        self._set_up_ws_client(self.server_factory,
+                               self.client_factory,
+                               self.server_handshake,
+                               self.client_handshake)
+        # Perform rest of client handshake
+        tval = self._build_client_protocol()
+        self.log("Getting handshake request start from client protocol")
+        self.log("<fp %s" % printable_data(tval))
+        # Revert transport handshake so that any data sent after our response is
+        # sent to the real transport
+        self.log("Reverting client transport")
+        self.log("Sending fake handshake response to client protocol:")
+        handshake_req = Request(tval)
+        handshake_rsp = self.client_handshake.copy()
+        sec_ws_key = handshake_req.headers['Sec-WebSocket-Key']
+        self.log("Generating Sec-WebSocket-Accept for %s" % sec_ws_key)
+        sec_ws_accept = WebSocketProxy._gen_sec_websocket_accept(sec_ws_key)
+        self.log("Sec-WebSocket-Accept = %s" % sec_ws_accept)
+        handshake_rsp.headers['Sec-WebSocket-Accept'] = sec_ws_accept
+        self.log("pf> %s" % printable_data(handshake_rsp.full_message))
+        self.client_protocol.dataReceived(handshake_rsp.full_message) # Tell it whatever the remote server told us
+        self.log("Compressed after handshake? %s" % self.client_protocol._perMessageCompress)
+
+        self.log("Fake handshake complete")
+
+    def _on_server_message(self, payload, is_binary):
+        """
+        Wrapper to convert arguments to onMessage into an object and call on_server_message
+        """
+        # Turn into object
+        m = WebSocketMessage()
+        m.direction = 'OUTGOING'
+        m.contents = payload
+        m.time_sent = datetime.datetime.utcnow()
+        m.is_binary = is_binary
+        self.log("rp< (websocket, binary=%s) %s" % (m.is_binary, m.contents))
+
+        self.on_server_message(m)
+
+    def _on_client_message(self, payload, is_binary):
+        """
+        Wrapper function for when the client protocol gets a data frame
+        """
+        # Turn into object
+        m = WebSocketMessage()
+        m.direction = 'INCOMING'
+        m.contents = payload
+        m.time_sent = datetime.datetime.utcnow()
+        m.is_binary = is_binary
+        self.log("cp> (websocket, binary=%s) %s" % (m.is_binary, m.contents))
+
+        self.on_client_message(m)
+
+    @defer.inlineCallbacks
+    def mangle_message(self, message):
+        from pappyproxy import context, macros
+
+        # Mangle object
+        sendreq = self.server_handshake
+        custom_macros = self.parent_http_proxy.custom_macros
+        mangle_macros = self.parent_http_proxy.mangle_macros
+        client_protocol = self.parent_http_proxy.client_protocol
+        save_requests = self.parent_http_proxy.save_requests
+        dropped = False
+        sendmsg = message
+
+        if context.in_scope(sendreq) or custom_macros:
+            self.log("Passing ws message through macros")
+            if not custom_macros:
+                mangle_macros = client_protocol.factory.get_macro_list()
+
+            if save_requests:
+                yield sendreq.async_deep_save()
+
+            (mangmsg, mangled) = yield macros.mangle_websocket_message(message, sendreq, mangle_macros)
+            if mangmsg is None:
+                self.log("Message dropped")
+                dropped = True
+            elif mangled:
+                self.log("Message mangled")
+                sendmsg.time_sent = None
+                mangmsg.unmangled = sendmsg
+                sendmsg = mangmsg
+            else:
+                self.log("Message not modified")
+
+            mangmsg.time_sent = datetime.datetime.utcnow()
+            if not dropped:
+                sendreq.add_websocket_message(sendmsg)
+            if save_requests:
+                yield sendreq.async_deep_save()
+        else:
+            sendreq.add_websocket_message(sendmsg)
+            self.log("Request out of scope, passing ws message along unmangled")
+
+        # Send data frame through server object to the client
+        defer.returnValue((sendmsg, dropped))
+
+    @defer.inlineCallbacks
+    def on_server_message(self, message):
+        """
+        Wrapper function for when the server protocol gets a data frame
+        """
+        # Mangle object
+        sendmsg, dropped = yield self.mangle_message(message)
+
+        # Send data frame through client object to remote server
+        if not dropped:
+            self.send_server_message(sendmsg.contents, sendmsg.is_binary)
+
+    @defer.inlineCallbacks
+    def on_client_message(self, message):
+        """
+        Wrapper function for when the client protocol gets a data frame
+        """
+        sendmsg, dropped = yield self.mangle_message(message)
+
+        # Send data frame through server object to the client
+        if not dropped:
+            self.send_client_message(sendmsg.contents, sendmsg.is_binary)
+
+    def client_data_received(self, data):
+        # Called when data is received from the client
+        # Sends RAW DATA to server protocol. NOT frame data
+        self.server_protocol.dataReceived(data)
+
+    def server_data_received(self, data):
+        # Called when data is received from the server
+        # Sends RAW DATA to client protocol. NOT frame data
+        self.client_protocol.dataReceived(data)
+
+    def send_client_message(self, message_data, is_binary=False):
+        # Write a message to the client over the actual transport
+        self.server_protocol.sendMessage(message_data, is_binary)
+
+    def send_server_message(self, message_data, is_binary=False):
+        # Write a message to the remote server over the actual transport
+        self.client_protocol.sendMessage(message_data, is_binary)
+
+    def on_client_frame(self, frame_data, is_binary=False):
+        # Call callback and have callback return mangled frame data
+        self.server_protocol.sendFrame(frame_data, is_binary)
 
 class HTTPMessage(object):
     """
@@ -657,6 +1177,7 @@ class HTTPMessage(object):
         self._first_line = True
         self._data_obj = None
         self._end_after_headers = False
+        self._data_buffer = ''
 
     def _from_full_message(self, full_message, update_content_length=False, meta=None):
         # Set defaults for metadata
@@ -666,34 +1187,16 @@ class HTTPMessage(object):
         if full_message == '':
             return
 
-        lines = full_message.splitlines(True)
-        header_len = 0
-        for line in lines:
-            if line[-2] == '\r':
-                l = line[:-2]
-            else:
-                l = line[:-1]
-            self.add_line(l)
-            header_len += len(line)
-            if self.headers_complete:
-                break
-        remaining = full_message[header_len:]
-            
-        if not self.headers_complete:
-            self.add_line('')
+        self.add_data(full_message, enforce_content_length=(not update_content_length))
 
         if meta:
             self.set_metadata(meta)
 
-        # We keep track of encoding here since if it's encoded, after
-        # we call add_data it will update content-length automatically
-        # and we won't have to update the content-length manually
-        if not self.complete:
-            # We do add data since just setting the body will keep the
-            # object from decoding chunked/compressed messages
-            self.add_data(remaining)
-        if update_content_length and (not self._decoded):
-            self.body = remaining
+        if update_content_length:
+            # If we have no body and didn't have a content-length header in the first
+            # place, don't add one
+            if 'Content-Length' in self.headers or len(self.body) > 0:
+                self.headers['Content-Length'] = str(len(self.body))
         assert(self.complete)
 
     ###############################
@@ -722,7 +1225,7 @@ class HTTPMessage(object):
         Same thing as :func:`pappyproxy.http.HTTPMessage.headers_section` except
         that the headers are colorized for terminal printing.
         """
-        to_ret = printable_data(self.headers_section)
+        to_ret = printable_data(self.headers_section, colors=False)
         to_ret = pygments.highlight(to_ret, HttpLexer(), TerminalFormatter())
         return to_ret
 
@@ -755,7 +1258,9 @@ class HTTPMessage(object):
         Same thing as :func:`pappy.http.HTTPMessage.body` but the output is
         colorized for the terminal.
         """
-        to_ret = printable_data(self.body)
+        if self.body == '':
+            return ''
+        to_ret = printable_data(self.body, colors=False)
         if 'content-type' in self.headers:
             try:
                 lexer = get_lexer_for_mimetype(self.headers['content-type'].split(';')[0])
@@ -780,12 +1285,15 @@ class HTTPMessage(object):
         Same as :func:`pappyproxy.http.HTTPMessage.full_message` except the
         output is colorized
         """
-        return (self.headers_section_pretty + '\r\n' + self.body_pretty)
+        if self.body:
+            return (self.headers_section_pretty + '\r\n' + self.body_pretty)
+        else:
+            return self.headers_section_pretty
 
     ###############
     ## Data loading
 
-    def add_line(self, line):
+    def add_line(self, line, enforce_content_length=True):
         """
         Used for building a message from a Twisted protocol.
         Add a line (for status line and headers). Lines must be added in order
@@ -802,12 +1310,16 @@ class HTTPMessage(object):
         if not line:
             self.headers_complete = True
 
+            if not self._data_obj:
+                self._data_obj = LengthData(0)
+
             if self._end_after_headers:
                 self.complete = True
                 return
 
-            if not self._data_obj:
-                self._data_obj = LengthData(0)
+            if not enforce_content_length or 'content-length' not in self.headers:
+                if isinstance(self._data_obj, LengthData):
+                    self._data_obj = LengthData(-1)
             self.complete = self._data_obj.complete
             self.headers_end()
             return
@@ -825,7 +1337,7 @@ class HTTPMessage(object):
             if self.handle_header(key, val):
                 self.headers.append(key, val, do_callback=False)
 
-    def add_data(self, data):
+    def add_data(self, data, enforce_content_length=True):
         """
         Used for building a message from a Twisted protocol.
         Add data to the message. The data must conform to the content encoding
@@ -836,13 +1348,33 @@ class HTTPMessage(object):
         :param data: The data to add
         :type data: string
         """
-        assert(self._data_obj)
-        assert(not self._data_obj.complete)
-        assert not self.complete
-        self._data_obj.add_data(data)
-        if self._data_obj.complete:
-            self.complete = True
-            self.body_complete()
+        assert not self.complete or not enforce_content_length
+        self._data_buffer += data
+
+        def popline(s):
+            parts = s.split('\n', 1)
+            if len(parts) == 1:
+                return (s, '')
+            line, rest = (parts[0], ''.join(parts[1:]))
+            if line[-1] == '\r':
+                line = line[:-1]
+            return (line, rest)
+
+        # Add headers from the data buffer if headers aren't complete
+        if not self.headers_complete:
+            while '\n' in self._data_buffer and not self.headers_complete:
+                line, self._data_buffer = popline(self._data_buffer)
+                self.add_line(line, enforce_content_length=enforce_content_length)
+
+        # Add the data section if the headers are complete and we have stuff left in the buffer
+        if self.headers_complete:
+            if self._data_buffer:
+                to_add = self._data_buffer
+                self._data_buffer = ''
+                self._data_obj.add_data(to_add)
+            if self._data_obj.complete:
+                self.complete = True
+                self.body_complete()
 
     ###############
     ## Data parsing
@@ -1022,6 +1554,7 @@ class HTTPMessage(object):
         # self.update_from_headers()
         # self.update_from_body()
 
+
 class Request(HTTPMessage):
     """
     :ivar time_end: The datetime that the request ended.
@@ -1094,9 +1627,13 @@ class Request(HTTPMessage):
             self.path_type = path_type
         if explicit_port:
             self.explicit_port = explicit_port
+
+        self.is_websocket = False
+        self.websocket_messages = []
             
     def __copy__(self):
         if not self.complete:
+            import pdb; pdb.set_trace()
             raise PappyException("Cannot copy incomplete http messages")
         retreq = self.__class__(self.full_message)
         retreq.set_metadata(self.get_metadata())
@@ -1107,6 +1644,16 @@ class Request(HTTPMessage):
             retreq.response = self.response.copy()
         if self.unmangled:
             retreq.unmangled = self.unmangled.copy()
+        retreq.set_websocket_messages([m.duplicate() for m in self.websocket_messages])
+        return retreq
+
+    def duplicate(self):
+        retreq = self.copy()
+        retreq.reqid = self.reqid
+        if self.unmangled:
+            retreq.unmangled = self.unmangled.duplicate()
+        if self.response:
+            retreq.response = self.response.duplicate()
         return retreq
 
     def duplicate(self):
@@ -1285,7 +1832,7 @@ class Request(HTTPMessage):
         encoded = base64.b64encode(decoded)
         header = 'Basic %s' % encoded
         return header
-        
+
     def _url_helper(self, colored=False, always_have_path=False):
         retstr = ''
         if self.is_ssl:
@@ -1323,7 +1870,10 @@ class Request(HTTPMessage):
             retstr += '?'
             pairs = []
             for p in self.url_params.all_pairs():
-                pairs.append('='.join(p))
+                if p[1] is None:
+                    pairs.append(p)
+                else:
+                    pairs.append('='.join(p))
             retstr += '&'.join(pairs)
         if self.fragment:
             retstr += '#%s' % self.fragment
@@ -1539,6 +2089,9 @@ class Request(HTTPMessage):
                 assignments.append(asn)
             header_val = '; '.join(assignments)
             self.headers.update('Cookie', header_val, do_callback=False)
+        elif 'Cookie' in self.headers:
+            del self.headers['Cookie']
+
         if self.post_params:
             pairs = []
             for k, v in self.post_params.all_pairs():
@@ -1553,6 +2106,26 @@ class Request(HTTPMessage):
         for k, v in self.headers.all_pairs():
             self.handle_header(k, v)
 
+    def _sort_websocket_messages(self):
+        """
+        Sort websocket message list by their submission time
+        """
+        def sort_key(mes):
+            if not mes.time_sent:
+                return datetime.datetime(1970,1,1)
+            return mes.time_sent
+        self.websocket_messages = sorted(self.websocket_messages, key=sort_key)
+        
+    def add_websocket_message(self, mes):
+        # Right now just insert and sort. We'll do a better structure later
+        mes.parent_request = self
+        self.websocket_messages.append(mes)
+        self._sort_websocket_messages()
+
+    def set_websocket_messages(self, msgs):
+        self.websocket_messages = msgs
+        self._sort_websocket_messages()
+
     ###############
     ## Data parsing
             
@@ -1660,9 +2233,8 @@ class Request(HTTPMessage):
                 self.cookies.append(cookie_key, cookie_val, do_callback=False)
         elif key.lower() == 'host':
             self._process_host(val)
-        elif key.lower() == 'connection':
-            #stripped = True
-            pass
+        elif re.match('^proxy.*', key.lower()):
+            stripped = True
 
         return (not stripped)
     
@@ -1694,6 +2266,8 @@ class Request(HTTPMessage):
         :rtype: twisted.internet.defer.Deferred
         """
         from .pappy import main_context
+        if not self.complete:
+            raise PappyException('Cannot save incomplete messages')
 
         global dbpool
         if cust_dbpool:
@@ -1739,7 +2313,7 @@ class Request(HTTPMessage):
     def async_deep_save(self):
         """
         async_deep_save()
-        Saves self, unmangled, response, and unmangled response. Returns a deferred
+        Saves self, unmangled, response, unmangled response, and websocket messages. Returns a deferred
         which fires after everything has been saved.
 
         :rtype: twisted.internet.defer.Deferred
@@ -1751,6 +2325,8 @@ class Request(HTTPMessage):
             yield self.response.async_save()
         if self.unmangled:
             yield self.unmangled.async_save()
+        for m in self.websocket_messages:
+            yield m.async_deep_save()
         yield self.async_save()
 
     def _update_tags(self, txn):
@@ -1969,6 +2545,11 @@ class Request(HTTPMessage):
         else:
             return template.format(pre='')
         
+    @staticmethod
+    @defer.inlineCallbacks
+    def _load_request_ws_messages(req):
+        ws_messages = yield Request._async_load_ws_by_parent(req.reqid)
+        req.set_websocket_messages(ws_messages)
         
     @staticmethod
     @defer.inlineCallbacks
@@ -2020,6 +2601,7 @@ class Request(HTTPMessage):
         req.tags = set()
         for row in rows:
             req.tags.add(row[0])
+        yield Request._load_request_ws_messages(req)
         defer.returnValue(req)
 
     @staticmethod
@@ -2189,71 +2771,95 @@ class Request(HTTPMessage):
             cache_to_use.add(req)
         defer.returnValue(retreq(req))
 
+    @staticmethod
+    @defer.inlineCallbacks
+    def _async_load_ws(msgid, cust_dbpool=None):
+        global dbpool
+        if cust_dbpool:
+            use_dbpool = cust_dbpool
+        else:
+            use_dbpool = dbpool
+        assert(use_dbpool)
+        rows = yield use_dbpool.runQuery(
+            """
+            SELECT id,parent_request,unmangled_id,is_binary,direction,time_sent,contents
+            FROM websocket_messages
+            WHERE id=?;
+            """,
+            (int(msgid),)
+            )
+        if len(rows) == 0:
+            raise PappyException("No websocket message with id=%s" % msgid)
+        assert(len(rows) == 1)
+        row = rows[0]
+        m = WebSocketMessage()
+        m.msgid = row[0]
+        #if load_parent:
+        #    m.parent_request = yield Request.load_request(str(row[1]))
+        if row[2]:
+            m.unmangled = yield Request._async_load_ws(str(row[2]))
+        if row[3] >= 0:
+            m.is_binary = True
+        else:
+            m.is_binary = False
+        if row[4] == 0:
+            m.direction = 'OUTGOING'
+        else:
+            m.direction = 'INCOMING'
+        if row[5] is not None:
+            m.time_sent = datetime.datetime.utcfromtimestamp(row[5])
+        m.contents = row[6]
+        defer.returnValue(m)
+
+    @staticmethod
+    @defer.inlineCallbacks
+    def _async_load_ws_by_parent(reqid, cust_dbpool=None):
+        global dbpool
+        if cust_dbpool:
+            use_dbpool = cust_dbpool
+        else:
+            use_dbpool = dbpool
+        assert(use_dbpool)
+        rows = yield use_dbpool.runQuery(
+            """
+            SELECT id
+            FROM websocket_messages
+            WHERE parent_request=?;
+            """,
+            (int(reqid),)
+            )
+        messages = []
+        # Yes we could do it in one query but we'll deal with it if it causes
+        # performance issues
+        for row in rows:
+            m = yield Request._async_load_ws(row[0])
+            messages.append(m)
+        defer.returnValue(messages)
+
     ######################
     ## Submitting Requests
-        
+
     @staticmethod
     @defer.inlineCallbacks
-    def submit_request(request,
-                       save_request=False,
-                       intercepting_macros={},
-                       stream_transport=None,
-                       _factory_string_transport=False,
-                       _conn_info=None):
-        """
-        submit_request(request, save_request=False, intercepting_macros={}, stream_transport=None)
-
-        Submits the request then sets ``request.response``. Returns a deferred that
-        is called with the request that was submitted.
-
-        :param request: The request to submit
-        :type host: Request
-        :param save_request: Whether to save the request to history
-        :type save_request: Bool
-        :param intercepting_macros: Dictionary of intercepting macros to be applied to the request
-        :type intercepting_macros: Dict or collections.OrderedDict
-        :param stream_transport: Return transport to stream to. Set to None to not stream the response.
-        :type stream_transport: twisted.internet.interfaces.ITransport
-        """
-
-        from .proxy import ProxyClientFactory, get_next_connection_id, get_endpoint
-        from .pappy import session
-        from .tests.testutil import TLSStringTransport
-
-        # _factory__string_transport, _conn_classes are only for unit tests. Do not use.
-
-        factory = None
-        if stream_transport is None:
-            factory = ProxyClientFactory(request,
-                                        save_all=save_request,
-                                        stream_response=False,
-                                        return_transport=None)
-        else:
-            factory = ProxyClientFactory(request,
-                                        save_all=save_request,
-                                        stream_response=True,
-                                        return_transport=stream_transport)
-
-        # Set up stuff for unit test if needed
-        if _factory_string_transport:
-            factory._use_string_transport = True
-        if _conn_info is not None:
-            # Pass factory back to unit test
-            _conn_info['factory'] = factory
-            factory._conn_info = _conn_info
-
-        # Set up factory settings
-        factory.intercepting_macros = intercepting_macros
-        factory.connection_id = get_next_connection_id()
-        try:
-            yield factory.connect()
-            new_req = yield factory.data_defer
-            request.response = new_req.response
-        except Exception as e:
-            request.response = None
-            raise e
-        defer.returnValue(request)
+    def submit_raw_request(message, host, port, is_ssl, mangle=False, int_macros=[]):
+        """
+        Submits a request to the target host and returns a request object
+        """
+        from pappyproxy.plugin import active_intercepting_macros
 
+        use_int_macros = int_macros
+        if mangle:
+            use_int_macros = active_intercepting_macros()
+
+        proxy_protocol = HTTPProtocolProxy(addr=(host, port, is_ssl),
+                                           int_macros=use_int_macros,
+                                           save_requests=False)
+        d = proxy_protocol.get_next_response()
+        proxy_protocol.client_data_received(message)
+        retreq = yield d
+        proxy_protocol.close_connections()
+        defer.returnValue(retreq)
+        
     @defer.inlineCallbacks
     def async_submit(self, mangle=False):
         """
@@ -2269,18 +2875,17 @@ class Request(HTTPMessage):
         """
         from pappyproxy.plugin import active_intercepting_macros
         
-        if mangle:
-            int_macros = active_intercepting_macros()
-        else:
-            int_macros = None
-        yield Request.submit_request(self,
-                                     save_request=False,
-                                     intercepting_macros=int_macros,
-                                     stream_transport=None)
+        newreq = yield Request.submit_raw_request(self.full_message, self.host, self.port,
+                                                  self.is_ssl, mangle=mangle)
+        self.unmangled = newreq.unmangled
+        self.response = newreq.response
+        self.time_start = newreq.time_start
+        self.time_end = newreq.time_end
+        self.set_metadata(newreq.get_metadata())
 
     @crochet.wait_for(timeout=180.0)
     @defer.inlineCallbacks
-    def submit(self, mangle=False):
+    def submit(self, *args, **kwargs):
         """
         submit()
         Submits the request using its host, port, etc. and updates its response value
@@ -2291,7 +2896,7 @@ class Request(HTTPMessage):
         This is what you should use to submit your requests in macros.
         """
         try:
-            yield self.async_submit(mangle=mangle)
+            yield self.async_submit(*args, **kwargs)
         except Exception as e:
             print 'Submitting request to %s failed: %s' % (self.host, str(e))
 
@@ -2583,6 +3188,8 @@ class Response(HTTPMessage):
 
         :rtype: twisted.internet.defer.Deferred
         """
+        if not self.complete:
+            raise PappyException('Cannot save incomplete messages')
         global dbpool
         if cust_dbpool:
             use_dbpool = cust_dbpool
@@ -2651,6 +3258,20 @@ class Response(HTTPMessage):
                 )
         self.rspid = None
 
+    @staticmethod
+    def is_ws_upgrade(rsp):
+        if rsp.response_code != 101:
+            return False
+        if 'Upgrade' not in rsp.headers:
+            return False
+        if 'Connection' not in rsp.headers:
+            return False
+        if rsp.headers['Upgrade'].lower() != 'websocket':
+            return False
+        if rsp.headers['Connection'].lower() != 'upgrade':
+            return False
+        return True
+
     @staticmethod
     @defer.inlineCallbacks
     def load_response(respid, cust_dbpool=None, cust_cache=None):
@@ -2685,4 +3306,364 @@ class Response(HTTPMessage):
                                                               cust_cache=cust_cache)
             resp.unmangled = unmangled_response
         defer.returnValue(resp)
-            
+
+class HTTPProtocolProxy(ProtocolProxy):
+
+    CLIENT_STATE_CLOSED = 1
+    CLIENT_STATE_HTTP_READY = 2
+    CLINET_STATE_WEBSDOCKET_READY = 3
+    CLIENT_STATE_WEBSOCKET = 4
+
+    SERVER_STATE_HTTP_READY = 1
+    SERVER_STATE_PROCESSING_HTTP_REQUEST = 2
+    SERVER_STATE_HTTP_AWAITING_RESPONSE = 3
+    SERVER_STATE_HTTP_AWAITING_PROXY_CONNECT = 4
+    SERVER_STATE_WEBSOCKET = 5
+
+    BLANK_RESPONSE = ('HTTP/1.1 200 OK\r\n'
+                      'Connection: close\r\n'
+                      'Cache-control: no-cache\r\n'
+                      'Pragma: no-cache\r\n'
+                      'Cache-control: no-store\r\n'
+                      'Content-Length: 0\r\n'
+                      'X-Frame-Options: DENY\r\n\r\n')
+
+    def __init__(self, *args, **kwargs):
+        self.request_queue = Queue.Queue()
+        self.request = Request()
+        self.response = Response()
+        self.stream_responses = True
+        self.next_rsp_def = None
+        self.ws_proxy = None
+
+        if 'int_macros' in kwargs:
+            self.custom_macros = True
+            self.mangle_macros = kwargs['int_macros']
+        else:
+            self.custom_macros = False
+            self.mangle_macros = []
+
+        if 'save_requests' in kwargs:
+            self.save_requests = kwargs['save_requests']
+        else:
+            self.save_requests = True
+
+        if 'addr' in kwargs:
+            self.connect_addr = kwargs['addr']
+            self.force_addr = True
+        else:
+            self.connect_addr = None
+            self.force_addr = False
+
+        self.using_upstream_http_proxy = False
+        self.was_streaming_responses = self.stream_responses
+        self.upstream_http_connected = False
+
+        self.client_state = HTTPProtocolProxy.CLIENT_STATE_CLOSED
+        self.server_state = HTTPProtocolProxy.SERVER_STATE_HTTP_READY
+        
+        ProtocolProxy.__init__(self)
+
+    def _set_client_state(self, state):
+        # Updates the state and sets other metadata states
+        # (like is_websocket)
+        self.client_state = state
+        self.log("Changing client state to %s" % self.client_state)
+
+    def _set_server_state(self, state):
+        # Updates the state and sets other metadata states
+        # (like is_websocket)
+        self.server_state = state
+        self.log("Changing server state to %s" % self.server_state)
+
+    def get_next_response(self):
+        """
+        Returns a deferred that fires with the next completed
+        request/response pair
+        """
+        self.next_rsp_def = defer.Deferred()
+        return self.next_rsp_def
+
+    def set_connection(self, host, port, use_ssl, use_socks=False):
+        """
+        If not connected to the given host, port, use_ssl, disconnects
+        the current connection and connects to the given endpoint. Otherwise
+        does nothing
+        """
+        self.log("setting connection...")
+        if self.conn_host != host or \
+           self.conn_port != port or \
+           self.conn_is_ssl != use_ssl:
+            self.log("Closing connection to old server")
+            self.close_server_connection()
+        self.connect(host, port, use_ssl, use_socks=use_socks)
+
+    def server_connection_lost(self, reason):
+        self.log("Connection to server lost: %s" % str(reason))
+        self.log(str(reason.getTraceback()))
+        ProtocolProxy.server_connection_lost(self, reason)
+
+    def client_data_received(self, data):
+        self.log("cp> %s" % short_data(data))
+        if self.client_state != HTTPProtocolProxy.CLIENT_STATE_WEBSOCKET:
+            self.request.add_data(data)
+            if self.request.complete:
+                req = self.request
+                self.request = Request()
+                self.request_complete(req)
+        else:
+            self.ws_proxy.client_data_received(data)
+
+    def server_data_received(self, data):
+        self.log("rp< %s" % short_data(data))
+        if self.client_state != HTTPProtocolProxy.CLIENT_STATE_WEBSOCKET:
+            self.response.add_data(data)
+            if self.stream_responses:
+                self.send_client_data(data)
+            if self.response.complete:
+                rsp = self.response
+                self.response = Response()
+                self.response_complete(rsp)
+        else:
+            self.ws_proxy.server_data_received(data)
+
+    @defer.inlineCallbacks
+    def process_request(self, pop_request=True):
+        from pappyproxy import context, macros, pappy
+
+        if self.server_state != HTTPProtocolProxy.SERVER_STATE_HTTP_READY:
+            self.log("Not ready to process a new HTTP request")
+            return
+        self._set_server_state(HTTPProtocolProxy.SERVER_STATE_PROCESSING_HTTP_REQUEST)
+
+        if pop_request and self.request_queue.empty():
+            #defer.returnValue(None)
+            self.log("Request queue is empty, not processing request")
+            self._set_server_state(HTTPProtocolProxy.SERVER_STATE_HTTP_READY)
+            return
+
+        if pop_request:
+            self.waiting_req = self.request_queue.get()
+
+        if self.waiting_req.host == 'pappy':
+            self.log("Processing request to internal webserver")
+            yield handle_webserver_request(self.waiting_req)
+            self.send_response(self.waiting_req.response.full_message)
+            self._set_server_state(HTTPProtocolProxy.SERVER_STATE_HTTP_READY)
+            self.process_request()
+            return
+
+        self.mangle_macros = []
+        self.stream_responses = True
+
+        if self.waiting_req.verb.upper() == 'CONNECT':
+            self.send_response('HTTP/1.1 200 Connection established\r\n\r\n')
+            self.start_client_maybe_tls(cert_host=self.waiting_req.host)
+            self.connect_addr = (self.waiting_req.host, self.waiting_req.port, self.waiting_req.is_ssl)
+            #defer.returnValue(None)
+            self.log("Client TLS setup, ready for next request")
+            self._set_server_state(HTTPProtocolProxy.SERVER_STATE_HTTP_READY)
+            self.process_request()
+            return
+
+        ## Process/store the request
+        sendreq = self.waiting_req
+
+        upstream_http_addr = get_http_proxy_addr()
+        if self.connect_addr is not None:
+            sendreq.host = self.connect_addr[0]
+            sendreq.port = self.connect_addr[1]
+            sendreq.is_ssl = self.connect_addr[2]
+
+        if context.in_scope(sendreq) or self.custom_macros:
+            if not self.custom_macros:
+                self.mangle_macros = self.client_protocol.factory.get_macro_list()
+            sendreq.time_start = datetime.datetime.utcnow()
+
+            if self.mangle_macros:
+                self.stream_responses = False
+            else:
+                self.stream_responses = True
+
+            if self.stream_responses and not self.mangle_macros:
+                if self.save_requests:
+                    sendreq.async_deep_save()
+            else:
+                if self.save_requests:
+                    yield sendreq.async_deep_save()
+
+                (mangreq, mangled) = yield macros.mangle_request(sendreq, self.mangle_macros)
+                if mangreq is None:
+                    self.log("Request dropped. Closing connections.")
+                    sendreq.tags.add('dropped')
+                    sendreq.response = None
+                    self.dropped_request = True
+                    self._set_server_state(HTTPProtocolProxy.SERVER_STATE_HTTP_READY)
+                    self.send_response(self.BLANK_RESPONSE)
+                    defer.returnValue(None)
+                elif mangled:
+                    sendreq = mangreq
+
+                self.log("Request in scope, saving")
+                sendreq.time_start = datetime.datetime.utcnow()
+                assert sendreq.complete
+                if self.save_requests:
+                    yield sendreq.async_deep_save()
+                self.waiting_req = sendreq
+        else:
+            self.log("Request out of scope, passing along unmangled")
+
+        self.log("Making new connection to %s:%d is_ssl=%s" % (self.waiting_req.host, self.waiting_req.port, self.waiting_req.is_ssl))
+        if upstream_http_addr is not None:
+            self.log("Using upstream http proxy")
+            self.log(str(self.waiting_req))
+            self.set_connection(upstream_http_addr[0], upstream_http_addr[1], False, use_socks=True)
+            self.using_upstream_http_proxy = True
+        else:
+            self.log("Not using upstream http proxy")
+            self.set_connection(sendreq.host, sendreq.port, sendreq.is_ssl, use_socks=True)
+            self.using_upstream_http_proxy = False
+
+        if self.using_upstream_http_proxy and sendreq.is_ssl and not self.upstream_http_connected:
+            self.was_streaming_responses = self.stream_responses
+            self.stream_responses = False
+            r = sendreq.connect_request
+            apply_http_proxy_creds(r)
+            self.send_server_data(r.full_message)
+            self._set_server_state(HTTPProtocolProxy.SERVER_STATE_HTTP_AWAITING_PROXY_CONNECT)
+            return
+        elif self.using_upstream_http_proxy and not sendreq.is_ssl:
+            # We're already connected to the proxy
+            r = sendreq.copy()
+            r.path_type = PATH_ABSOLUTE
+            apply_http_proxy_creds(r)
+            self.send_server_data(r.full_message)
+            self._set_server_state(HTTPProtocolProxy.SERVER_STATE_HTTP_AWAITING_RESPONSE)
+            return
+        else:
+            self.send_server_data(sendreq.full_message)
+            self._set_server_state(HTTPProtocolProxy.SERVER_STATE_HTTP_AWAITING_RESPONSE)
+            return
+    
+    def request_complete(self, req):
+        self.log("Request complete, adding to queue")
+        self.request_queue.put(req)
+        self.process_request()
+
+    @defer.inlineCallbacks
+    def response_complete(self, rsp):
+        from pappyproxy import context, macros, http
+
+        if self.server_state == HTTPProtocolProxy.SERVER_STATE_HTTP_AWAITING_PROXY_CONNECT:
+            self.log("Got upstream connection established response")
+            self.stream_responses = self.was_streaming_responses
+
+            if rsp.response_code == 407:
+                print "Incorrect credentials for HTTP proxy. Please check your username and password."
+                self.close_server_connection()
+                return
+
+            self.upstream_http_connected = True
+            self.start_server_tls()
+            self.log("Remote proxy TLS setup, ready for next request")
+            self._set_server_state(HTTPProtocolProxy.SERVER_STATE_HTTP_READY)
+            self.process_request(pop_request=False) # waiting_req is already the request we want to send
+            return
+
+        assert self.server_state == HTTPProtocolProxy.SERVER_STATE_HTTP_AWAITING_RESPONSE
+
+        self.waiting_req.response = self.response
+        sendreq = self.waiting_req
+        sendreq.response = rsp
+        self.waiting_req = None
+
+        if context.in_scope(sendreq) or self.custom_macros:
+            self.log("Response in scope, saving")
+            sendreq.time_end = datetime.datetime.utcnow()
+
+            assert sendreq.complete
+
+            if self.stream_responses and not self.mangle_macros:
+                if self.save_requests:
+                    sendreq.async_deep_save()
+            else:
+                if self.save_requests:
+                    yield sendreq.async_deep_save()
+
+            if self.mangle_macros:
+                if sendreq.response:
+                    mangled = yield macros.mangle_response(sendreq, self.mangle_macros)
+                    if mangled is None:
+                        self._set_server_state(HTTPProtocolProxy.SERVER_STATE_HTTP_READY)
+                        self.send_response(self.BLANK_RESPONSE)
+                        defer.returnValue(None)
+                    if mangled and self.save_requests:
+                        yield sendreq.async_deep_save()
+        else:
+            self.log("Out of scope, not touching response")
+
+        self.log("Checking if we need to write response to transport")
+
+        if self.next_rsp_def is not None:
+            self.next_rsp_def.callback(sendreq)
+
+        if not self.stream_responses:
+            self.log("Wasn't streaming, writing response")
+            self.send_response(sendreq.response.full_message)
+        else:
+            self.log("Already streamed response, not writing to transport, ending response")
+            self.end_response()
+
+        if Response.is_ws_upgrade(rsp):
+            self.log("Upgrading to websocket connection")
+
+            self.server_state = HTTPProtocolProxy.SERVER_STATE_WEBSOCKET
+            self.client_state = HTTPProtocolProxy.CLIENT_STATE_WEBSOCKET
+
+            self.ws_proxy = WebSocketProxy(self.client_transport, self.server_transport, rsp, sendreq, self)
+            self.ws_proxy.message_callback = self.ws_message_complete
+
+            self.request.is_websocket = True
+            self.log("Upgraded to websocket")
+        else:
+            self.log("Processing of response complete, ready for next request")
+            self._set_server_state(HTTPProtocolProxy.SERVER_STATE_HTTP_READY)
+            self.process_request()
+
+    def ws_message_complete(self, wsobj):
+        """
+        Handles objects from both client and server. The object itself
+        has a direction attribute that says which direction it went.
+        """
+        self.request.websocket_messages.append(wsobj)
+
+    # Probably just going to wait for the connection to close
+    # def ws_close(self):
+    #     self.log("Websocket connection closed. Processing next request.")
+    #     self._set_server_state(HTTPProtocolProxy.SERVER_STATE_HTTP_READY)
+    #     self.process_request()
+
+    def send_response(self, data):
+        """
+        Sends a response back to the client and processes the next request
+        """
+        self.send_client_data(data)
+        self.end_response()
+
+    def end_response(self):
+        """
+        Signals that all response data has been sent and the object is ready
+        to process the next request
+        """
+        self.process_request()
+
+    def submit_websocket_frame(self, data):
+        raise PappyException("Websocket stream is not active")
+
+    def abort_connection(self):
+        pass
+
+    def client_connection_made(self, protocol):
+        self._set_client_state(HTTPProtocolProxy.CLIENT_STATE_HTTP_READY)
+        ProtocolProxy.client_connection_made(self, protocol)
+
diff --git a/pappyproxy/macros.py b/pappyproxy/macros.py
index a91ebc1..953019e 100644
--- a/pappyproxy/macros.py
+++ b/pappyproxy/macros.py
@@ -92,9 +92,11 @@ class InterceptMacro(object):
         self.short_name = None
         self.intercept_requests = False
         self.intercept_responses = False
+        self.intercept_ws = False
 
         self.async_req = False
         self.async_rsp = False
+        self.async_ws = False
 
     def __repr__(self):
         return "<InterceptingMacro (%s)>" % self.name
@@ -108,6 +110,9 @@ class InterceptMacro(object):
     def mangle_response(self, request):
         return request.response
 
+    def mangle_ws(self, request, message):
+        return message
+
     @defer.inlineCallbacks
     def async_mangle_request(self, request):
         defer.returnValue(request)
@@ -115,6 +120,10 @@ class InterceptMacro(object):
     @defer.inlineCallbacks
     def async_mangle_response(self, request):
         defer.returnValue(request.response)
+
+    @defer.inlineCallbacks
+    def async_mangle_ws(self, request, message):
+        defer.returnValue(messsage)
             
 class FileInterceptMacro(InterceptMacro):
     """
@@ -165,6 +174,9 @@ class FileInterceptMacro(InterceptMacro):
             if hasattr(self.source, 'mangle_response') and \
                hasattr(self.source, 'async_mangle_response'):
                 raise PappyException('Intercepting macro in %s cannot define both mangle_response and async_mangle_response' % self.filename)
+            if hasattr(self.source, 'mangle_ws') and \
+               hasattr(self.source, 'async_mangle_ws'):
+                raise PappyException('Intercepting macro in %s cannot define both mangle_ws and async_mangle_ws' % self.filename)
         else:
             self.source = None
 
@@ -187,6 +199,15 @@ class FileInterceptMacro(InterceptMacro):
         else:
             self.intercept_responses = False
 
+        if self.source and hasattr(self.source, 'mangle_ws'):
+            self.intercept_ws = True
+            self.async_ws = False
+        elif self.source and hasattr(self.source, 'async_mangle_ws'):
+            self.intercept_ws = True
+            self.async_ws = True
+        else:
+            self.intercept_ws = False
+
     def init(self, args):
         if hasattr(self.source, 'init'):
             self.source.init(args)
@@ -203,6 +224,12 @@ class FileInterceptMacro(InterceptMacro):
             return rsp
         return request.response
 
+    def mangle_ws(self, request, message):
+        if hasattr(self.source, 'mangle_ws'):
+            mangled_ws = self.source.mangle_ws(request, message)
+            return mangled_ws
+        return message
+
     @defer.inlineCallbacks
     def async_mangle_request(self, request):
         if hasattr(self.source, 'async_mangle_request'):
@@ -275,6 +302,73 @@ class MacroTemplate(object):
     def template_argstring(cls, template):
         return cls._template_data[template][2]
 
+## Other functions
+
+    @defer.inlineCallbacks
+    def async_mangle_ws(self, request, message):
+        if hasattr(self.source, 'async_mangle_ws'):
+            mangled_ws = yield self.source.async_mangle_ws(request, message)
+            defer.returnValue(mangled_ws)
+        defer.returnValue(message)
+        
+class MacroTemplate(object):
+    _template_data = {
+        'macro': ('macro.py.template',
+                  'Generic macro template',
+                  '[reqids]',
+                  'macro_{fname}.py',
+                  gen_template_args_macro),
+
+        'intmacro': ('intmacro.py.template',
+                     'Generic intercepting macro template',
+                     '',
+                     'int_{fname}.py',
+                     gen_template_generator_noargs('intmacro')),
+
+        'modheader': ('macro_header.py.template',
+                      'Modify a header in the request and the response if it exists.',
+                      '',
+                      'int_{fname}.py',
+                      gen_template_generator_noargs('modheader')),
+
+        'resubmit': ('macro_resubmit.py.template',
+                     'Resubmit all in-context requests',
+                     '',
+                     'macro_{fname}.py',
+                     gen_template_generator_noargs('resubmit')),
+    }
+
+    @classmethod
+    def fill_template(cls, template, subs):
+        loader = FileSystemLoader(session.config.pappy_dir+'/templates')
+        env = Environment(loader=loader)
+        template = env.get_template(cls._template_data[template][0])
+        return template.render(zip=zip, **subs)
+
+    @classmethod
+    @defer.inlineCallbacks
+    def fill_template_args(cls, template, args=[]):
+        ret = cls._template_data[template][4](args)
+        if isinstance(ret, defer.Deferred):
+            ret = yield ret
+        defer.returnValue(ret)
+
+    @classmethod
+    def template_filename(cls, template, fname):
+        return cls._template_data[template][3].format(fname=fname)
+
+    @classmethod
+    def template_list(cls):
+        return [k for k, v in cls._template_data.iteritems()]
+    
+    @classmethod
+    def template_description(cls, template):
+        return cls._template_data[template][1]
+
+    @classmethod
+    def template_argstring(cls, template):
+        return cls._template_data[template][2]
+
 ## Other functions
 
 def load_macros(loc):
@@ -376,7 +470,7 @@ def mangle_request(request, intmacros):
         defer.returnValue((request, False))
 
     cur_req = request.copy()
-    for k, macro in intmacros.iteritems():
+    for macro in intmacros:
         if macro.intercept_requests:
             if macro.async_req:
                 cur_req = yield macro.async_mangle_request(cur_req.copy())
@@ -389,7 +483,8 @@ def mangle_request(request, intmacros):
     mangled = False
     if not cur_req == request or \
        not cur_req.host == request.host or \
-       not cur_req.port == request.port:
+       not cur_req.port == request.port or \
+       not cur_req.is_ssl == request.is_ssl:
         # copy unique data to new request and clear it off old one
         cur_req.unmangled = request
         cur_req.unmangled.is_unmangled_version = True
@@ -415,10 +510,10 @@ def mangle_response(request, intmacros):
         defer.returnValue(False)
 
     old_rsp = request.response
-    # We copy so that changes to request.response doesn't mangle the original response
-    request.response = request.response.copy()
-    for k, macro in intmacros.iteritems():
+    for macro in intmacros:
         if macro.intercept_responses:
+            # We copy so that changes to request.response doesn't mangle the original response
+            request.response = request.response.copy()
             if macro.async_rsp:
                 request.response = yield macro.async_mangle_response(request)
             else:
@@ -437,3 +532,31 @@ def mangle_response(request, intmacros):
     else:
         request.response = old_rsp
     defer.returnValue(mangled)
+
+@defer.inlineCallbacks
+def mangle_websocket_message(message, request, intmacros):
+    # Mangle messages with list of intercepting macros
+    if not intmacros:
+        defer.returnValue((message, False))
+
+    cur_msg = message.copy()
+    for macro in intmacros:
+        if macro.intercept_ws:
+            if macro.async_ws:
+                cur_msg = yield macro.async_mangle_ws(request, cur_msg.copy())
+            else:
+                cur_msg = macro.mangle_ws(request, cur_msg.copy())
+
+            if cur_msg is None:
+                defer.returnValue((None, True))
+
+    mangled = False
+    if not cur_msg == message:
+        # copy unique data to new request and clear it off old one
+        cur_msg.unmangled = message
+        cur_msg.unmangled.is_unmangled_version = True
+        mangled = True
+    else:
+        # return the original request
+        cur_msg = message
+    defer.returnValue((cur_msg, mangled))
diff --git a/pappyproxy/pappy.py b/pappyproxy/pappy.py
index 9687b56..7ccacbf 100755
--- a/pappyproxy/pappy.py
+++ b/pappyproxy/pappy.py
@@ -9,8 +9,13 @@ The :class:`pappyproxy.pappy.PappySession` object for the current session. Mainl
 used for accessing the session's config information.
 """
 
-import argparse
 import crochet
+import txaio
+
+crochet.no_setup()
+txaio.use_twisted()
+
+import argparse
 import datetime
 import os
 import schema.update
@@ -33,7 +38,6 @@ from twisted.internet.error import CannotListenError
 from twisted.internet.protocol import ServerFactory
 from twisted.internet.threads import deferToThread
 
-crochet.no_setup()
 main_context = context.Context()
 all_contexts = [main_context]
 
@@ -107,7 +111,8 @@ class PappySession(object):
         listen_strs = []
         self.ports = []
         for listener in self.config.listeners:
-            server_factory = proxy.ProxyServerFactory(save_all=True)
+            #server_factory = proxy.ProxyServerFactory(save_all=True)
+            server_factory = proxy.ProxyProtocolFactory()
             try:
                 if 'forward_host_ssl' in listener and listener['forward_host_ssl']:
                     server_factory.force_ssl = True
@@ -284,8 +289,8 @@ def inturrupt_handler(signal, frame):
         quit_confirm_time = datetime.datetime.now() + datetime.timedelta(0, 10)
     else:
         d = session.cleanup()
-        d.addCallback(lambda _: reactor.stop())
-        d.addCallback(lambda _: os._exit(1)) # Sorry blocking threads :(
+        d.addBoth(lambda _: reactor.stop())
+        d.addBoth(lambda _: os._exit(1)) # Sorry blocking threads :(
     
 if __name__ == '__main__':
     start()
diff --git a/pappyproxy/plugin.py b/pappyproxy/plugin.py
index 0b96e16..5b5a98e 100644
--- a/pappyproxy/plugin.py
+++ b/pappyproxy/plugin.py
@@ -13,8 +13,6 @@ import stat
 import crochet
 
 from twisted.internet import defer
-from .proxy import add_intercepting_macro as proxy_add_intercepting_macro
-from .proxy import remove_intercepting_macro as proxy_remove_intercepting_macro
 from .colors import Colors
 from .util import PappyException
 
@@ -95,7 +93,7 @@ def add_intercepting_macro(name, macro):
     passed along.
     """
     for factory in pappyproxy.pappy.session.server_factories:
-        proxy_add_intercepting_macro(name, macro, factory.intercepting_macros)
+        factory.add_intercepting_macro(macro, name=name)
     
 def remove_intercepting_macro(name):
     """
@@ -105,17 +103,18 @@ def remove_intercepting_macro(name):
     macro you would like to stop.
     """
     for factory in pappyproxy.pappy.session.server_factories:
-        proxy_remove_intercepting_macro(name, factory.intercepting_macros)
+        factory.remove_intercepting_macro(name=name)
     
 def active_intercepting_macros():
     """
     Returns a dict of the active intercepting macro objects. Modifying
     this list will not affect which macros are active.
     """
-    ret = {}
-    for factory in pappyproxy.pappy.session.server_factories:
-        for k, v in factory.intercepting_macros.iteritems():
-            ret[k] = v
+    # every factory should have the same int macros so screw it we'll
+    # just use the macros from the first one
+    ret = []
+    if len(pappyproxy.pappy.session.server_factories) > 0:
+        ret = pappyproxy.pappy.session.server_factories[0].get_macro_list()
     return ret
 
 def in_memory_reqs():
@@ -181,6 +180,16 @@ def add_to_history(req):
     pappyproxy.http.Request.cache.add(req)
     pappyproxy.context.reset_context_caches()
 
+def get_active_filter_strings():
+    """
+    Returns a list of filter strings representing the currently active filters
+    """
+    filts = pappyproxy.pappy.main_context.active_filters
+    strs = []
+    for f in filts:
+        strs.append(f.filter_string)
+    return strs
+
 def run_cmd(cmd):
     """
     Run a command as if you typed it into the console. Try and use
@@ -217,3 +226,32 @@ def require_modules(*largs):
                 return func(*args, **kwargs)
         return wr2
     return wr
+
+def set_context_to_saved(name):
+    """
+    Sets the current context to the context saved under the given name.
+    Raises PappyException if name does not exist
+    """
+
+@crochet.wait_for(timeout=None)
+@defer.inlineCallbacks
+def delete_saved_context(name):
+    """
+    Deletes the saved context with the given name.
+    Raises PappyException if name does not exist
+    """
+    
+def save_current_context(name):
+    """
+    Saves the current context under the given name.
+    """
+    
+def save_context(name, filter_strs):
+    """
+    Takes a list of filter strings and saves it as a context under the given name.
+    
+    :param name: The name to save the context under
+    :type name: string
+    :param filter_strs: The in-order list of filter strings of the context to save.
+    :type filter_strs: List of strings
+    """
diff --git a/pappyproxy/plugins/filter.py b/pappyproxy/plugins/filter.py
index 8d6904a..34f886e 100644
--- a/pappyproxy/plugins/filter.py
+++ b/pappyproxy/plugins/filter.py
@@ -3,6 +3,7 @@ import pappyproxy
 
 from pappyproxy.util import PappyException, confirm, autocomplete_startswith
 from pappyproxy.http import Request
+from pappyproxy.context import save_context, delete_saved_context, get_saved_context, get_all_saved_contexts
 from twisted.internet import defer
 
 class BuiltinFilters(object):
@@ -157,9 +158,9 @@ def filter_prune(line):
     act_reqs = yield pappyproxy.pappy.main_context.get_reqs()
     inact_reqs = set(Request.cache.req_ids()).difference(set(act_reqs))
     message = 'This will delete %d/%d requests. You can NOT undo this!! Continue?' % (len(inact_reqs), (len(inact_reqs) + len(act_reqs)))
-    print message
-    # if not confirm(message, 'n'):
-    #     defer.returnValue(None)
+    #print message
+    if not confirm(message, 'n'):
+        defer.returnValue(None)
     
     for reqid in inact_reqs:
         try:
@@ -170,6 +171,55 @@ def filter_prune(line):
     print 'Deleted %d requests' % len(inact_reqs)
     defer.returnValue(None)
 
+@defer.inlineCallbacks
+def _save_filters_to(key):
+    if key == '':
+        raise PappyException("Must give name to save filters as")
+    strs = pappyproxy.plugin.get_active_filter_strings()
+    yield save_context(key, strs, pappyproxy.http.dbpool)
+    defer.returnValue(strs)
+
+@crochet.wait_for(timeout=None)
+@defer.inlineCallbacks
+def save_filter_set(line):
+    if line == '':
+        raise PappyException("Must give name to save filters as")
+    strs = yield _save_filters_to(line)
+    print 'Filters saved to %s:' % line
+    for s in strs:
+        print '  %s' % s
+
+@crochet.wait_for(timeout=None)
+@defer.inlineCallbacks
+def load_filter_set(line):
+    if line == '':
+        raise PappyException("Must give name to save filters as")
+    strs = yield get_saved_context(line, pappyproxy.http.dbpool)
+    yield _save_filters_to('_')
+    pappyproxy.pappy.main_context.set_filters([])
+    for s in strs:
+        yield pappyproxy.pappy.main_context.add_filter_string(s)
+    print 'Set the context to:'
+    for s in strs:
+        print '  %s' % s
+
+def delete_filter_set(line):
+    if line == '':
+        raise PappyException("Must give name to save filters as")
+    delete_saved_context(line, pappyproxy.http.dbpool)
+
+@crochet.wait_for(timeout=None)
+@defer.inlineCallbacks
+def list_filter_set(line):
+    print 'Saved contexts:'
+    contexts = yield get_all_saved_contexts(pappyproxy.http.dbpool)
+    for k in sorted(contexts.keys()):
+        v = contexts[k]
+        print '%s' % k
+        for s in v:
+            print '  %s' % s
+        print ''
+
 ###############
 ## Plugin hooks
 
@@ -185,6 +235,10 @@ def load_cmds(cmd):
         'filter_up': (filter_up, None),
         'builtin_filter': (builtin_filter, complete_builtin_filter),
         'filter': (filtercmd, complete_filtercmd),
+        'save_context': (save_filter_set, None),
+        'load_context': (load_filter_set, None),
+        'delete_context': (delete_filter_set, None),
+        'list_contexts': (list_filter_set, None),
     })
     cmd.add_aliases([
         #('filter_prune', ''),
@@ -198,4 +252,8 @@ def load_cmds(cmd):
         ('builtin_filter', 'fbi'),
         ('filter', 'f'),
         ('filter', 'fl'),
+        ('save_context', 'sc'),
+        ('load_context', 'lc'),
+        ('delete_context', 'dc'),
+        ('list_contexts', 'cls'),
     ])
diff --git a/pappyproxy/plugins/macrocmds.py b/pappyproxy/plugins/macrocmds.py
index 6b8b108..fcece6b 100644
--- a/pappyproxy/plugins/macrocmds.py
+++ b/pappyproxy/plugins/macrocmds.py
@@ -111,7 +111,7 @@ def complete_run_int_macro(text, line, begidx, endidx):
     running = []
     not_running = []
     for macro in loaded_int_macros:
-        if macro.name in [m.name for k, m in active_intercepting_macros().iteritems()]:
+        if macro.name in [m.name for m in active_intercepting_macros()]:
             running.append(macro)
         else:
             not_running.append(macro)
@@ -151,7 +151,7 @@ def complete_stop_int_macro(text, line, begidx, endidx):
     running = []
     not_running = []
     for macro in loaded_int_macros:
-        if macro.name in [m.name for k, m in active_intercepting_macros().iteritems()]:
+        if macro.name in [m.name for m in active_intercepting_macros()]:
             running.append(macro)
         else:
             not_running.append(macro)
@@ -187,7 +187,7 @@ def list_int_macros(line):
     running = []
     not_running = []
     for macro in loaded_int_macros:
-        if macro.name in [m.name for k, m in active_intercepting_macros().iteritems()]:
+        if macro.name in [m.name for m in active_intercepting_macros()]:
             running.append(macro)
         else:
             not_running.append(macro)
diff --git a/pappyproxy/plugins/manglecmds.py b/pappyproxy/plugins/manglecmds.py
index 4bd8f65..007273d 100644
--- a/pappyproxy/plugins/manglecmds.py
+++ b/pappyproxy/plugins/manglecmds.py
@@ -27,8 +27,10 @@ class MangleInterceptMacro(InterceptMacro):
         self.name = 'Pappy Interceptor Macro'
         self.intercept_requests = False
         self.intercept_responses = False
+        self.intercept_ws = False
         self.async_req = True
         self.async_rsp = True
+        self.async_ws = True
 
     def __repr__(self):
         return "<MangleInterceptingMacro>"
@@ -99,6 +101,38 @@ class MangleInterceptMacro(InterceptMacro):
             retrsp = mangled_rsp
 
         defer.returnValue(retrsp)
+
+    @defer.inlineCallbacks
+    def async_mangle_ws(self, request, message):
+        # This function gets called to mangle/edit respones passed through the proxy
+
+        retmsg = message
+        # Write original message to the temp file
+        with tempfile.NamedTemporaryFile(delete=False) as tf:
+            tfName = tf.name
+            tf.write(retmsg.contents)
+
+        # Have the console edit the file
+        yield edit_file(tfName, front=True)
+
+        # Create new mangled message from edited file
+        with open(tfName, 'r') as f:
+            text = f.read()
+
+        os.remove(tfName)
+
+        # Check if dropped
+        if text == '':
+            pappyproxy.proxy.log('Websocket message dropped!')
+            defer.returnValue(None)
+
+        mangled_message = message.copy()
+        mangled_message.contents = text
+
+        if mangled_message.contents != message.contents:
+            retmsg = mangled_message
+
+        defer.returnValue(retmsg)
             
 
 ###############
@@ -155,29 +189,38 @@ def intercept(line):
     args = shlex.split(line)
     intercept_requests = False
     intercept_responses = False
+    intercept_ws = True
+    intercept_ws
 
     req_names = ('req', 'request', 'requests')
     rsp_names = ('rsp', 'response', 'responses')
+    ws_names = ('ws', 'websocket')
 
     if any(a in req_names for a in args):
         intercept_requests = True
     if any(a in rsp_names for a in args):
         intercept_responses = True
+    if any(a in req_names for a in args):
+        intercept_ws = True
     if not args:
         intercept_requests = True
 
-    if intercept_requests and intercept_responses:
-        intercept_str = 'Requests and responses'
-    elif intercept_requests:
-        intercept_str = 'Requests'
-    elif intercept_responses:
-        intercept_str = 'Responses'
-    else:
+    intercepting = []
+    if intercept_requests:
+        intercepting.append('Requests')
+    if intercept_responses:
+        intercepting.append('Responses')
+    if intercept_ws:
+        intercepting.append('Websocket Messages')
+    if not intercept_requests and not intercept_responses and not intercept_ws:
         intercept_str = 'NOTHING'
+    else:
+        intercept_str = ', '.join(intercepting)
 
     mangle_macro = MangleInterceptMacro()
     mangle_macro.intercept_requests = intercept_requests
     mangle_macro.intercept_responses = intercept_responses
+    mangle_macro.intercept_ws = intercept_ws
 
     add_intercepting_macro('pappy_intercept', mangle_macro)
 
diff --git a/pappyproxy/plugins/misc.py b/pappyproxy/plugins/misc.py
index 32ae5c7..e35133e 100644
--- a/pappyproxy/plugins/misc.py
+++ b/pappyproxy/plugins/misc.py
@@ -200,7 +200,7 @@ def submit(line):
     """
     Resubmit some requests, optionally with modified headers and cookies.
 
-    Usage: submit reqids [-h] [-m] [-u] [-p] [-c [COOKIES [COOKIES ...]]] [-d [HEADERS [HEADERS ...]]]
+    Usage: submit reqids [-h] [-m] [-u] [-p] [-o REQID] [-c [COOKIES [COOKIES ...]]] [-d [HEADERS [HEADERS ...]]]
     """
     
     parser = argparse.ArgumentParser(prog="submit", usage=submit.__doc__)
@@ -210,16 +210,25 @@ def submit(line):
     parser.add_argument('-p', '--uniquepath', action='store_true', help='Only resubmit one request per endpoint (ignoring URL parameters)')
     parser.add_argument('-c', '--cookies', nargs='*', help='Apply a cookie to requests before submitting')
     parser.add_argument('-d', '--headers', nargs='*', help='Apply a header to requests before submitting')
+    parser.add_argument('-o', '--copycookies', help='Copy the cookies used in another request')
     args = parser.parse_args(shlex.split(line))
 
     headers = {}
     cookies = {}
+    clear_cookies = False
 
     if args.headers:
         for h in args.headers:
             k, v = h.split('=', 1)
             headers[k] = v
 
+    if args.copycookies:
+        reqid = args.copycookies
+        req = yield Request.load_request(reqid)
+        clear_cookies = True
+        for k, v in req.cookies.all_pairs():
+            cookies[k] = v
+
     if args.cookies:
         for c in args.cookies:
             k, v = c.split('=', 1)
@@ -232,23 +241,9 @@ def submit(line):
     
     reqs = yield load_reqlist(args.reqids)
 
-    if args.unique or args.uniquepath:
-        endpoints = set()
-        new_reqs = []
-        for r in reqs:
-            if args.unique:
-                s = r.url
-            else:
-                s = r.path
-
-            if not s in endpoints:
-                new_reqs.append(r.copy())
-                endpoints.add(s)
-        reqs = new_reqs
-    else:
-        reqs = [r.copy() for r in reqs]
-
     for req in reqs:
+        if clear_cookies:
+            req.cookies.clear()
         newsession.apply_req(req)
 
     conf_message = "You're about to submit %d requests, continue?" % len(reqs)
@@ -258,12 +253,9 @@ def submit(line):
     for r in reqs:
         r.tags.add('resubmitted')
 
-    if args.inmem:
-        yield async_submit_requests(reqs)
-        for req in reqs:
-            add_to_history(req)
-    else:
-        yield async_submit_requests(reqs, save=True)
+    save = not args.inmem
+    yield async_submit_requests(reqs, save=save, save_in_mem=args.inmem,
+        unique_paths=args.uniquepath, unique_path_and_args=args.unique)
         
 def load_cmds(cmd):
     cmd.set_cmds({
diff --git a/pappyproxy/plugins/view.py b/pappyproxy/plugins/view.py
index 73e08a7..89cc008 100644
--- a/pappyproxy/plugins/view.py
+++ b/pappyproxy/plugins/view.py
@@ -4,10 +4,11 @@ import json
 import pappyproxy
 import pygments
 import pprint
+import re
 import shlex
 import urllib
 
-from pappyproxy.util import PappyException, utc2local, load_reqlist, print_table, print_request_rows, get_req_data_row
+from pappyproxy.util import PappyException, utc2local, load_reqlist, print_table, print_request_rows, get_req_data_row, datetime_string, maybe_hexdump
 from pappyproxy.http import Request, repeatable_parse_qs
 from twisted.internet import defer
 from pappyproxy.plugin import async_main_context_ids
@@ -19,11 +20,58 @@ from pygments.lexers.html import XmlLexer
 ###################
 ## Helper functions
 
-def view_full_message(request, headers_only=False):
+def view_full_message(request, headers_only=False, try_ws=False):
+    def _print_message(mes):
+        print_str = ''
+        if mes.direction == 'INCOMING':
+            print_str += Colors.BLUE
+            print_str += '< Incoming'
+        elif mes.direction == 'OUTGOING':
+            print_str += Colors.GREEN
+            print_str += '> Outgoing'
+        else:
+            print_str += Colors.RED
+            print_str += '? ERROR: Unknown direction'
+        if mes.unmangled:
+            print_str += ', mangled'
+        print_str += ', binary = %s\n' % mes.is_binary
+        print_str += Colors.ENDC
+        print_str += maybe_hexdump(mes.contents)
+        print_str += '\n'
+        return print_str
+
     if headers_only:
         print request.headers_section_pretty
     else:
-        print request.full_message_pretty
+        if try_ws and request.websocket_messages:
+            print_str = ''
+            print_str += Styles.TABLE_HEADER
+            print_str += "Websocket session handshake\n"
+            print_str += Colors.ENDC
+            print_str += request.full_message_pretty
+            print_str += '\n'
+            print_str += Styles.TABLE_HEADER
+            print_str += "Websocket session \n"
+            print_str += Colors.ENDC
+            for mes in request.websocket_messages:
+                print_str += _print_message(mes)
+                if mes.unmangled:
+                    print_str += Colors.YELLOW
+                    print_str += '-'*10
+                    print_str += Colors.ENDC
+                    print_str += ' ^^ UNMANGLED ^^ '
+                    print_str += Colors.YELLOW
+                    print_str += '-'*10
+                    print_str += Colors.ENDC
+                    print_str += '\n'
+                    print_str += _print_message(mes.unmangled)
+                    print_str += Colors.YELLOW
+                    print_str += '-'*20 + '-'*len(' ^^ UNMANGLED ^^ ')
+                    print_str += '\n'
+                    print_str += Colors.ENDC
+            print print_str
+        else:
+            print request.full_message_pretty
 
 def print_request_extended(request):
     # Prints extended info for the request
@@ -63,8 +111,7 @@ def print_request_extended(request):
         is_ssl = 'NO'
 
     if request.time_start:
-        dtobj = utc2local(request.time_start)
-        time_made_str = dtobj.strftime('%a, %b %d, %Y, %I:%M:%S %p')
+        time_made_str = datetime_string(request.time_start)
     else:
         time_made_str = '--'
 
@@ -325,7 +372,7 @@ def view_full_request(line):
     for req in reqs:
         if len(reqs) > 1:
             print 'Request %s:' % req.reqid
-        view_full_message(req)
+        view_full_message(req, try_ws=True)
         if len(reqs) > 1:
             print '-'*30
             print ''
@@ -498,6 +545,20 @@ def get_param_info(line):
                 add_param(found_params, 'Cookie', k, v, req.reqid)
     print_param_info(found_params)
 
+@crochet.wait_for(timeout=None)
+@defer.inlineCallbacks
+def find_urls(line):
+    args = shlex.split(line)
+    reqs = yield load_reqlist(args[0])
+
+    url_regexp = r'((?:http|ftp|https)://(?:[\w_-]+(?:(?:\.[\w_-]+)+))(?:[\w.,@?^=%&:/~+#-]*[\w@?^=%&/~+#-])?)'
+    urls = set()
+    for req in reqs:
+        urls |= set(re.findall(url_regexp, req.full_message))
+        if req.response:
+            urls |= set(re.findall(url_regexp, req.response.full_message))
+    for url in sorted(urls):
+        print url
 
 @crochet.wait_for(timeout=None)
 @defer.inlineCallbacks
@@ -568,6 +629,7 @@ def load_cmds(cmd):
         'param_info': (get_param_info, None),
         'site_map': (site_map, None),
         'dump_response': (dump_response, None),
+        'urls': (find_urls, None),
     })
     cmd.add_aliases([
         ('list', 'ls'),
diff --git a/pappyproxy/proxy.py b/pappyproxy/proxy.py
index 8376fea..73c784f 100644
--- a/pappyproxy/proxy.py
+++ b/pappyproxy/proxy.py
@@ -6,15 +6,14 @@ import random
 
 from OpenSSL import SSL
 from OpenSSL import crypto
-from pappyproxy import context
-from pappyproxy import http
-from pappyproxy import macros
-from pappyproxy.util import PappyException, printable_data
+from pappyproxy.util import PappyException, printable_data, short_data
 from twisted.internet import defer
 from twisted.internet import reactor, ssl
-from twisted.internet.protocol import ClientFactory, ServerFactory
+from twisted.internet.protocol import ClientFactory, ServerFactory, Protocol
 from twisted.protocols.basic import LineReceiver
 from twisted.python.failure import Failure
+#from twisted.web.client import BrowserLikePolicyForHTTPS
+from pappyproxy.util import hexdump
 
 next_connection_id = 1
 
@@ -26,16 +25,6 @@ def get_next_connection_id():
     next_connection_id += 1
     return ret_id
 
-def add_intercepting_macro(key, macro, int_macro_dict):
-    if key in int_macro_dict:
-        raise PappyException('Macro with key %s already exists' % key)
-    int_macro_dict[key] = macro
-
-def remove_intercepting_macro(key, int_macro_dict):
-    if not key in int_macro_dict:
-        raise PappyException('Macro with key %s not currently running' % key)
-    del int_macro_dict[key]
-
 def log(message, id=None, symbol='*', verbosity_level=1):
     from pappyproxy.pappy import session
 
@@ -63,41 +52,6 @@ def log_request(request, id=None, symbol='*', verbosity_level=3):
         for l in r_split:
             log(l, id, symbol, verbosity_level)
             
-def get_endpoint(target_host, target_port, target_ssl, socks_config=None, use_http_proxy=False, debugid=None):
-    # Imports go here to allow mocking for tests
-    from twisted.internet.endpoints import SSL4ClientEndpoint, TCP4ClientEndpoint
-    from txsocksx.client import SOCKS5ClientEndpoint
-    from txsocksx.tls import TLSWrapClientEndpoint
-    from pappyproxy.pappy import session
-
-    log("Getting endpoint for host '%s' on port %d ssl=%s, socks_config=%s, use_http_proxy=%s" % (target_host, target_port, target_ssl, str(socks_config), use_http_proxy), id=debugid, verbosity_level=3)
-
-    if session.config.http_proxy and use_http_proxy:
-        target_host = session.config.http_proxy['host']
-        target_port = session.config.http_proxy['port']
-        target_ssl = False # We turn on ssl after CONNECT request if needed
-        log("Connecting to http proxy at %s:%d" % (target_host, target_port), id=debugid, verbosity_level=3)
-
-    if socks_config is not None:
-        sock_host = socks_config['host']
-        sock_port = int(socks_config['port'])
-        methods = {'anonymous': ()}
-        if 'username' in socks_config and 'password' in socks_config:
-            methods['login'] = (socks_config['username'], socks_config['password'])
-        tcp_endpoint = TCP4ClientEndpoint(reactor, sock_host, sock_port)
-        socks_endpoint = SOCKS5ClientEndpoint(target_host, target_port, tcp_endpoint, methods=methods)
-        if target_ssl:
-            endpoint = TLSWrapClientEndpoint(ssl.ClientContextFactory(), socks_endpoint)
-        else:
-            endpoint = socks_endpoint
-    else:
-        if target_ssl:
-            endpoint = SSL4ClientEndpoint(reactor, target_host, target_port,
-                                          ssl.ClientContextFactory())
-        else:
-            endpoint = TCP4ClientEndpoint(reactor, target_host, target_port)
-    return endpoint
-
 def is_wildcardable_domain_name(domain):
     """
     Guesses if this is a domain that can have a wildcard CN
@@ -130,554 +84,6 @@ def get_most_general_cn(domain):
     else:
         return domain
         
-class ProxyClient(LineReceiver):
-
-    def __init__(self, request):
-        self.factory = None
-        self._response_sent = False
-        self._sent = False
-        self.request = request
-        self.data_defer = defer.Deferred()
-        self.completed = False
-        self.stream_response = True # used so child classes can temporarily turn off response streaming
-        self.data_received = False # we assume something's wrong until we get some data
-
-        self._response_obj = http.Response()
-
-    def log(self, message, symbol='*', verbosity_level=1):
-        log(message, id=self.factory.connection_id, symbol=symbol, verbosity_level=verbosity_level)
-
-    def lineReceived(self, *args, **kwargs):
-        line = args[0]
-        if line is None:
-            line = ''
-        self.log(line, symbol='r<', verbosity_level=3)
-        self._response_obj.add_line(line)
-        if self._response_obj.headers_complete:
-            self.setRawMode()
-
-    def rawDataReceived(self, *args, **kwargs):
-        from pappyproxy.pappy import session
-
-        data = args[0]
-        self.log('Returning data back through stream')
-        if not self._response_obj.complete:
-            if data:
-                if session.config.debug_to_file or session.config.debug_verbosity > 0:
-                    s = printable_data(data)
-                    dlines = s.split('\n')
-                    for l in dlines:
-                        self.log(l, symbol='<rd', verbosity_level=3)
-            self._response_obj.add_data(data)
-
-    def dataReceived(self, data):
-        self.data_received = True
-        if self.factory.stream_response and self.stream_response:
-            self.factory.return_transport.write(data)
-        LineReceiver.dataReceived(self, data)
-        if not self.completed:
-            if self._response_obj.complete:
-                self.completed = True
-                self.handle_response_end()
-        
-    def connectionMade(self):
-        self.log("Connection made, sending request", verbosity_level=3)
-        lines = self.request.full_request.splitlines()
-        for l in lines:
-            self.log(l, symbol='>r', verbosity_level=3)
-        self.transport.write(self.request.full_request)
-        
-    def handle_response_end(self, *args, **kwargs):
-        self.log("Remote response finished, returning data to original stream")
-        self.request.response = self._response_obj
-        self.log('Response ended, losing connection')
-        self.transport.loseConnection()
-        assert self._response_obj.full_response
-        self.data_defer.callback(self.request)
-
-    def respond_failure(self, message):
-        """
-        Closes the connection to the remote server and returns an error message.
-        The request object will have a response of None.
-        """
-        #self.transport.loseConnection()
-        self.data_defer.errback(PappyException(message))
-
-    def clientConnectionFailed(self, connector, reason):
-        self.log("Connection with remote server failed: %s" % reason)
-
-    def clientConnectionLost(self, connector, reason):
-        self.log("Connection with remote server lost: %s" % reason)
-
-    def _guess_failure_reason(self, failure):
-        message = failure.getErrorMessage()
-        try:
-            failure.raiseException()
-        except SSL.Error as e:
-            message = 'Error performing SSL handshake'
-        except Exception as e:
-            pass
-        return message
-
-    def connectionLost(self, reason):
-        self.log("Connection lost: %s" % reason)
-        if not self.data_received:
-            self.request.response = None
-            message = self._guess_failure_reason(reason)
-            self.respond_failure("Connection lost: %s" % message)
-
-class UpstreamHTTPProxyClient(ProxyClient):
-
-    def __init__(self, request):
-        ProxyClient.__init__(self, request)
-        self.connect_response = False
-        self.proxy_connected = False
-        self.stream_response = False
-        self.creds = None
-
-    def write_proxied_request(self, request):
-        """
-        Takes an unencrypted request and sends it to the proxy server to be
-        forwarded.
-        """
-        sendreq = request.copy()
-        sendreq.path_type = http.PATH_ABSOLUTE
-        if self.creds is not None:
-            sendreq.proxy_creds = self.creds
-        lines = sendreq.full_request.splitlines()
-        for l in lines:
-            self.log(l, symbol='>rp', verbosity_level=3)
-        self.transport.write(sendreq.full_message)
-
-    def connectionMade(self):
-        self.log("Connection made to http proxy", verbosity_level=3)
-        if not self.proxy_connected:
-            if self.request.is_ssl:
-                connreq = self.request.connect_request
-                self.connect_response = True
-                if self.creds is not None:
-                    connreq.proxy_creds = self.creds
-                lines = connreq.full_message.splitlines()
-                for l in lines:
-                    self.log(l, symbol='>p', verbosity_level=3)
-                self.transport.write(connreq.full_message)
-            else:
-                self.proxy_connected = True
-                self.stream_response = True
-                lines = self.request.full_message.splitlines()
-                for l in lines:
-                    self.log(l, symbol='>p', verbosity_level=3)
-                self.write_proxied_request(self.request)
-
-    def handle_response_end(self, *args, **kwargs):
-        if self._response_obj.response_code == 407:
-            print "Incorrect credentials for HTTP proxy. Please check your username and password."
-            self.transport.loseConnection()
-            return
-        if self.proxy_connected:
-            self.log("Received request while connected, forwarding to http proxy", verbosity_level=3)
-            self.request.response = self._response_obj
-            self.transport.loseConnection()
-            assert self._response_obj.full_response
-            self.data_defer.callback(self.request)
-        elif self._response_obj.response_code != 200:
-            print "Error establishing connection to proxy"
-            self.transport.loseConnection()
-            return
-        elif self.connect_response:
-            self.log("Response to CONNECT request recieved from http proxy", verbosity_level=3)
-            self.proxy_connected = True
-            self.stream_response = True
-            self._response_obj = http.Response()
-            self.setLineMode()
-            self.completed = False
-            self._sent = False
-
-            self.log("Starting TLS", verbosity_level=3)
-            self.transport.startTLS(ssl.ClientContextFactory())
-            self.log("TLS started", verbosity_level=3)
-            lines = self.request.full_message.splitlines()
-            for l in lines:
-                self.log(l, symbol='>rpr', verbosity_level=3)
-            self.transport.write(self.request.full_message)
-
-class ProxyClientFactory(ClientFactory):
-
-    def __init__(self, request, save_all=False, stream_response=False,
-                 return_transport=None):
-        self.request = request
-        self.connection_id = -1
-        self.data_defer = defer.Deferred()
-        self.start_time = datetime.datetime.utcnow()
-        self.end_time = None
-        self.save_all = save_all
-        self.stream_response = stream_response
-        self.return_transport = return_transport
-        self.intercepting_macros = {}
-        self.use_as_proxy = False
-        self.sendback_function = None
-        self.dropped_request = False
-
-        # Only used for unit tests. Do not use.
-        self._use_string_transport = False
-        self._conn_info = None
-
-    def log(self, message, symbol='*', verbosity_level=1):
-        log(message, id=self.connection_id, symbol=symbol, verbosity_level=verbosity_level)
-
-    def buildProtocol(self, addr):
-        from pappyproxy.pappy import session
-        if self.use_as_proxy and context.in_scope(self.request):
-            p = UpstreamHTTPProxyClient(self.request)
-            if 'username' in session.config.http_proxy and 'password' in session.config.http_proxy:
-                username = session.config.http_proxy['username']
-                password = session.config.http_proxy['password']
-                p.creds = (username, password)
-        else:
-            p = ProxyClient(self.request)
-        p.factory = self
-        self.log("Building protocol", verbosity_level=3)
-        p.data_defer.addCallback(self.return_request_pair)
-        p.data_defer.addErrback(self._data_defer_errback)
-        return p
-
-    def clientConnectionFailed(self, connector, reason):
-        self.log("Connection failed with remote server: %s" % reason.getErrorMessage())
-
-    def clientConnectionLost(self, connector, reason):
-        self.log("Connection lost with remote server: %s" % reason.getErrorMessage())
-
-    @defer.inlineCallbacks
-    def prepare_request(self):
-        """
-        Prepares request for submitting
-        
-        Saves the associated request with a temporary start time, mangles it, then
-        saves the mangled version with an update start time. Also updates flags
-        and values needed for submitting the request.
-        """
-        from pappyproxy.pappy import session
-
-        sendreq = self.request
-        if context.in_scope(sendreq):
-            mangle_macros = copy.copy(self.intercepting_macros)
-            self.request.time_start = datetime.datetime.utcnow()
-            if self.save_all:
-                if self.stream_response and not mangle_macros:
-                    self.request.async_deep_save()
-                else:
-                    yield self.request.async_deep_save()
-
-            (mangreq, mangled) = yield macros.mangle_request(sendreq, mangle_macros)
-            if mangreq is None:
-                self.log("Request dropped. Closing connections.")
-                self.request.tags.add('dropped')
-                self.request.response = None
-                self.dropped_request = True
-                defer.returnValue(None)
-            else:
-                sendreq = mangreq
-                if sendreq and mangled and self.save_all:
-                    self.start_time = datetime.datetime.utcnow()
-                    sendreq.time_start = self.start_time
-                    yield sendreq.async_deep_save()
-
-                if session.config.http_proxy:
-                    self.use_as_proxy = True
-                    if (not self.stream_response) and self.sendback_function:
-                        self.data_defer.addCallback(self.sendback_function)
-        else:
-            self.log("Request out of scope, passing along unmangled")
-        self.request = sendreq
-        defer.returnValue(self.request)
-
-    @defer.inlineCallbacks
-    def return_request_pair(self, request):
-        """
-        If the request is in scope, it saves the completed request,
-        sets the start/end time, mangles the response, saves the
-        mangled version, then calls back data_defer with the mangled
-        request
-        """
-        from pappyproxy.pappy import session
-
-        self.end_time = datetime.datetime.utcnow()
-        if session.config.debug_to_file or session.config.debug_verbosity > 0 and request.response:
-            log_request(printable_data(request.response.full_response), id=self.connection_id, symbol='<m', verbosity_level=3)
-
-        request.time_start = self.start_time
-        request.time_end = self.end_time
-        if context.in_scope(request):
-            mangle_macros = copy.copy(self.intercepting_macros)
-
-            if self.save_all:
-                if self.stream_response and not mangle_macros:
-                    request.async_deep_save()
-                else:
-                    yield request.async_deep_save()
-
-            if request.response:
-                mangled = yield macros.mangle_response(request, mangle_macros)
-
-                if mangled and self.save_all:
-                    yield request.async_deep_save()
-
-                if request.response and (session.config.debug_to_file or session.config.debug_verbosity > 0):
-                    log_request(printable_data(request.response.full_response),
-                                id=self.connection_id, symbol='<', verbosity_level=3)
-        else:
-            self.log("Response out of scope, passing along unmangled")
-        self.data_defer.callback(request)
-        defer.returnValue(None)
-
-    @defer.inlineCallbacks
-    def connect(self):
-        from pappyproxy.pappy import session
-
-        yield self.prepare_request()
-        if self.dropped_request:
-            self.data_defer.callback(self.request)
-            defer.returnValue(None)
-
-        if context.in_scope(self.request):
-            # Get connection using config
-            endpoint = get_endpoint(self.request.host,
-                                    self.request.port,
-                                    self.request.is_ssl,
-                                    socks_config=session.config.socks_proxy,
-                                    use_http_proxy=True)
-        else:
-            # Just forward it normally
-            endpoint = get_endpoint(self.request.host,
-                                    self.request.port,
-                                    self.request.is_ssl,
-                                    socks_config=None,
-                                    use_http_proxy=False)
-
-        if self._use_string_transport:
-            from pappyproxy.tests.testutil import TLSStringTransport
-            # "Connect" via string transport
-            protocol = self.buildProtocol(('127.0.0.1', 0))
-
-            # Pass the protocol back to the test
-            if self._conn_info:
-                self._conn_info['protocol'] = protocol
-
-            tr = TLSStringTransport()
-            protocol.makeConnection(tr)
-        else:
-            # Connect via the endpoint
-            self.log("Accessing using endpoint")
-            yield endpoint.connect(self)
-            self.log("Connected")
-
-    def _data_defer_errback(self, message):
-        self.data_defer.errback(message)
-
-class ProxyServerFactory(ServerFactory):
-
-    def __init__(self, save_all=False):
-        from pappyproxy.site import PappyWebServer
-        
-        self.intercepting_macros = collections.OrderedDict()
-        self.save_all = save_all
-        self.force_ssl = False
-        self.web_server = PappyWebServer()
-        self.forward_host = None
-
-    def buildProtocol(self, addr):
-        prot = ProxyServer()
-        prot.factory = self
-        return prot
-
-class ProxyServer(LineReceiver):
-
-    def log(self, message, symbol='*', verbosity_level=1):
-        log(message, id=self.connection_id, symbol=symbol, verbosity_level=verbosity_level)
-
-    def __init__(self, *args, **kwargs):
-        global next_connection_id
-        self.connection_id = get_next_connection_id()
-
-        self._request_obj = http.Request()
-        self._connect_response = False
-        self._forward = True
-        self._connect_uri = None
-        self._connect_host = None
-        self._connect_ssl = None
-        self._connect_port = None
-        self._client_factory = None
-
-    def lineReceived(self, *args, **kwargs):
-        line = args[0]
-        self.log(line, symbol='>', verbosity_level=3)
-        self._request_obj.add_line(line)
-
-        if self._request_obj.headers_complete:
-            self.setRawMode()
-            
-    def rawDataReceived(self, *args, **kwargs):
-        data = args[0]
-        self._request_obj.add_data(data)
-        self.log(data, symbol='d>', verbosity_level=3)
-
-    def dataReceived(self, *args, **kwargs):
-        # receives the data then checks if the request is complete.
-        # if it is, it calls full_Request_received
-        LineReceiver.dataReceived(self, *args, **kwargs)
-
-        if self._request_obj.complete:
-            self.full_request_received()
-        
-    def _start_tls(self, cert_host=None):
-        from pappyproxy.pappy import session
-
-        # Generate a cert for the hostname and start tls
-        if cert_host is None:
-            host = self._request_obj.host
-        else:
-            host = cert_host
-        cn_host = get_most_general_cn(host)
-        if not host in cached_certs:
-            log("Generating cert for '%s'" % cn_host,
-                verbosity_level=3)
-            (pkey, cert) = generate_cert(cn_host,
-                                         session.config.cert_dir)
-            cached_certs[cn_host] = (pkey, cert)
-        else:
-            log("Using cached cert for %s" % cn_host, verbosity_level=3)
-            (pkey, cert) = cached_certs[cn_host]
-        ctx = ServerTLSContext(
-            private_key=pkey,
-            certificate=cert,
-        )
-        self.transport.startTLS(ctx, self.factory)
-
-    def _connect_okay(self):
-        self.log('Responding to browser CONNECT request', verbosity_level=3)
-        okay_str = 'HTTP/1.1 200 Connection established\r\n\r\n'
-        self.transport.write(okay_str)
-                
-    @defer.inlineCallbacks
-    def full_request_received(self):
-        from pappyproxy.http import Request
-
-        global cached_certs
-        
-        self.log('End of request', verbosity_level=3)
-
-        forward = True
-        if self._request_obj.verb.upper() == 'CONNECT':
-            self._connect_okay()
-            self._start_tls()
-            self._connect_uri = self._request_obj.url
-            self._connect_host = self._request_obj.host
-            self._connect_ssl = True # do we just assume connect means ssl?
-            self._connect_port = self._request_obj.port
-            self.log('uri=%s, ssl=%s, connect_port=%s' % (self._connect_uri, self._connect_ssl, self._connect_port), verbosity_level=3)
-            forward = False
-
-        if self._request_obj.host == 'pappy':
-            yield self.factory.web_server.handle_request(self._request_obj)
-            self.transport.write(self._request_obj.response.full_message)
-            forward = False
-
-        # if _request_obj.host is a listener, forward = False
-
-        if self.factory.intercepting_macros:
-            return_transport = None
-        else:
-            return_transport = self.transport
-
-        if forward:
-            d = Request.submit_request(self._request_obj,
-                                       save_request=True,
-                                       intercepting_macros=self.factory.intercepting_macros,
-                                       stream_transport=return_transport)
-            if return_transport is None:
-                d.addCallback(self.send_response_back)
-            d.addErrback(self.send_error_back)
-        self._reset()
-        
-    def _reset(self):
-        # Reset per-request variables and have the request default to using
-        # some parameters from the connect request
-        self.log("Resetting per-request data", verbosity_level=3)
-        self._connect_response = False
-        self._request_obj = http.Request()
-        if self._connect_uri:
-            self._request_obj.url = self._connect_uri
-        if self._connect_host:
-            self._request_obj._host = self._connect_host
-        if self._connect_ssl:
-            self._request_obj.is_ssl = self._connect_ssl
-        if self._connect_port:
-            self._request_obj.port = self._connect_port
-        self.setLineMode()
-
-    def send_response_back(self, request):
-        if request.response is not None:
-            self.transport.write(request.response.full_response)
-        else:
-            droppedrsp = http.Response(('HTTP/1.1 200 OK\r\n'
-                                        'Connection: close\r\n'
-                                        'Cache-control: no-cache\r\n'
-                                        'Pragma: no-cache\r\n'
-                                        'Cache-control: no-store\r\n'
-                                        'X-Frame-Options: DENY\r\n\r\n'))
-            self.transport.write(droppedrsp.full_message)
-        self.log("Response sent back, losing connection")
-        self.transport.loseConnection()
-
-    def send_error_back(self, failure):
-        errorrsp = http.Response(('HTTP/1.1 200 OK\r\n'
-                                  'Connection: close\r\n'
-                                  'Cache-control: no-cache\r\n'
-                                  'Pragma: no-cache\r\n'
-                                  'Cache-control: no-store\r\n'
-                                  'X-Frame-Options: DENY\r\n'
-                                  'Content-Length: %d\r\n\r\n'
-                                  '%s') % (len(str(failure.getErrorMessage())), str(failure.getErrorMessage())))
-        self.transport.write(errorrsp.full_message)
-        self.log("Error response sent back, losing connection")
-        self.transport.loseConnection()
-        
-    def connectionMade(self):
-        if self.factory.force_ssl:
-            self._start_tls(self.factory.forward_host)
-                
-    def connectionLost(self, reason):
-        self.log('Connection lost with browser: %s' % reason.getErrorMessage())
-        
-        
-class ServerTLSContext(ssl.ContextFactory):
-    def __init__(self, private_key, certificate):
-        self.private_key = private_key
-        self.certificate = certificate
-        self.sslmethod = SSL.TLSv1_METHOD
-        self.cacheContext()
-
-    def cacheContext(self):
-        ctx = SSL.Context(self.sslmethod)
-        ctx.use_certificate(self.certificate)
-        ctx.use_privatekey(self.private_key)
-        self._context = ctx
-   
-    def __getstate__(self):
-        d = self.__dict__.copy()
-        del d['_context']
-        return d
-   
-    def __setstate__(self, state):
-        self.__dict__ = state
-        self.cacheContext()
-   
-    def getContext(self):
-        """Create an SSL context.
-        """
-        return self._context
-
-        
 def generate_cert_serial():
     # Generates a random serial to be used for the cert
     return random.getrandbits(8*20)
@@ -718,6 +124,27 @@ def generate_cert(hostname, cert_dir):
 
     return (key, cert)
 
+def generate_tls_context(cert_host):
+    from pappyproxy.pappy import session
+
+    # Generate a cert for the hostname and start tls
+    host = cert_host
+    cn_host = get_most_general_cn(host)
+    if not host in cached_certs:
+        log("Generating cert for '%s'" % cn_host,
+            verbosity_level=3)
+        (pkey, cert) = generate_cert(cn_host,
+                                     session.config.cert_dir)
+        cached_certs[cn_host] = (pkey, cert)
+    else:
+        log("Using cached cert for %s" % cn_host, verbosity_level=3)
+        (pkey, cert) = cached_certs[cn_host]
+    ctx = ServerTLSContext(
+        private_key=pkey,
+        certificate=cert,
+    )
+    return ctx
+
 
 def generate_ca_certs(cert_dir):
     from pappyproxy.pappy import session
@@ -761,4 +188,458 @@ def generate_ca_certs(cert_dir):
     with os.fdopen(os.open(cert_dir+'/'+session.config.ssl_ca_file, os.O_WRONLY | os.O_CREAT, 0o0600), 'w') as f:
         f.write(crypto.dump_certificate(crypto.FILETYPE_PEM, cert))
     print "Done!"
+    
+def make_proxied_connection(protocol_factory, target_host, target_port, use_ssl,
+                            socks_config=None, log_id=None, http_error_transport=None):
+    from twisted.internet.endpoints import SSL4ClientEndpoint, TCP4ClientEndpoint
+    from txsocksx.client import SOCKS5ClientEndpoint
+    from txsocksx.tls import TLSWrapClientEndpoint
+    from pappyproxy.pappy import session
+
+    if socks_config is not None:
+        log("Connecting to socks proxy", id=log_id)
+        sock_host = socks_config['host']
+        sock_port = int(socks_config['port'])
+        methods = {'anonymous': ()}
+        if 'username' in socks_config and 'password' in socks_config:
+            methods['login'] = (socks_config['username'], socks_config['password'])
+        tcp_endpoint = TCP4ClientEndpoint(reactor, sock_host, sock_port)
+        socks_endpoint = SOCKS5ClientEndpoint(target_host, target_port, tcp_endpoint, methods=methods)
+        if use_ssl:
+            log("Using SSL over proxy to connect to %s:%d ssl=%s" % (target_host, target_port, use_ssl), id=log_id)
+            endpoint = TLSWrapClientEndpoint(ssl.ClientContextFactory(), socks_endpoint)
+        else:
+            log("Using TCP over proxy to connect to %s:%d ssl=%s" % (target_host, target_port, use_ssl), id=log_id)
+            endpoint = socks_endpoint
+    else:
+        log("Connecting directly to host", id=log_id)
+        if use_ssl:
+            log("Using SSL to connect to %s:%d ssl=%s" % (target_host, target_port, use_ssl), id=log_id)
+            #context = BrowserLikePolicyForHTTPS().creatorForNetloc(target_host, target_port)
+            context = ssl.ClientContextFactory()
+            endpoint = SSL4ClientEndpoint(reactor, target_host, target_port, context)
+        else:
+            log("Using TCP to connect to %s:%d ssl=%s" % (target_host, target_port, use_ssl), id=log_id)
+            endpoint = TCP4ClientEndpoint(reactor, target_host, target_port)
+
+    connection_deferred = endpoint.connect(protocol_factory)
+    if http_error_transport:
+        connection_deferred.addErrback(connection_error_http_response,
+                                       http_error_transport, log_id)
+        
+def connection_error_http_response(error, transport, log_id):
+    from .http import Response
+    from .util import html_escape
+    rsp = Response(('HTTP/1.1 200 OK\r\n'
+                    'Connection: close\r\n'
+                    'Cache-control: no-cache\r\n'
+                    'Pragma: no-cache\r\n'
+                    'Cache-control: no-store\r\n'
+                    'X-Frame-Options: DENY\r\n\r\n'))
+    rsp.body = ('<html><head><title>Pappy Error</title></head>'
+                '<body>'
+                '<h1>Pappy Error</h1><h2>Pappy could not connect to the remote host:</h2><p>{0}</p>'
+                '</body>'
+                '</html>').format(html_escape(error.getErrorMessage()))
+    log("Error connecting to remote host. Sending error response.", id=log_id,
+        verbosity_level=3)
+    log("pc< %s" % rsp.full_message, id=log_id, verbosity_level=3)
+    transport.write(rsp.full_message)
+
+def get_http_proxy_addr():
+    """
+    Returns the main session's 
+    """
+    from pappyproxy import pappy
+
+    if not pappy.session.config.http_proxy:
+        return None
+    host = pappy.session.config.http_proxy['host']
+    port = pappy.session.config.http_proxy['port']
+    return (host, port)
+
+def start_maybe_tls(transport, tls_host, start_tls_callback=None):
+    
+    newprot = MaybeTLSProtocol(transport.protocol,
+            tls_host=tls_host,
+            start_tls_callback=start_tls_callback)
+    newprot.transport = transport
+    transport.protocol = newprot
+
+class ServerTLSContext(ssl.ContextFactory):
+    def __init__(self, private_key, certificate):
+        self.private_key = private_key
+        self.certificate = certificate
+        self.sslmethod = SSL.TLSv1_METHOD
+        self.cacheContext()
+
+    def cacheContext(self):
+        ctx = SSL.Context(self.sslmethod)
+        ctx.use_certificate(self.certificate)
+        ctx.use_privatekey(self.private_key)
+        self._context = ctx
+   
+    def __getstate__(self):
+        d = self.__dict__.copy()
+        del d['_context']
+        return d
+   
+    def __setstate__(self, state):
+        self.__dict__ = state
+        self.cacheContext()
+   
+    def getContext(self):
+        """Create an SSL context.
+        """
+        return self._context
+
+
+class ProtocolProxy(object):
+    """
+    A base object to be used to implement a proxy for an object.
+    Responsible for taking in data from the client and the server.
+    Base class contains minimum for the protocol to hook into the
+    listener.
+    """
+
+    def __init__(self):
+        self.client_transport = None
+        self.client_connected = False
+        self.client_buffer = ''
+        self.client_start_tls = False
+        self.client_protocol = None
+
+        self.server_transport = None
+        self.server_connected = False
+        self.server_buffer = ''
+        self.server_start_tls = False
+        self.server_protocol = None
+
+        self.conn_host = None
+        self.conn_port = None
+        self.conn_is_ssl = None
+        self.connection_id = get_next_connection_id()
+
+    def log(self, message, symbol='*', verbosity_level=3):
+        if self.client_protocol:
+            log(message, id=self.connection_id, symbol=symbol, verbosity_level=verbosity_level)
+        else:
+            log(message, symbol=symbol, verbosity_level=verbosity_level)
+
+    def connect(self, host, port, use_ssl, use_socks=False):
+        from pappyproxy.pappy import session
+
+        self.connecting = True
+        self.log("Connecting to %s:%d ssl=%s" % (host, port, use_ssl))
+        factory = PassthroughProtocolFactory(self.server_data_received,
+                                             self.server_connection_made,
+                                             self.server_connection_lost)
+        self.conn_host = host
+        self.conn_port = port
+        self.conn_is_ssl = use_ssl
+        if use_socks:
+            socks_config = session.config.socks_proxy
+        else:
+            socks_config = None
 
+        make_proxied_connection(factory, host, port, use_ssl, socks_config=socks_config,
+                                log_id=self.connection_id, http_error_transport=self.client_transport)
+
+    ## Client interactions
+
+    def send_client_data(self, data):
+        self.log("pc< %s" % short_data(data))
+        if self.client_connected:
+            self.client_transport.write(data)
+        else:
+            self.client_buffer += data
+
+    def client_connection_made(self, protocol):
+        self.client_transport = self.client_protocol.transport
+        self.client_connected = True
+        self.connecting = False
+
+        if self.client_start_tls:
+            self.start_client_tls()
+        if self.client_buffer != '':
+            self.client_transport.write(self.client_buffer)
+            self.client_buffer = ''
+
+    def client_connection_lost(self, reason):
+        self.client_connected = False
+
+    def add_client_data(self, data):
+        """
+        Called when data is received from the client.
+        """
+        pass
+
+    def start_server_tls(self):
+        if self.server_connected:
+            self.log("Starting TLS on server transport")
+            self.server_transport.startTLS(ssl.ClientContextFactory())
+        else:
+            self.log("Server not yet connected, will start TLS on connect")
+            self.start_server_tls = True
+
+    def start_client_maybe_tls(self, cert_host):
+        ctx = generate_tls_context(cert_host)
+        start_maybe_tls(self.client_transport,
+                tls_host=cert_host,
+                start_tls_callback=self.start_server_tls)
+
+    def start_client_tls(self, cert_host):
+        if self.client_connected:
+            self.log("Starting TLS on client transport")
+            ctx = generate_tls_context(cert_host)
+            self.client_transport.startTLS(ctx)
+        else:
+            self.log("Client not yet connected, will start TLS on connect")
+            self.start_client_tls = True
+
+    ## Server interactions
+
+    def send_server_data(self, data):
+        if self.server_connected:
+            self.log("ps> %s" % short_data(data))
+            self.server_transport.write(data)
+        else:
+            self.log("Buffering...")
+            self.log("pb> %s" % short_data(data))
+            self.server_buffer += data
+
+    def server_connection_made(self, protocol):
+        """
+        self.server_protocol must be set before calling
+        """
+        self.log("Connection made")
+        self.server_protocol = protocol
+        self.server_transport = protocol.transport
+        self.server_connected = True
+
+        if self.server_start_tls:
+            self.start_server_tls()
+        if self.server_buffer != '':
+            self.log("Writing buffer to server")
+            self.log("ps> %s" % short_data(self.server_buffer))
+            self.server_transport.write(self.server_buffer)
+            self.server_buffer = ''
+
+    def server_connection_lost(self, reason):
+        self.server_connected = False
+
+    def add_server_data(self, data):
+        """
+        Called when data is received from the server.
+        """
+        pass
+
+    def close_server_connection(self):
+        if self.server_transport:
+            self.log("Manually closing server connection")
+            self.server_transport.loseConnection()
+            self.server_transport = None
+            self.server_connected = False
+            self.server_buffer = ''
+            self.server_protocol = None
+
+    def close_client_connection(self):
+        if self.client_transport:
+            self.log("Manually closing client connection")
+            self.client_transport.loseConnection()
+            self.client_transport = None
+            self.client_connected = False
+            self.client_buffer = ''
+            self.client_protocol = None
+
+    def close_connections(self):
+        self.close_server_connection()
+        self.close_client_connection()
+        
+
+class PassthroughProtocolFactory(ClientFactory):
+
+    def __init__(self,
+                 data_callback,
+                 connection_made_callback,
+                 connection_lost_callback):
+        self.data_callback = data_callback
+        self.connection_made_callback = connection_made_callback
+        self.connection_lost_callback = connection_lost_callback
+        self.protocol = None
+
+    def buildProtocol(self, addr):
+        prot = PassthroughProtocol(self.data_callback,
+                                   self.connection_made_callback,
+                                   self.connection_lost_callback)
+        self.protocol = prot
+        prot.factory = self
+        log("addr: %s" % str(addr))
+        return prot
+        
+    def clientConnectionFailed(self, connector, reason):
+        pass
+        
+    def clientConnectionLost(self, connector, reason):
+        pass
+        
+class PassthroughProtocol(Protocol):
+    """
+    A protocol that makes a connection to a remote server and makes callbacks to
+    functions to handle network events
+    """
+    def __init__(self, data_callback, connection_made_callback, connection_lost_callback):
+        self.data_callback = data_callback
+        self.connection_made_callback = connection_made_callback
+        self.connection_lost_callback = connection_lost_callback
+        self.connected = False
+
+    def dataReceived(self, data):
+        self.data_callback(data)
+
+    def connectionMade(self):
+        self.connected = True
+        self.connection_made_callback(self)
+
+    def connectionLost(self, reason):
+        self.connected = False
+        self.connection_lost_callback(reason)
+
+class ProxyProtocolFactory(ServerFactory):
+
+    next_int_macro_id = 0
+
+    def __init__(self):
+        self._int_macros = {}
+        self._macro_order = []
+        self._macro_names = {}
+
+    def add_intercepting_macro(self, macro, name=None):
+        new_id = self._get_int_macro_id()
+        self._int_macros[new_id] = macro
+        self._macro_order.append(new_id)
+        self._macro_names[new_id] = name
+
+    def remove_intercepting_macro(self, macro_id=None, name=None):
+        if macro_id is None and name is None:
+            raise PappyException("Either macro_id or name must be given")
+
+        ids_to_remove = []
+        if macro_id:
+            ids_to_remove.append(macro_id)
+        if name:
+            for k, v in self._macro_names.iteritems():
+                if v == name:
+                    ids_to_remove.append(k)
+
+        for i in ids_to_remove:
+            if i in self._macro_order:
+                self._macro_order.remove(i)
+            if i in self._macro_names:
+                del self._macro_names[i]
+            if i in self._int_macros:
+                del self._int_macros[i]
+
+    def get_macro_list(self):
+        return [self._int_macros[i] for i in self._macro_order]
+
+    @staticmethod
+    def _get_int_macro_id():
+        i = ProxyProtocolFactory.next_int_macro_id
+        ProxyProtocolFactory.next_int_macro_id += 1
+        return i
+    
+    def buildProtocol(self, addr):
+        prot = ProxyProtocol()
+        prot.factory = self
+        return prot
+
+class ProxyProtocol(Protocol):
+    """
+    The protocol hooked on to a listening port.
+    """
+
+    protocol = "http"
+
+    def __init__(self):
+        from pappyproxy.http import HTTPProtocolProxy
+        self.protocol_proxy = HTTPProtocolProxy()
+        self.protocol_proxy.client_protocol = self
+
+    def dataReceived(self, data):
+        self.protocol_proxy.client_data_received(data)
+
+    def connectionMade(self):
+        self.protocol_proxy.client_connection_made(self)
+
+    def connectionLost(self, reason):
+        self.protocol_proxy.client_connection_lost(reason)
+
+class MaybeTLSProtocol(Protocol):
+    """
+    A protocol that wraps another protocol and will guess whether the incoming
+    data is TLS and if it is, attempts to strip the TLS before passing it to
+    the protocol
+    """
+
+    STATE_DECIDING = 0
+    STATE_PASSTHROUGH = 1
+
+    def __init__(self, protocol, tls_host, start_tls_callback=None):
+        self.protocol = protocol
+        self.state = MaybeTLSProtocol.STATE_DECIDING
+        self._data_buffer = ''
+        self.start_tls_callback = start_tls_callback
+        self.tls_host = tls_host
+
+    def log(self, message, symbol='*', verbosity_level=3):
+        if hasattr(self, "connection_id"):
+            log(message, id=self.connection_id, symbol=symbol, verbosity_level=verbosity_level)
+        else:
+            log(message, symbol=symbol, verbosity_level=verbosity_level)
+
+    def decide_plaintext(self):
+        self.protocol.dataReceived(self._data_buffer)
+        self._data_buffer = ''
+        self.state = MaybeTLSProtocol.STATE_PASSTHROUGH
+
+    def decide_tls(self):
+        # Store the original transport. I think that startTLS changes self.transport
+        transport = self.transport
+
+        # Calling startTLS wraps whatever protocol is currently associated with the
+        # transport in another protocol that handles TLS. We want to send the data
+        # we already received to that protocol since the data we received is part
+        # of the TLS handshake
+        self.transport.startTLS(generate_tls_context(self.tls_host))
+        transport.protocol.dataReceived(self._data_buffer)
+
+        # The TLS protocol wrapper will send us the decrypted data so we should go
+        # into passthrough mode
+        self._data_buffer = ''
+        self.state = MaybeTLSProtocol.STATE_PASSTHROUGH
+
+        # Make the callback
+        if self.start_tls_callback is not None:
+            self.start_tls_callback()
+
+    def guess_if_tls(self):
+        if self._data_buffer == '':
+            return
+
+        # Is the first byte the byte of a ClientHello?
+        if ord(self._data_buffer[0]) == 0x16:
+            # Yes! Assume TLS
+            self.decide_tls()
+        else:
+            # Nope! It's plaintext
+            self.decide_plaintext()
+
+    def dataReceived(self, data):
+        if self.state == MaybeTLSProtocol.STATE_DECIDING:
+            self._data_buffer += data
+            self.guess_if_tls()
+        elif self.state == MaybeTLSProtocol.STATE_PASSTHROUGH:
+            self.protocol.dataReceived(data)
+        else:
+            raise Exception("Protocol in invalid state")
diff --git a/pappyproxy/schema/schema_8.py b/pappyproxy/schema/schema_8.py
new file mode 100644
index 0000000..e1d2dda
--- /dev/null
+++ b/pappyproxy/schema/schema_8.py
@@ -0,0 +1,39 @@
+from twisted.internet import defer
+
+"""
+Schema v8
+
+Creates a table for saved contexts and for web socket messages. Saved contexts
+are saved as a json list of filter strings.
+"""
+
+update_queries = [
+    """
+    CREATE TABLE saved_contexts (
+        id                INTEGER   PRIMARY KEY  AUTOINCREMENT,
+        context_name      TEXT      UNIQUE,
+        filter_strings    TEXT
+    );
+    """,
+
+    """
+    CREATE TABLE websocket_messages (
+        id                INTEGER   PRIMARY KEY  AUTOINCREMENT,
+        parent_request    INTEGER   REFERENCES requests(id),
+        unmangled_id      INTEGER   REFERENCES websocket_messages(id),
+        is_binary         INTEGER,
+        direction         INTEGER,
+        time_sent         REAL,
+        contents          BLOB
+    );
+    """,
+
+    """
+    UPDATE schema_meta SET version=8;
+    """
+]
+
+@defer.inlineCallbacks
+def update(dbpool):
+    for query in update_queries:
+        yield dbpool.runQuery(query)
diff --git a/pappyproxy/templates/macro_resubmit.py.template b/pappyproxy/templates/macro_resubmit.py.template
index 27037e6..c96e99d 100644
--- a/pappyproxy/templates/macro_resubmit.py.template
+++ b/pappyproxy/templates/macro_resubmit.py.template
@@ -1,34 +1,29 @@
 import sys
 {% include 'macroheader.py.template' %}
+from pappyproxy.http import submit_requests
 
 def run_macro(args):
     # Get IDs of in-context requests
     reqids = main_context_ids()
     reqids.reverse() # Resubmit earliest first
-    reqs = []
-
-    # Create session jar (uncomment jar functions to use)
-    #jar = Session() # Create a cookie jar
 
     # Iterate over each request and submit it
+    to_submit = []
     for rid in reqids:
-        print rid,
-        sys.stdout.flush()
-        r = request_by_id(rid)
-        r = r.copy()
-
-        #jar.apply_req(r) # Apply headers/cookies from the cookie jar
+        req = request_by_id(rid).copy()
 
-        #####################
-        # Modify request here
+        ###################
+        # Modify `req` here
         
-        r.submit()
-        #jar.save_rsp(r.response, save_all=True) # Update the cookie jar from the response
-
-        #r.save() # Save the request to the data file
-        reqs.append(r)
-
-    print ''
-
-    # Store the requests in memory
-    set_tag('resubmit', reqs)
+        req.tags.add('resubmit')
+        to_submit.append(req)
+        
+    #############################
+    # Modify resubmit params here
+    submit_requests(to_submit,
+                    mangle=False,
+                    save=False,
+                    save_in_mem=False,
+                    unique_paths=False,
+                    unique_paths_and_args=False,
+    )
diff --git a/pappyproxy/tests/test_http.py b/pappyproxy/tests/test_http.py
index 1012d02..3b6f54e 100644
--- a/pappyproxy/tests/test_http.py
+++ b/pappyproxy/tests/test_http.py
@@ -24,12 +24,15 @@ def by_lines_and_full_helper(Type, id_attr, load_func, header_lines, data=''):
     #  after calling update() on it,
     #  created by serializing and unserializing to json)
     
+    print '-'*30
     t_lines = Type()
-    for l in header_lines:
-        t_lines.add_line(l)
+    t_lines.add_data('\r\n'.join(header_lines) + '\r\n')
+    # for l in header_lines:
+    #     t_lines.add_line(l)
 
     if data:
         t_lines.add_data(data)
+    print '-'*30
 
     t_fulls = '\r\n'.join(header_lines)+'\r\n'
     t_fulls += data
@@ -396,10 +399,10 @@ def test_message_build():
            'Content-Length: 100\r\n\r\n')
     raw += 'A'*100
     m = http.HTTPMessage()
-    m.add_line('foobar')
-    m.add_line('a: b')
-    m.add_line('Content-Length: 100')
-    m.add_line('')
+    m.add_data('foobar\r\n')
+    m.add_data('a: b\r\n')
+    m.add_data('Content-Length: 100\r\n')
+    m.add_data('\r\n')
     assert not m.complete
     m.add_data('A'*50)
     assert not m.complete
@@ -421,10 +424,10 @@ def test_message_build_chunked():
            'Content-Length: 100\r\n\r\n')
     raw += 'A'*100
     m = http.HTTPMessage()
-    m.add_line('foobar')
-    m.add_line('a: b')
-    m.add_line('Transfer-Encoding: chunked')
-    m.add_line('')
+    m.add_data('foobar\r\n')
+    m.add_data('a: b\r\n')
+    m.add_data('Transfer-Encoding: chunked\r\n')
+    m.add_data('\r\n')
     assert not m.complete
     m.add_data('%x\r\n' % 50)
     m.add_data('A'*50)
@@ -588,7 +591,7 @@ def test_headers_end():
     ]
     r = http.Request()
     for l in header_lines:
-        r.add_line(l)
+        r.add_data(l+'\r\n')
     assert not r.complete
     assert r.headers_complete
     
@@ -761,17 +764,18 @@ def test_request_update_content_length():
                       'Content-Length: 4\r\n\r\n'
                       'AAAAAAAAAA'), update_content_length=True)
 
+    assert r.complete
     assert r.full_request == (('GET / HTTP/1.1\r\n'
                                'Content-Length: 10\r\n\r\n'
                                'AAAAAAAAAA'))
     
 def test_request_blank_url_params():
     r = http.Request()
-    r.add_line('GET /this/??-asdf/ HTTP/1.1')
+    r.add_data('GET /this/??-asdf/ HTTP/1.1\r\n')
     assert r.full_request == ('GET /this/??-asdf/ HTTP/1.1\r\n\r\n')
 
     r = http.Request()
-    r.add_line('GET /this/??-asdf/?a=b&c&d=ef HTTP/1.1')
+    r.add_data('GET /this/??-asdf/?a=b&c&d=ef HTTP/1.1\r\n')
     assert r.full_request == ('GET /this/??-asdf/?a=b&c&d=ef HTTP/1.1\r\n\r\n')
     assert r.url_params['?-asdf/?a'] == 'b'
     assert r.url_params['c'] == None
@@ -784,26 +788,26 @@ def test_request_blank():
 def test_request_blank_headers():
     r = http.Request(('GET / HTTP/1.1\r\n'
                       'Header: \r\n'
-                      'Header2:\r\n'))
+                      'Header2:\r\n\r\n'))
 
     assert r.headers['header'] == ''
     assert r.headers['header2'] == ''
     
 def test_request_blank_cookies():
     r = http.Request(('GET / HTTP/1.1\r\n'
-                      'Cookie: \r\n'))
+                      'Cookie: \r\n\r\n'))
     assert r.cookies[''] == ''
 
     r = http.Request(('GET / HTTP/1.1\r\n'
-                      'Cookie: a=b; ; c=d\r\n'))
+                      'Cookie: a=b; ; c=d\r\n\r\n'))
     assert r.cookies[''] == ''
 
     r = http.Request(('GET / HTTP/1.1\r\n'
-                      'Cookie: a=b; foo; c=d\r\n'))
+                      'Cookie: a=b; foo; c=d\r\n\r\n'))
     assert r.cookies['foo'] == ''
 
 def test_request_set_url():
-    r = http.Request('GET / HTTP/1.1\r\n')
+    r = http.Request('GET / HTTP/1.1\r\n\r\n')
     r.url = 'www.AAAA.BBBB'
     assert r.host == 'www.AAAA.BBBB'
     assert r.port == 80
@@ -830,7 +834,7 @@ def test_request_set_url():
     assert r.is_ssl
     
 def test_request_set_url_params():
-    r = http.Request('GET / HTTP/1.1\r\n')
+    r = http.Request('GET / HTTP/1.1\r\n\r\n')
     r.url = 'www.AAAA.BBBB?a=b&c=d#foo'
     assert r.url_params.all_pairs() == [('a','b'), ('c','d')]
     assert r.fragment == 'foo'
@@ -889,13 +893,16 @@ def test_request_absolute_url():
     r = http.Request(('GET /foo/path HTTP/1.1\r\n'
                       'Host: www.example.faketld\r\n\r\n'))
     assert r.full_message == ('GET /foo/path HTTP/1.1\r\n'
-                              'Host: www.example.faketld\r\n\r\n')
+                              'Host: www.example.faketld\r\n'
+                              '\r\n')
     r.path_type = http.PATH_ABSOLUTE
     assert r.full_message == ('GET http://www.example.faketld/foo/path HTTP/1.1\r\n'
-                              'Host: www.example.faketld\r\n\r\n')
+                              'Host: www.example.faketld\r\n'
+                              '\r\n')
     r.is_ssl = True
     assert r.full_message == ('GET https://www.example.faketld/foo/path HTTP/1.1\r\n'
-                              'Host: www.example.faketld\r\n\r\n')
+                              'Host: www.example.faketld\r\n'
+                              '\r\n')
 
 def test_proxy_auth():
     r = http.Request(('GET /foo/path HTTP/1.1\r\n'
@@ -1075,9 +1082,9 @@ def test_response_chunked_gzip():
 def test_response_early_completion():
     r = http.Response()
     r.start_line = 'HTTP/1.1 200 OK'
-    r.add_line('Content-Length: 0')
+    r.add_data('Content-Length: 0\r\n')
     assert not r.complete
-    r.add_line('')
+    r.add_data('\r\n')
     assert r.complete
 
 def test_response_cookies():
@@ -1117,6 +1124,7 @@ def test_response_repeated_cookies():
                        'Set-Cookie: foo=buzz\r\n'
                        '\r\n'))
     expected_pairs = [('foo', 'bar'), ('baz', 'buzz'), ('foo', 'buzz')]
+    assert r.complete
     check_response_cookies(expected_pairs, r)
 
 def test_repeated_response_headers():
@@ -1175,6 +1183,7 @@ def test_response_update_modified_headers():
                                'content-length: 4\r\n\r\n'
                                'AAAA')
     assert r.headers['content-length'] == '4'
+    assert r.complete
 
 def test_response_update_cookies():
     r = http.Response()
@@ -1204,6 +1213,7 @@ def test_response_update_content_length():
                        'Content-Length: 4\r\n\r\n'
                        'AAAAAAAAAA'), update_content_length=True)
 
+    assert r.complete
     assert r.full_response == (('HTTP/1.1 200 OK\r\n'
                                'Content-Length: 10\r\n\r\n'
                                'AAAAAAAAAA'))
@@ -1273,7 +1283,7 @@ def test_response_blank():
 def test_response_blank_headers():
     r = http.Response(('HTTP/1.1 200 OK\r\n'
                       'Header: \r\n'
-                      'Header2:\r\n'))
+                      'Header2:\r\n\r\n'))
 
     assert r.headers['header'] == ''
     assert r.headers['header2'] == ''
@@ -1311,7 +1321,7 @@ def test_response_add_cookie():
 
 def test_response_set_cookie():
     r = http.Response(('HTTP/1.1 200 OK\r\n'
-                       'Content-Length: 0\r\n'))
+                       'Content-Length: 0\r\n\r\n'))
     r.set_cookie(http.ResponseCookie('foo=bar'))
     assert r.full_response == ('HTTP/1.1 200 OK\r\n'
                                'Content-Length: 0\r\n'
@@ -1344,3 +1354,4 @@ def test_response_short_statusline():
     assert r.response_text == ''
     assert r.version == 'HTTP/1.1'
     assert r.response_code == 407
+
diff --git a/pappyproxy/util.py b/pappyproxy/util.py
index b761a1c..afa1f27 100644
--- a/pappyproxy/util.py
+++ b/pappyproxy/util.py
@@ -1,5 +1,6 @@
 import StringIO
 import datetime
+import hashlib
 import re
 import string
 import sys
@@ -34,6 +35,11 @@ class PappyStringTransport(StringTransport):
     def finish(self):
         # Called when a finishable producer finishes
         self.producerState = 'stopped'
+
+    def pop_value(self):
+        v = self.value()
+        self.clear()
+        return v
         
     def registerProducer(self, producer, streaming):
         StringTransport.registerProducer(self, producer, streaming)
@@ -43,13 +49,14 @@ class PappyStringTransport(StringTransport):
             self.producer.resumeProducing()
 
     def loseConnection(self):
-        StringTransport.loseconnection(self)
+        assert False
+        StringTransport.loseConnection(self)
         self.complete_deferred.callback(None)
 
     def startTLS(self, context, factory):
         pass
 
-def printable_data(data):
+def printable_data(data, colors=True):
     """
     Return ``data``, but replaces unprintable characters with periods.
 
@@ -61,15 +68,17 @@ def printable_data(data):
     colored = False
     for c in data:
         if c in string.printable:
-            if colored:
+            if colored and colors:
                 chars.append(Colors.ENDC)
-                colored = False
+            colored = False
             chars.append(c)
         else:
-            if not colored:
+            if (not colored) and colors:
                 chars.append(Styles.UNPRINTABLE_DATA)
-                colored = True
+            colored = True
             chars.append('.')
+    if colors:
+        chars.append(Colors.ENDC)
     return ''.join(chars)
 
 def remove_color(s):
@@ -93,6 +102,11 @@ def hexdump(src, length=16):
         lines.append("%04x  %-*s  %s\n" % (c, length*3, hex, printable))
     return ''.join(lines)
 
+def maybe_hexdump(s):
+    if any(c not in string.printable for c in s):
+        return hexdump(s)
+    return s
+
 # Taken from http://stackoverflow.com/questions/16571150/how-to-capture-stdout-output-from-a-python-function-call
 # then modified
 class Capturing():
@@ -356,3 +370,40 @@ def autocomplete_startswith(text, lst, allow_spaces=False):
         ret = [s for s in ret if ' ' not in s]
     return ret
     
+def short_data(data):
+    l = 1024
+    if len(data) > l:
+        return printable_data(data[:l], colors=False)
+    else:
+        return printable_data(data, colors=False)
+
+def print_traceback():
+    import traceback; print '\n'.join([l.strip() for l in traceback.format_stack()])
+
+def traceback_on_call(obj, func):
+    old = getattr(obj, func)
+    def patched(*args, **kwargs):
+        print_traceback()
+        old(*args, **kwargs)
+    setattr(obj, func, patched)
+
+def sha1(data):
+    m = hashlib.sha1()
+    m.update(data)
+    return m.digest()
+
+def datetime_string(dt):
+    dtobj = utc2local(dt)
+    time_made_str = dtobj.strftime('%a, %b %d, %Y, %I:%M:%S.%f %p')
+    return time_made_str
+
+def html_escape(s, quote=None):
+    '''Replace special characters "&", "<" and ">" to HTML-safe sequences.
+    If the optional flag quote is true, the quotation mark character (")
+is also translated.'''
+    s = s.replace("&", "&amp;") # Must be done first!
+    s = s.replace("<", "&lt;")
+    s = s.replace(">", "&gt;")
+    if quote:
+        s = s.replace('"', "&quot;")
+    return s
diff --git a/setup.py b/setup.py
index 9a6d14c..54077e2 100755
--- a/setup.py
+++ b/setup.py
@@ -22,6 +22,7 @@ setup(name='pappyproxy',
       keywords='http proxy hacking 1337hax pwnurmum',
       download_url='https://github.com/roglew/pappy-proxy/archive/%s.tar.gz'%VERSION,
       install_requires=[
+          'autobahn>=0.16.0',
           'beautifulsoup4>=4.4.1',
           'cmd2>=0.6.8',
           'crochet>=1.4.0',
@@ -30,10 +31,11 @@ setup(name='pappyproxy',
           'lxml>=3.6.0',
           'pygments>=2.0.2',
           'pyperclip>=1.5.26',
-          'pytest-cov>=2.2.0',
-          'pytest-mock>=0.9.0',
-          'pytest-twisted>=1.5',
-          'pytest>=2.8.3',
+          # Uncomment if you need to run unit tests
+          # 'pytest-cov>=2.2.0',
+          # 'pytest-mock>=0.9.0',
+          # 'pytest-twisted>=1.5',
+          # 'pytest>=2.8.3',
           'scrypt>=0.7.1',
           'service_identity>=14.0.0',
           'twisted>=15.4.0',
diff --git a/websockets.org b/websockets.org
new file mode 100644
index 0000000..179eb4b
--- /dev/null
+++ b/websockets.org
@@ -0,0 +1,14 @@
+* Todo
+** DONE Modify schema to save websocket sessions
+** DONE OTHER: Modify schema to save saved contexts
+** DONE Save saved contexts to data file
+** TODO Add websocket classes to Request object
+*** TODO include in JSON
+** TODO Add console commands to view websocket communications
+*** TODO ls-type command
+*** TODO Add websocket info to viq
+** TODO Implement websocket saving/loading
+** TODO Add websocket data loading to request object
+** TODO Wedge websocket parser/saver into http proxy
+** TODO Implement websocket mangling macros
+** TODO Implement injecting into existing websocket streams