diff --git a/.gitignore b/.gitignore
index 8c21cd4..1485a6d 100644
--- a/.gitignore
+++ b/.gitignore
@@ -5,5 +5,5 @@
 dist/
 docs/_build/doctrees/*
 huTools.egg-info/
-testenv/
+pythonenv/
 build/
diff --git a/Makefile b/Makefile
index ff45647..0aa1d23 100644
--- a/Makefile
+++ b/Makefile
@@ -1,5 +1,5 @@
 # setting the PATH seems only to work in GNUmake not in BSDmake
-PATH := ./testenv/bin:$(PATH)
+PATH := ./pythonenv/bin:$(PATH)
 
 default: dependencies check test examples
 
@@ -16,18 +16,20 @@ check:
 	-/usr/local/hudorakit/bin/hd_pylint huTools
 
 test:
-	PYTHONPATH=. python huTools/NetStringIO.py
-	PYTHONPATH=. python huTools/calendar/formats.py
-	PYTHONPATH=. python huTools/calendar/workdays.py
-	PYTHONPATH=. python huTools/checksumming.py
-	PYTHONPATH=. python huTools/humessaging.py
-	PYTHONPATH=. python huTools/luids.py
-	PYTHONPATH=. python huTools/obfuscation.py
-	PYTHONPATH=. python huTools/unicode.py
+	PYTHONPATH=. ./pythonenv/bin/python huTools/http/test.py
+	PYTHONPATH=. ./pythonenv/bin/python huTools/NetStringIO.py
+	PYTHONPATH=. ./pythonenv/bin/python huTools/calendar/formats.py
+	PYTHONPATH=. ./pythonenv/bin/python huTools/calendar/workdays.py
+	PYTHONPATH=. ./pythonenv/bin/python huTools/checksumming.py
+	PYTHONPATH=. ./pythonenv/bin/python huTools/humessaging.py
+	PYTHONPATH=. ./pythonenv/bin/python huTools/luids.py
+	PYTHONPATH=. ./pythonenv/bin/python huTools/obfuscation.py
+	PYTHONPATH=. ./pythonenv/bin/python huTools/unicode.py
+	PYJASPER_SERVLET_URL=http://127.0.0.1:8000/pyJasper/jasper.py PYTHONPATH=. ./pythonenv/bin/python huTools/pyjasper.py
 
 coverage: dependencies
 	printf '.*/tests/.*\n.*test.py\n' > .figleaf-exclude.txt
-	printf '/usr/local/lib/.*\n/opt/.*\ntestenv/.*\n' >> .figleaf-exclude.txt
+	printf '/usr/local/lib/.*\n/opt/.*\npythonenv/.*\n' >> .figleaf-exclude.txt
 	printf '.*manage.py\n.*settings.py\n.*setup.py\n.*urls.py\n' >> .figleaf-exclude.txt
 	PYTHONPATH=. /usr/local/hudorakit/bin/hd_figleaf --ignore-pylibs huTools/NetStringIO.py
 	PYTHONPATH=. /usr/local/hudorakit/bin/hd_figleaf --ignore-pylibs huTools/ReReadingConfigParser.py
@@ -53,8 +55,8 @@ build: examples
 	python setup.py build
 
 dependencies:
-	virtualenv testenv
-	pip -q install -E testenv -r requirements.txt
+	virtualenv pythonenv
+	pip -q install -E pythonenv -r requirements.txt
 
 statistics:
 	sloccount --wide --details huTools | tee sloccount.sc
@@ -77,7 +79,7 @@ examples: doc/standards/examples/warenzugang.xml doc/standards/examples/kommiauf
 
 
 clean:
-	rm -Rf testenv build dist html test.db pylint.out sloccount.sc pip-log.txt
+	rm -Rf testenv pythonenv build dist html test.db pylint.out sloccount.sc pip-log.txt
 	find . -name '*.pyc' -delete
 
-.PHONY: build clean install upload check doc
+.PHONY: build clean install upload check doc docs test
diff --git a/doc/development.markdown b/doc/development.markdown
index 2bdc858..2f5bb67 100644
--- a/doc/development.markdown
+++ b/doc/development.markdown
@@ -103,7 +103,7 @@ Use global unique identifiers where ever possible. `huTools.luids.guid128()` cre
 * Always test Iñtërnâtiônàlizætiøn by putting strange strings into input fields
 * Always test `<script>alert("XSS");</script> & <bold>Co</bold>` by putting strange strings into input fields
 * use [huTools](http://hudora.github.com/huTools/) where appropriate
-
+* `Iñtërnâtiônàlizætiøn <script>alert("XSS");</script> %+'"<!--` might be a goot test string.
 
 ## Django Specifica
 
diff --git a/doc/standards/examples/wms2logos_kommiauftrag.xml b/doc/standards/examples/wms2logos_kommiauftrag.xml
index 791c7ca..e8c9781 100644
--- a/doc/standards/examples/wms2logos_kommiauftrag.xml
+++ b/doc/standards/examples/wms2logos_kommiauftrag.xml
@@ -10,7 +10,7 @@
       <Liefertermin>20091125</Liefertermin>
       <Terminart>BIS</Terminart>
       <Textcode1>8</Textcode1>
-      <Auftragstext>abholer: Abholung durch Spedition Dornseif$hebebuehne: True$</Auftragstext>
+      <Auftragstext>abholer: Abholung durch Spedition Dornseif$avisieren_unter: +49123456$hebebuehne: True$</Auftragstext>
       <Textcode2>2</Textcode2>
       <Kommissioniertext>etiketten_speicherort: c:\desktop\Programm Data\schrecklicher windows pfad$sortenrein: True$packhoehe: 1100</Kommissioniertext>
       <EmpfaengerILN/>
diff --git a/huTools/http/__init__.py b/huTools/http/__init__.py
new file mode 100644
index 0000000..a3bbfa4
--- /dev/null
+++ b/huTools/http/__init__.py
@@ -0,0 +1,85 @@
+#!/usr/bin/env python
+# encoding: utf-8
+"""
+huTools/http/__init__.py
+
+Provides a simple interface for doing HTTP requests on stock Python and on Google Appengine. Provides
+unicode aware application/x-www-form-urlencoded encoding and an do multipart/form-data (file upload) 
+without aditional code. On Google Appengine it incerass the timeout from 5 seconds to 10.
+
+Usage is without suprises::
+
+    >>> status, header, body = fetch('http://www.postbin.org/o0ds54',
+                                     {'küh': 'Iñtërnâtiônàlizætiøn', 'just a test': 212},
+                                     headers={'X-Foo': 'Bar'})
+
+File Upload just works::
+
+    >>> status, header, body = fetch('http://www.postbin.org/o0ds54',
+                                     {'hosts': open('/etc/hosts', 'r')}, 'POST')
+
+"""
+# Created by Maximillian Dornseif on 2010-10-24.
+# Copyright (c) 2010 HUDORA. All rights reserved.
+
+from huTools.http import tools
+import logging
+import poster_encode
+import urllib
+import urlparse
+
+try:
+    from engine_appengine import request
+except ImportError:
+    from engine_httplib2 import request
+
+
+def fetch(url, content='', method='GET', credentials=None, headers=None, multipart=False):
+    """Does a HTTP request with method `method` to `url`. 
+    
+    Returns (status, headers, content) whereas `status` is an integer status code, `headers` is a dict
+    containing the headers sent by the server and `content` is the body of the http response.
+    
+    Parameters to fetch are::
+    
+    * `url` is the fully qualified request URL. It may contain query prameters.
+    * `content` is the request body to be sent. It may be a dict which for all requests expect POST
+      is converted to query parameters. If there are query parameters already in the `url` they are merged
+      with `content`. For POST requests the data is encoded as application/x-www-form-urlencoded
+      or multipart/form-data and encoded. If the parameter `multipart` is `True` or if one of the values
+      in content has a `name` attribute (which is the case for file objects) multipart encoding is choosen.
+    * `headers` is a dict of header values
+    * `credentials` is reserved for future use
+    """
+
+    if not headers:
+        headers = {}
+    if method == 'POST':
+        if hasattr(content, 'items'):
+            # we assume content is a dict which needs to be encoded
+            # decide to use multipart/form-data encoding or application/x-www-form-urlencoded
+            for v in content.values():
+                if hasattr(v, 'name'):
+                    multipart = True
+            if multipart:
+                datagen, mp_headers = poster_encode.multipart_encode(content)
+                headers.update(mp_headers)
+                content = "".join(datagen)
+            else:
+                headers.update({'content-type': 'application/x-www-form-urlencoded'})
+                content = tools.urlencode(content)
+    else:
+        # url parmater encoding
+        if hasattr(content, 'items'):
+            scheme, netloc, path, params, query, fragment = urlparse.urlparse(url)
+            qdict = urlparse.parse_qs(query)
+            # ugly Unicode issues, see http://bugs.python.org/issue1712522
+            qdict.update(content)
+            query = tools.urlencode(qdict)
+            url = urlparse.urlunparse((scheme, netloc, path, params, query, fragment))
+            content = ''
+    # convert all header values to strings (what about unicode?)
+    for k, v in headers.items():
+        headers[k] = str(v)
+
+    return request(url, method, content, headers)
diff --git a/huTools/http/_httplib2/__init__.py b/huTools/http/_httplib2/__init__.py
new file mode 100644
index 0000000..3cebcb3
--- /dev/null
+++ b/huTools/http/_httplib2/__init__.py
@@ -0,0 +1,1202 @@
+from __future__ import generators
+"""
+httplib2
+
+A caching http interface that supports ETags and gzip
+to conserve bandwidth. 
+
+Requires Python 2.3 or later
+
+Changelog:
+2007-08-18, Rick: Modified so it's able to use a socks proxy if needed.
+
+"""
+
+__author__ = "Joe Gregorio (joe@bitworking.org)"
+__copyright__ = "Copyright 2006, Joe Gregorio"
+__contributors__ = ["Thomas Broyer (t.broyer@ltgt.net)",
+    "James Antill",
+    "Xavier Verges Farrero",
+    "Jonathan Feinberg",
+    "Blair Zajac",
+    "Sam Ruby",
+    "Louis Nyffenegger"]
+__license__ = "MIT"
+__version__ = "$Rev$"
+
+import re 
+import sys 
+import email
+import email.Utils
+import email.Message
+import email.FeedParser
+import StringIO
+import gzip
+import zlib
+import httplib
+import urlparse
+import base64
+import os
+import copy
+import calendar
+import time
+import random
+# remove depracated warning in python2.6
+try:
+    from hashlib import sha1 as _sha, md5 as _md5
+except ImportError:
+    import sha
+    import md5
+    _sha = sha.new
+    _md5 = md5.new
+import hmac
+from gettext import gettext as _
+import socket
+
+try:
+    import socks
+except ImportError:
+    socks = None
+
+# Build the appropriate socket wrapper for ssl
+try:
+    import ssl # python 2.6
+    _ssl_wrap_socket = ssl.wrap_socket
+except ImportError:
+    def _ssl_wrap_socket(sock, key_file, cert_file):
+        ssl_sock = socket.ssl(sock, key_file, cert_file)
+        return httplib.FakeSocket(sock, ssl_sock)
+
+
+if sys.version_info >= (2,3):
+    from iri2uri import iri2uri
+else:
+    def iri2uri(uri):
+        return uri
+
+def has_timeout(timeout): # python 2.6
+    if hasattr(socket, '_GLOBAL_DEFAULT_TIMEOUT'):
+        return (timeout is not None and timeout is not socket._GLOBAL_DEFAULT_TIMEOUT)
+    return (timeout is not None)
+
+__all__ = ['Http', 'Response', 'ProxyInfo', 'HttpLib2Error',
+  'RedirectMissingLocation', 'RedirectLimit', 'FailedToDecompressContent', 
+  'UnimplementedDigestAuthOptionError', 'UnimplementedHmacDigestAuthOptionError',
+  'debuglevel']
+
+
+# The httplib debug level, set to a non-zero value to get debug output
+debuglevel = 0
+
+
+# Python 2.3 support
+if sys.version_info < (2,4):
+    def sorted(seq):
+        seq.sort()
+        return seq
+
+# Python 2.3 support
+def HTTPResponse__getheaders(self):
+    """Return list of (header, value) tuples."""
+    if self.msg is None:
+        raise httplib.ResponseNotReady()
+    return self.msg.items()
+
+if not hasattr(httplib.HTTPResponse, 'getheaders'):
+    httplib.HTTPResponse.getheaders = HTTPResponse__getheaders
+
+# All exceptions raised here derive from HttpLib2Error
+class HttpLib2Error(Exception): pass
+
+# Some exceptions can be caught and optionally 
+# be turned back into responses. 
+class HttpLib2ErrorWithResponse(HttpLib2Error):
+    def __init__(self, desc, response, content):
+        self.response = response
+        self.content = content
+        HttpLib2Error.__init__(self, desc)
+
+class RedirectMissingLocation(HttpLib2ErrorWithResponse): pass
+class RedirectLimit(HttpLib2ErrorWithResponse): pass
+class FailedToDecompressContent(HttpLib2ErrorWithResponse): pass
+class UnimplementedDigestAuthOptionError(HttpLib2ErrorWithResponse): pass
+class UnimplementedHmacDigestAuthOptionError(HttpLib2ErrorWithResponse): pass
+
+class RelativeURIError(HttpLib2Error): pass
+class ServerNotFoundError(HttpLib2Error): pass
+
+# Open Items:
+# -----------
+# Proxy support
+
+# Are we removing the cached content too soon on PUT (only delete on 200 Maybe?)
+
+# Pluggable cache storage (supports storing the cache in
+#   flat files by default. We need a plug-in architecture
+#   that can support Berkeley DB and Squid)
+
+# == Known Issues ==
+# Does not handle a resource that uses conneg and Last-Modified but no ETag as a cache validator.
+# Does not handle Cache-Control: max-stale
+# Does not use Age: headers when calculating cache freshness.
+
+
+# The number of redirections to follow before giving up.
+# Note that only GET redirects are automatically followed.
+# Will also honor 301 requests by saving that info and never
+# requesting that URI again.
+DEFAULT_MAX_REDIRECTS = 5
+
+# Which headers are hop-by-hop headers by default
+HOP_BY_HOP = ['connection', 'keep-alive', 'proxy-authenticate', 'proxy-authorization', 'te', 'trailers', 'transfer-encoding', 'upgrade']
+
+def _get_end2end_headers(response):
+    hopbyhop = list(HOP_BY_HOP)
+    hopbyhop.extend([x.strip() for x in response.get('connection', '').split(',')])
+    return [header for header in response.keys() if header not in hopbyhop]
+
+URI = re.compile(r"^(([^:/?#]+):)?(//([^/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))?")
+
+def parse_uri(uri):
+    """Parses a URI using the regex given in Appendix B of RFC 3986.
+
+        (scheme, authority, path, query, fragment) = parse_uri(uri)
+    """
+    groups = URI.match(uri).groups()
+    return (groups[1], groups[3], groups[4], groups[6], groups[8])
+
+def urlnorm(uri):
+    (scheme, authority, path, query, fragment) = parse_uri(uri)
+    if not scheme or not authority:
+        raise RelativeURIError("Only absolute URIs are allowed. uri = %s" % uri)
+    authority = authority.lower()
+    scheme = scheme.lower()
+    if not path: 
+        path = "/"
+    # Could do syntax based normalization of the URI before
+    # computing the digest. See Section 6.2.2 of Std 66.
+    request_uri = query and "?".join([path, query]) or path
+    scheme = scheme.lower()
+    defrag_uri = scheme + "://" + authority + request_uri
+    return scheme, authority, request_uri, defrag_uri
+
+
+# Cache filename construction (original borrowed from Venus http://intertwingly.net/code/venus/)
+re_url_scheme    = re.compile(r'^\w+://')
+re_slash         = re.compile(r'[?/:|]+')
+
+def safename(filename):
+    """Return a filename suitable for the cache.
+
+    Strips dangerous and common characters to create a filename we
+    can use to store the cache in.
+    """
+
+    try:
+        if re_url_scheme.match(filename):
+            if isinstance(filename,str):
+                filename = filename.decode('utf-8')
+                filename = filename.encode('idna')
+            else:
+                filename = filename.encode('idna')
+    except UnicodeError:
+        pass
+    if isinstance(filename,unicode):
+        filename=filename.encode('utf-8')
+    filemd5 = _md5(filename).hexdigest()
+    filename = re_url_scheme.sub("", filename)
+    filename = re_slash.sub(",", filename)
+
+    # limit length of filename
+    if len(filename)>200:
+        filename=filename[:200]
+    return ",".join((filename, filemd5))
+
+NORMALIZE_SPACE = re.compile(r'(?:\r\n)?[ \t]+')
+def _normalize_headers(headers):
+    return dict([ (key.lower(), NORMALIZE_SPACE.sub(value, ' ').strip())  for (key, value) in headers.iteritems()])
+
+def _parse_cache_control(headers):
+    retval = {}
+    if headers.has_key('cache-control'):
+        parts =  headers['cache-control'].split(',')
+        parts_with_args = [tuple([x.strip().lower() for x in part.split("=", 1)]) for part in parts if -1 != part.find("=")]
+        parts_wo_args = [(name.strip().lower(), 1) for name in parts if -1 == name.find("=")]
+        retval = dict(parts_with_args + parts_wo_args)
+    return retval 
+
+# Whether to use a strict mode to parse WWW-Authenticate headers
+# Might lead to bad results in case of ill-formed header value,
+# so disabled by default, falling back to relaxed parsing.
+# Set to true to turn on, usefull for testing servers.
+USE_WWW_AUTH_STRICT_PARSING = 0
+
+# In regex below:
+#    [^\0-\x1f\x7f-\xff()<>@,;:\\\"/[\]?={} \t]+             matches a "token" as defined by HTTP
+#    "(?:[^\0-\x08\x0A-\x1f\x7f-\xff\\\"]|\\[\0-\x7f])*?"    matches a "quoted-string" as defined by HTTP, when LWS have already been replaced by a single space
+# Actually, as an auth-param value can be either a token or a quoted-string, they are combined in a single pattern which matches both:
+#    \"?((?<=\")(?:[^\0-\x1f\x7f-\xff\\\"]|\\[\0-\x7f])*?(?=\")|(?<!\")[^\0-\x08\x0A-\x1f\x7f-\xff()<>@,;:\\\"/[\]?={} \t]+(?!\"))\"?
+WWW_AUTH_STRICT = re.compile(r"^(?:\s*(?:,\s*)?([^\0-\x1f\x7f-\xff()<>@,;:\\\"/[\]?={} \t]+)\s*=\s*\"?((?<=\")(?:[^\0-\x08\x0A-\x1f\x7f-\xff\\\"]|\\[\0-\x7f])*?(?=\")|(?<!\")[^\0-\x1f\x7f-\xff()<>@,;:\\\"/[\]?={} \t]+(?!\"))\"?)(.*)$")
+WWW_AUTH_RELAXED = re.compile(r"^(?:\s*(?:,\s*)?([^ \t\r\n=]+)\s*=\s*\"?((?<=\")(?:[^\\\"]|\\.)*?(?=\")|(?<!\")[^ \t\r\n,]+(?!\"))\"?)(.*)$")
+UNQUOTE_PAIRS = re.compile(r'\\(.)')
+def _parse_www_authenticate(headers, headername='www-authenticate'):
+    """Returns a dictionary of dictionaries, one dict
+    per auth_scheme."""
+    retval = {}
+    if headers.has_key(headername):
+        authenticate = headers[headername].strip()
+        www_auth = USE_WWW_AUTH_STRICT_PARSING and WWW_AUTH_STRICT or WWW_AUTH_RELAXED
+        while authenticate:
+            # Break off the scheme at the beginning of the line
+            if headername == 'authentication-info':
+                (auth_scheme, the_rest) = ('digest', authenticate)                
+            else:
+                (auth_scheme, the_rest) = authenticate.split(" ", 1)
+            # Now loop over all the key value pairs that come after the scheme, 
+            # being careful not to roll into the next scheme
+            match = www_auth.search(the_rest)
+            auth_params = {}
+            while match:
+                if match and len(match.groups()) == 3:
+                    (key, value, the_rest) = match.groups()
+                    auth_params[key.lower()] = UNQUOTE_PAIRS.sub(r'\1', value) # '\\'.join([x.replace('\\', '') for x in value.split('\\\\')])
+                match = www_auth.search(the_rest)
+            retval[auth_scheme.lower()] = auth_params
+            authenticate = the_rest.strip()
+    return retval
+
+
+def _entry_disposition(response_headers, request_headers):
+    """Determine freshness from the Date, Expires and Cache-Control headers.
+
+    We don't handle the following:
+
+    1. Cache-Control: max-stale
+    2. Age: headers are not used in the calculations.
+
+    Not that this algorithm is simpler than you might think 
+    because we are operating as a private (non-shared) cache.
+    This lets us ignore 's-maxage'. We can also ignore
+    'proxy-invalidate' since we aren't a proxy.
+    We will never return a stale document as 
+    fresh as a design decision, and thus the non-implementation 
+    of 'max-stale'. This also lets us safely ignore 'must-revalidate' 
+    since we operate as if every server has sent 'must-revalidate'.
+    Since we are private we get to ignore both 'public' and
+    'private' parameters. We also ignore 'no-transform' since
+    we don't do any transformations.    
+    The 'no-store' parameter is handled at a higher level.
+    So the only Cache-Control parameters we look at are:
+
+    no-cache
+    only-if-cached
+    max-age
+    min-fresh
+    """
+    
+    retval = "STALE"
+    cc = _parse_cache_control(request_headers)
+    cc_response = _parse_cache_control(response_headers)
+
+    if request_headers.has_key('pragma') and request_headers['pragma'].lower().find('no-cache') != -1:
+        retval = "TRANSPARENT"
+        if 'cache-control' not in request_headers:
+            request_headers['cache-control'] = 'no-cache'
+    elif cc.has_key('no-cache'):
+        retval = "TRANSPARENT"
+    elif cc_response.has_key('no-cache'):
+        retval = "STALE"
+    elif cc.has_key('only-if-cached'):
+        retval = "FRESH"
+    elif response_headers.has_key('date'):
+        date = calendar.timegm(email.Utils.parsedate_tz(response_headers['date']))
+        now = time.time()
+        current_age = max(0, now - date)
+        if cc_response.has_key('max-age'):
+            try:
+                freshness_lifetime = int(cc_response['max-age'])
+            except ValueError:
+                freshness_lifetime = 0
+        elif response_headers.has_key('expires'):
+            expires = email.Utils.parsedate_tz(response_headers['expires'])
+            if None == expires:
+                freshness_lifetime = 0
+            else:
+                freshness_lifetime = max(0, calendar.timegm(expires) - date)
+        else:
+            freshness_lifetime = 0
+        if cc.has_key('max-age'):
+            try:
+                freshness_lifetime = int(cc['max-age'])
+            except ValueError:
+                freshness_lifetime = 0
+        if cc.has_key('min-fresh'):
+            try:
+                min_fresh = int(cc['min-fresh'])
+            except ValueError:
+                min_fresh = 0
+            current_age += min_fresh 
+        if freshness_lifetime > current_age:
+            retval = "FRESH"
+    return retval 
+
+def _decompressContent(response, new_content):
+    content = new_content
+    try:
+        encoding = response.get('content-encoding', None)
+        if encoding in ['gzip', 'deflate']:
+            if encoding == 'gzip':
+                content = gzip.GzipFile(fileobj=StringIO.StringIO(new_content)).read()
+            if encoding == 'deflate':
+                content = zlib.decompress(content)
+            response['content-length'] = str(len(content))
+            # Record the historical presence of the encoding in a way the won't interfere.
+            response['-content-encoding'] = response['content-encoding']
+            del response['content-encoding']
+    except IOError:
+        content = ""
+        raise FailedToDecompressContent(_("Content purported to be compressed with %s but failed to decompress.") % response.get('content-encoding'), response, content)
+    return content
+
+def _updateCache(request_headers, response_headers, content, cache, cachekey):
+    if cachekey:
+        cc = _parse_cache_control(request_headers)
+        cc_response = _parse_cache_control(response_headers)
+        if cc.has_key('no-store') or cc_response.has_key('no-store'):
+            cache.delete(cachekey)
+        else:
+            info = email.Message.Message()
+            for key, value in response_headers.iteritems():
+                if key not in ['status','content-encoding','transfer-encoding']:
+                    info[key] = value
+
+            # Add annotations to the cache to indicate what headers
+            # are variant for this request.
+            vary = response_headers.get('vary', None)
+            if vary:
+                vary_headers = vary.lower().replace(' ', '').split(',')
+                for header in vary_headers:
+                    key = '-varied-%s' % header
+                    try:
+                        info[key] = request_headers[header]
+                    except KeyError:
+                        pass
+
+            status = response_headers.status
+            if status == 304:
+                status = 200
+
+            status_header = 'status: %d\r\n' % response_headers.status
+
+            header_str = info.as_string()
+
+            header_str = re.sub("\r(?!\n)|(?<!\r)\n", "\r\n", header_str)
+            text = "".join([status_header, header_str, content])
+
+            cache.set(cachekey, text)
+
+def _cnonce():
+    dig = _md5("%s:%s" % (time.ctime(), ["0123456789"[random.randrange(0, 9)] for i in range(20)])).hexdigest()
+    return dig[:16]
+
+def _wsse_username_token(cnonce, iso_now, password):
+    return base64.b64encode(_sha("%s%s%s" % (cnonce, iso_now, password)).digest()).strip()
+
+
+# For credentials we need two things, first 
+# a pool of credential to try (not necesarily tied to BAsic, Digest, etc.)
+# Then we also need a list of URIs that have already demanded authentication
+# That list is tricky since sub-URIs can take the same auth, or the 
+# auth scheme may change as you descend the tree.
+# So we also need each Auth instance to be able to tell us
+# how close to the 'top' it is.
+
+class Authentication(object):
+    def __init__(self, credentials, host, request_uri, headers, response, content, http):
+        (scheme, authority, path, query, fragment) = parse_uri(request_uri)
+        self.path = path
+        self.host = host
+        self.credentials = credentials
+        self.http = http
+
+    def depth(self, request_uri):
+        (scheme, authority, path, query, fragment) = parse_uri(request_uri)
+        return request_uri[len(self.path):].count("/")
+
+    def inscope(self, host, request_uri):
+        # XXX Should we normalize the request_uri?
+        (scheme, authority, path, query, fragment) = parse_uri(request_uri)
+        return (host == self.host) and path.startswith(self.path)
+
+    def request(self, method, request_uri, headers, content):
+        """Modify the request headers to add the appropriate
+        Authorization header. Over-rise this in sub-classes."""
+        pass
+
+    def response(self, response, content):
+        """Gives us a chance to update with new nonces
+        or such returned from the last authorized response.
+        Over-rise this in sub-classes if necessary.
+
+        Return TRUE is the request is to be retried, for 
+        example Digest may return stale=true.
+        """
+        return False
+
+
+
+class BasicAuthentication(Authentication):
+    def __init__(self, credentials, host, request_uri, headers, response, content, http):
+        Authentication.__init__(self, credentials, host, request_uri, headers, response, content, http)
+
+    def request(self, method, request_uri, headers, content):
+        """Modify the request headers to add the appropriate
+        Authorization header."""
+        headers['authorization'] = 'Basic ' + base64.b64encode("%s:%s" % self.credentials).strip()
+
+
+class DigestAuthentication(Authentication):
+    """Only do qop='auth' and MD5, since that 
+    is all Apache currently implements"""
+    def __init__(self, credentials, host, request_uri, headers, response, content, http):
+        Authentication.__init__(self, credentials, host, request_uri, headers, response, content, http)
+        challenge = _parse_www_authenticate(response, 'www-authenticate')
+        self.challenge = challenge['digest']
+        qop = self.challenge.get('qop', 'auth')
+        self.challenge['qop'] = ('auth' in [x.strip() for x in qop.split()]) and 'auth' or None
+        if self.challenge['qop'] is None:
+            raise UnimplementedDigestAuthOptionError( _("Unsupported value for qop: %s." % qop))
+        self.challenge['algorithm'] = self.challenge.get('algorithm', 'MD5').upper()
+        if self.challenge['algorithm'] != 'MD5':
+            raise UnimplementedDigestAuthOptionError( _("Unsupported value for algorithm: %s." % self.challenge['algorithm']))
+        self.A1 = "".join([self.credentials[0], ":", self.challenge['realm'], ":", self.credentials[1]])   
+        self.challenge['nc'] = 1
+
+    def request(self, method, request_uri, headers, content, cnonce = None):
+        """Modify the request headers"""
+        H = lambda x: _md5(x).hexdigest()
+        KD = lambda s, d: H("%s:%s" % (s, d))
+        A2 = "".join([method, ":", request_uri])
+        self.challenge['cnonce'] = cnonce or _cnonce() 
+        request_digest  = '"%s"' % KD(H(self.A1), "%s:%s:%s:%s:%s" % (self.challenge['nonce'], 
+                    '%08x' % self.challenge['nc'], 
+                    self.challenge['cnonce'], 
+                    self.challenge['qop'], H(A2)
+                    )) 
+        headers['Authorization'] = 'Digest username="%s", realm="%s", nonce="%s", uri="%s", algorithm=%s, response=%s, qop=%s, nc=%08x, cnonce="%s"' % (
+                self.credentials[0], 
+                self.challenge['realm'],
+                self.challenge['nonce'],
+                request_uri, 
+                self.challenge['algorithm'],
+                request_digest,
+                self.challenge['qop'],
+                self.challenge['nc'],
+                self.challenge['cnonce'],
+                )
+        self.challenge['nc'] += 1
+
+    def response(self, response, content):
+        if not response.has_key('authentication-info'):
+            challenge = _parse_www_authenticate(response, 'www-authenticate').get('digest', {})
+            if 'true' == challenge.get('stale'):
+                self.challenge['nonce'] = challenge['nonce']
+                self.challenge['nc'] = 1 
+                return True
+        else:
+            updated_challenge = _parse_www_authenticate(response, 'authentication-info').get('digest', {})
+
+            if updated_challenge.has_key('nextnonce'):
+                self.challenge['nonce'] = updated_challenge['nextnonce']
+                self.challenge['nc'] = 1 
+        return False
+
+
+class HmacDigestAuthentication(Authentication):
+    """Adapted from Robert Sayre's code and DigestAuthentication above."""
+    __author__ = "Thomas Broyer (t.broyer@ltgt.net)"
+
+    def __init__(self, credentials, host, request_uri, headers, response, content, http):
+        Authentication.__init__(self, credentials, host, request_uri, headers, response, content, http)
+        challenge = _parse_www_authenticate(response, 'www-authenticate')
+        self.challenge = challenge['hmacdigest']
+        # TODO: self.challenge['domain']
+        self.challenge['reason'] = self.challenge.get('reason', 'unauthorized')
+        if self.challenge['reason'] not in ['unauthorized', 'integrity']:
+            self.challenge['reason'] = 'unauthorized'
+        self.challenge['salt'] = self.challenge.get('salt', '')
+        if not self.challenge.get('snonce'):
+            raise UnimplementedHmacDigestAuthOptionError( _("The challenge doesn't contain a server nonce, or this one is empty."))
+        self.challenge['algorithm'] = self.challenge.get('algorithm', 'HMAC-SHA-1')
+        if self.challenge['algorithm'] not in ['HMAC-SHA-1', 'HMAC-MD5']:
+            raise UnimplementedHmacDigestAuthOptionError( _("Unsupported value for algorithm: %s." % self.challenge['algorithm']))
+        self.challenge['pw-algorithm'] = self.challenge.get('pw-algorithm', 'SHA-1')
+        if self.challenge['pw-algorithm'] not in ['SHA-1', 'MD5']:
+            raise UnimplementedHmacDigestAuthOptionError( _("Unsupported value for pw-algorithm: %s." % self.challenge['pw-algorithm']))
+        if self.challenge['algorithm'] == 'HMAC-MD5':
+            self.hashmod = _md5
+        else:
+            self.hashmod = _sha
+        if self.challenge['pw-algorithm'] == 'MD5':
+            self.pwhashmod = _md5
+        else:
+            self.pwhashmod = _sha
+        self.key = "".join([self.credentials[0], ":",
+                    self.pwhashmod.new("".join([self.credentials[1], self.challenge['salt']])).hexdigest().lower(),
+                    ":", self.challenge['realm']
+                    ])
+        self.key = self.pwhashmod.new(self.key).hexdigest().lower()
+
+    def request(self, method, request_uri, headers, content):
+        """Modify the request headers"""
+        keys = _get_end2end_headers(headers)
+        keylist = "".join(["%s " % k for k in keys])
+        headers_val = "".join([headers[k] for k in keys])
+        created = time.strftime('%Y-%m-%dT%H:%M:%SZ',time.gmtime())
+        cnonce = _cnonce()
+        request_digest = "%s:%s:%s:%s:%s" % (method, request_uri, cnonce, self.challenge['snonce'], headers_val)
+        request_digest  = hmac.new(self.key, request_digest, self.hashmod).hexdigest().lower()
+        headers['Authorization'] = 'HMACDigest username="%s", realm="%s", snonce="%s", cnonce="%s", uri="%s", created="%s", response="%s", headers="%s"' % (
+                self.credentials[0], 
+                self.challenge['realm'],
+                self.challenge['snonce'],
+                cnonce,
+                request_uri, 
+                created,
+                request_digest,
+                keylist,
+                )
+
+    def response(self, response, content):
+        challenge = _parse_www_authenticate(response, 'www-authenticate').get('hmacdigest', {})
+        if challenge.get('reason') in ['integrity', 'stale']:
+            return True
+        return False
+
+
+class WsseAuthentication(Authentication):
+    """This is thinly tested and should not be relied upon.
+    At this time there isn't any third party server to test against.
+    Blogger and TypePad implemented this algorithm at one point
+    but Blogger has since switched to Basic over HTTPS and 
+    TypePad has implemented it wrong, by never issuing a 401
+    challenge but instead requiring your client to telepathically know that
+    their endpoint is expecting WSSE profile="UsernameToken"."""
+    def __init__(self, credentials, host, request_uri, headers, response, content, http):
+        Authentication.__init__(self, credentials, host, request_uri, headers, response, content, http)
+
+    def request(self, method, request_uri, headers, content):
+        """Modify the request headers to add the appropriate
+        Authorization header."""
+        headers['Authorization'] = 'WSSE profile="UsernameToken"'
+        iso_now = time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime())
+        cnonce = _cnonce()
+        password_digest = _wsse_username_token(cnonce, iso_now, self.credentials[1])
+        headers['X-WSSE'] = 'UsernameToken Username="%s", PasswordDigest="%s", Nonce="%s", Created="%s"' % (
+                self.credentials[0],
+                password_digest,
+                cnonce,
+                iso_now)
+
+class GoogleLoginAuthentication(Authentication):
+    def __init__(self, credentials, host, request_uri, headers, response, content, http):
+        from urllib import urlencode
+        Authentication.__init__(self, credentials, host, request_uri, headers, response, content, http)
+        challenge = _parse_www_authenticate(response, 'www-authenticate')
+        service = challenge['googlelogin'].get('service', 'xapi')
+        # Bloggger actually returns the service in the challenge
+        # For the rest we guess based on the URI
+        if service == 'xapi' and  request_uri.find("calendar") > 0:
+            service = "cl"
+        # No point in guessing Base or Spreadsheet
+        #elif request_uri.find("spreadsheets") > 0:
+        #    service = "wise"
+
+        auth = dict(Email=credentials[0], Passwd=credentials[1], service=service, source=headers['user-agent'])
+        resp, content = self.http.request("https://www.google.com/accounts/ClientLogin", method="POST", body=urlencode(auth), headers={'Content-Type': 'application/x-www-form-urlencoded'})
+        lines = content.split('\n')
+        d = dict([tuple(line.split("=", 1)) for line in lines if line])
+        if resp.status == 403:
+            self.Auth = ""
+        else:
+            self.Auth = d['Auth']
+
+    def request(self, method, request_uri, headers, content):
+        """Modify the request headers to add the appropriate
+        Authorization header."""
+        headers['authorization'] = 'GoogleLogin Auth=' + self.Auth 
+
+
+AUTH_SCHEME_CLASSES = {
+    "basic": BasicAuthentication,
+    "wsse": WsseAuthentication,
+    "digest": DigestAuthentication,
+    "hmacdigest": HmacDigestAuthentication,
+    "googlelogin": GoogleLoginAuthentication
+}
+
+AUTH_SCHEME_ORDER = ["hmacdigest", "googlelogin", "digest", "wsse", "basic"]
+
+class FileCache(object):
+    """Uses a local directory as a store for cached files.
+    Not really safe to use if multiple threads or processes are going to 
+    be running on the same cache.
+    """
+    def __init__(self, cache, safe=safename): # use safe=lambda x: md5.new(x).hexdigest() for the old behavior
+        self.cache = cache
+        self.safe = safe
+        if not os.path.exists(cache): 
+            os.makedirs(self.cache)
+
+    def get(self, key):
+        retval = None
+        cacheFullPath = os.path.join(self.cache, self.safe(key))
+        try:
+            f = file(cacheFullPath, "rb")
+            retval = f.read()
+            f.close()
+        except IOError:
+            pass
+        return retval
+
+    def set(self, key, value):
+        cacheFullPath = os.path.join(self.cache, self.safe(key))
+        f = file(cacheFullPath, "wb")
+        f.write(value)
+        f.close()
+
+    def delete(self, key):
+        cacheFullPath = os.path.join(self.cache, self.safe(key))
+        if os.path.exists(cacheFullPath):
+            os.remove(cacheFullPath)
+
+class Credentials(object):
+    def __init__(self):
+        self.credentials = []
+
+    def add(self, name, password, domain=""):
+        self.credentials.append((domain.lower(), name, password))
+
+    def clear(self):
+        self.credentials = []
+
+    def iter(self, domain):
+        for (cdomain, name, password) in self.credentials:
+            if cdomain == "" or domain == cdomain:
+                yield (name, password) 
+
+class KeyCerts(Credentials):
+    """Identical to Credentials except that
+    name/password are mapped to key/cert."""
+    pass
+
+
+class ProxyInfo(object):
+  """Collect information required to use a proxy."""
+  def __init__(self, proxy_type, proxy_host, proxy_port, proxy_rdns=None, proxy_user=None, proxy_pass=None):
+      """The parameter proxy_type must be set to one of socks.PROXY_TYPE_XXX
+      constants. For example:
+
+p = ProxyInfo(proxy_type=socks.PROXY_TYPE_HTTP, proxy_host='localhost', proxy_port=8000)
+      """
+      self.proxy_type, self.proxy_host, self.proxy_port, self.proxy_rdns, self.proxy_user, self.proxy_pass = proxy_type, proxy_host, proxy_port, proxy_rdns, proxy_user, proxy_pass
+
+  def astuple(self):
+    return (self.proxy_type, self.proxy_host, self.proxy_port, self.proxy_rdns,
+        self.proxy_user, self.proxy_pass)
+
+  def isgood(self):
+    return socks and (self.proxy_host != None) and (self.proxy_port != None)
+
+
+class HTTPConnectionWithTimeout(httplib.HTTPConnection):
+    """HTTPConnection subclass that supports timeouts"""
+
+    def __init__(self, host, port=None, strict=None, timeout=None, proxy_info=None):
+        httplib.HTTPConnection.__init__(self, host, port, strict)
+        self.timeout = timeout
+        self.proxy_info = proxy_info
+
+    def connect(self):
+        """Connect to the host and port specified in __init__."""
+        # Mostly verbatim from httplib.py.
+        msg = "getaddrinfo returns an empty list"
+        for res in socket.getaddrinfo(self.host, self.port, 0,
+                socket.SOCK_STREAM):
+            af, socktype, proto, canonname, sa = res
+            try:
+                if self.proxy_info and self.proxy_info.isgood():
+                    self.sock = socks.socksocket(af, socktype, proto)
+                    self.sock.setproxy(*self.proxy_info.astuple())
+                else:
+                    self.sock = socket.socket(af, socktype, proto)
+                # Different from httplib: support timeouts.
+                if has_timeout(self.timeout):
+                    self.sock.settimeout(self.timeout)
+                    # End of difference from httplib.
+                if self.debuglevel > 0:
+                    print "connect: (%s, %s)" % (self.host, self.port)
+
+                self.sock.connect(sa)
+            except socket.error, msg:
+                if self.debuglevel > 0:
+                    print 'connect fail:', (self.host, self.port)
+                if self.sock:
+                    self.sock.close()
+                self.sock = None
+                continue
+            break
+        if not self.sock:
+            raise socket.error, msg
+
+class HTTPSConnectionWithTimeout(httplib.HTTPSConnection):
+    "This class allows communication via SSL."
+
+    def __init__(self, host, port=None, key_file=None, cert_file=None,
+                 strict=None, timeout=None, proxy_info=None):
+        httplib.HTTPSConnection.__init__(self, host, port=port, key_file=key_file,
+                cert_file=cert_file, strict=strict)
+        self.timeout = timeout
+        self.proxy_info = proxy_info
+
+    def connect(self):
+        "Connect to a host on a given (SSL) port."
+
+        if self.proxy_info and self.proxy_info.isgood():
+            sock = socks.socksocket(socket.AF_INET, socket.SOCK_STREAM)
+            sock.setproxy(*self.proxy_info.astuple())
+        else:
+            sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        
+        if has_timeout(self.timeout):
+            sock.settimeout(self.timeout)
+        sock.connect((self.host, self.port))
+        self.sock =_ssl_wrap_socket(sock, self.key_file, self.cert_file)
+
+
+
+class Http(object):
+    """An HTTP client that handles:
+- all methods
+- caching
+- ETags
+- compression,
+- HTTPS
+- Basic
+- Digest
+- WSSE
+
+and more.
+    """
+    def __init__(self, cache=None, timeout=None, proxy_info=None):
+        """The value of proxy_info is a ProxyInfo instance.
+
+If 'cache' is a string then it is used as a directory name
+for a disk cache. Otherwise it must be an object that supports
+the same interface as FileCache."""
+        self.proxy_info = proxy_info
+        # Map domain name to an httplib connection
+        self.connections = {}
+        # The location of the cache, for now a directory
+        # where cached responses are held.
+        if cache and isinstance(cache, str):
+            self.cache = FileCache(cache)
+        else:
+            self.cache = cache
+
+        # Name/password
+        self.credentials = Credentials()
+
+        # Key/cert
+        self.certificates = KeyCerts()
+
+        # authorization objects
+        self.authorizations = []
+
+        # If set to False then no redirects are followed, even safe ones.
+        self.follow_redirects = True
+        
+        # Which HTTP methods do we apply optimistic concurrency to, i.e.
+        # which methods get an "if-match:" etag header added to them.
+        self.optimistic_concurrency_methods = ["PUT"]
+
+        # If 'follow_redirects' is True, and this is set to True then
+        # all redirecs are followed, including unsafe ones.
+        self.follow_all_redirects = False
+
+        self.ignore_etag = False
+
+        self.force_exception_to_status_code = False 
+
+        self.timeout = timeout
+
+    def _auth_from_challenge(self, host, request_uri, headers, response, content):
+        """A generator that creates Authorization objects
+           that can be applied to requests.
+        """
+        challenges = _parse_www_authenticate(response, 'www-authenticate')
+        for cred in self.credentials.iter(host):
+            for scheme in AUTH_SCHEME_ORDER:
+                if challenges.has_key(scheme):
+                    yield AUTH_SCHEME_CLASSES[scheme](cred, host, request_uri, headers, response, content, self)
+
+    def add_credentials(self, name, password, domain=""):
+        """Add a name and password that will be used
+        any time a request requires authentication."""
+        self.credentials.add(name, password, domain)
+
+    def add_certificate(self, key, cert, domain):
+        """Add a key and cert that will be used
+        any time a request requires authentication."""
+        self.certificates.add(key, cert, domain)
+
+    def clear_credentials(self):
+        """Remove all the names and passwords
+        that are used for authentication"""
+        self.credentials.clear()
+        self.authorizations = []
+
+    def _conn_request(self, conn, request_uri, method, body, headers):
+        for i in range(2):
+            try:
+                conn.request(method, request_uri, body, headers)
+            except socket.gaierror:
+                conn.close()
+                raise ServerNotFoundError("Unable to find the server at %s" % conn.host)
+            except (socket.error, httplib.HTTPException):
+                # Just because the server closed the connection doesn't apparently mean
+                # that the server didn't send a response.
+                pass
+            try:
+                response = conn.getresponse()
+            except (socket.error, httplib.HTTPException):
+                if i == 0:
+                    conn.close()
+                    conn.connect()
+                    continue
+                else:
+                    raise
+            else:
+                content = ""
+                if method == "HEAD":
+                    response.close()
+                else:
+                    content = response.read()
+                response = Response(response)
+                if method != "HEAD":
+                    content = _decompressContent(response, content)
+            break
+        return (response, content)
+
+
+    def _request(self, conn, host, absolute_uri, request_uri, method, body, headers, redirections, cachekey):
+        """Do the actual request using the connection object
+        and also follow one level of redirects if necessary"""
+
+        auths = [(auth.depth(request_uri), auth) for auth in self.authorizations if auth.inscope(host, request_uri)]
+        auth = auths and sorted(auths)[0][1] or None
+        if auth: 
+            auth.request(method, request_uri, headers, body)
+
+        (response, content) = self._conn_request(conn, request_uri, method, body, headers)
+
+        if auth: 
+            if auth.response(response, body):
+                auth.request(method, request_uri, headers, body)
+                (response, content) = self._conn_request(conn, request_uri, method, body, headers )
+                response._stale_digest = 1
+
+        if response.status == 401:
+            for authorization in self._auth_from_challenge(host, request_uri, headers, response, content):
+                authorization.request(method, request_uri, headers, body) 
+                (response, content) = self._conn_request(conn, request_uri, method, body, headers, )
+                if response.status != 401:
+                    self.authorizations.append(authorization)
+                    authorization.response(response, body)
+                    break
+
+        if (self.follow_all_redirects or (method in ["GET", "HEAD"]) or response.status == 303):
+            if self.follow_redirects and response.status in [300, 301, 302, 303, 307]:
+                # Pick out the location header and basically start from the beginning
+                # remembering first to strip the ETag header and decrement our 'depth'
+                if redirections:
+                    if not response.has_key('location') and response.status != 300:
+                        raise RedirectMissingLocation( _("Redirected but the response is missing a Location: header."), response, content)
+                    # Fix-up relative redirects (which violate an RFC 2616 MUST)
+                    if response.has_key('location'):
+                        location = response['location']
+                        (scheme, authority, path, query, fragment) = parse_uri(location)
+                        if authority == None:
+                            response['location'] = urlparse.urljoin(absolute_uri, location)
+                    if response.status == 301 and method in ["GET", "HEAD"]:
+                        response['-x-permanent-redirect-url'] = response['location']
+                        if not response.has_key('content-location'):
+                            response['content-location'] = absolute_uri 
+                        _updateCache(headers, response, content, self.cache, cachekey)
+                    if headers.has_key('if-none-match'):
+                        del headers['if-none-match']
+                    if headers.has_key('if-modified-since'):
+                        del headers['if-modified-since']
+                    if response.has_key('location'):
+                        location = response['location']
+                        old_response = copy.deepcopy(response)
+                        if not old_response.has_key('content-location'):
+                            old_response['content-location'] = absolute_uri 
+                        redirect_method = ((response.status == 303) and (method not in ["GET", "HEAD"])) and "GET" or method
+                        (response, content) = self.request(location, redirect_method, body=body, headers = headers, redirections = redirections - 1)
+                        response.previous = old_response
+                else:
+                    raise RedirectLimit( _("Redirected more times than rediection_limit allows."), response, content)
+            elif response.status in [200, 203] and method == "GET":
+                # Don't cache 206's since we aren't going to handle byte range requests
+                if not response.has_key('content-location'):
+                    response['content-location'] = absolute_uri 
+                _updateCache(headers, response, content, self.cache, cachekey)
+
+        return (response, content)
+
+    def _normalize_headers(self, headers):
+        return _normalize_headers(headers)
+
+# Need to catch and rebrand some exceptions
+# Then need to optionally turn all exceptions into status codes
+# including all socket.* and httplib.* exceptions.
+
+
+    def request(self, uri, method="GET", body=None, headers=None, redirections=DEFAULT_MAX_REDIRECTS, connection_type=None):
+        """ Performs a single HTTP request.
+The 'uri' is the URI of the HTTP resource and can begin 
+with either 'http' or 'https'. The value of 'uri' must be an absolute URI.
+
+The 'method' is the HTTP method to perform, such as GET, POST, DELETE, etc. 
+There is no restriction on the methods allowed.
+
+The 'body' is the entity body to be sent with the request. It is a string
+object.
+
+Any extra headers that are to be sent with the request should be provided in the
+'headers' dictionary.
+
+The maximum number of redirect to follow before raising an 
+exception is 'redirections. The default is 5.
+
+The return value is a tuple of (response, content), the first 
+being and instance of the 'Response' class, the second being 
+a string that contains the response entity body.
+        """
+        try:
+            if headers is None:
+                headers = {}
+            else:
+                headers = self._normalize_headers(headers)
+
+            if not headers.has_key('user-agent'):
+                headers['user-agent'] = "Python-httplib2/%s" % __version__
+
+            uri = iri2uri(uri)
+
+            (scheme, authority, request_uri, defrag_uri) = urlnorm(uri)
+            domain_port = authority.split(":")[0:2]
+            if len(domain_port) == 2 and domain_port[1] == '443' and scheme == 'http':
+                scheme = 'https'
+                authority = domain_port[0]
+
+            conn_key = scheme+":"+authority
+            if conn_key in self.connections:
+                conn = self.connections[conn_key]
+            else:
+                if not connection_type:
+                    connection_type = (scheme == 'https') and HTTPSConnectionWithTimeout or HTTPConnectionWithTimeout
+                certs = list(self.certificates.iter(authority))
+                if scheme == 'https' and certs:
+                    conn = self.connections[conn_key] = connection_type(authority, key_file=certs[0][0],
+                        cert_file=certs[0][1], timeout=self.timeout, proxy_info=self.proxy_info)
+                else:
+                    conn = self.connections[conn_key] = connection_type(authority, timeout=self.timeout, proxy_info=self.proxy_info)
+                conn.set_debuglevel(debuglevel)
+
+            if method in ["GET", "HEAD"] and 'range' not in headers and 'accept-encoding' not in headers:
+                headers['accept-encoding'] = 'gzip, deflate'
+
+            info = email.Message.Message()
+            cached_value = None
+            if self.cache:
+                cachekey = defrag_uri
+                cached_value = self.cache.get(cachekey)
+                if cached_value:
+                    # info = email.message_from_string(cached_value)
+                    #
+                    # Need to replace the line above with the kludge below
+                    # to fix the non-existent bug not fixed in this
+                    # bug report: http://mail.python.org/pipermail/python-bugs-list/2005-September/030289.html
+                    try:
+                        info, content = cached_value.split('\r\n\r\n', 1)
+                        feedparser = email.FeedParser.FeedParser()
+                        feedparser.feed(info)
+                        info = feedparser.close()
+                        feedparser._parse = None
+                    except IndexError:
+                        self.cache.delete(cachekey)
+                        cachekey = None
+                        cached_value = None
+            else:
+                cachekey = None
+
+            if method in self.optimistic_concurrency_methods and self.cache and info.has_key('etag') and not self.ignore_etag and 'if-match' not in headers:
+                # http://www.w3.org/1999/04/Editing/
+                headers['if-match'] = info['etag']
+
+            if method not in ["GET", "HEAD"] and self.cache and cachekey:
+                # RFC 2616 Section 13.10
+                self.cache.delete(cachekey)
+
+            # Check the vary header in the cache to see if this request
+            # matches what varies in the cache.
+            if method in ['GET', 'HEAD'] and 'vary' in info:
+                vary = info['vary']
+                vary_headers = vary.lower().replace(' ', '').split(',')
+                for header in vary_headers:
+                    key = '-varied-%s' % header
+                    value = info[key]
+                    if headers.get(header, '') != value:
+                            cached_value = None
+                            break
+
+            if cached_value and method in ["GET", "HEAD"] and self.cache and 'range' not in headers:
+                if info.has_key('-x-permanent-redirect-url'):
+                    # Should cached permanent redirects be counted in our redirection count? For now, yes.
+                    (response, new_content) = self.request(info['-x-permanent-redirect-url'], "GET", headers = headers, redirections = redirections - 1)
+                    response.previous = Response(info)
+                    response.previous.fromcache = True
+                else:
+                    # Determine our course of action:
+                    #   Is the cached entry fresh or stale?
+                    #   Has the client requested a non-cached response?
+                    #   
+                    # There seems to be three possible answers: 
+                    # 1. [FRESH] Return the cache entry w/o doing a GET
+                    # 2. [STALE] Do the GET (but add in cache validators if available)
+                    # 3. [TRANSPARENT] Do a GET w/o any cache validators (Cache-Control: no-cache) on the request
+                    entry_disposition = _entry_disposition(info, headers) 
+                    
+                    if entry_disposition == "FRESH":
+                        if not cached_value:
+                            info['status'] = '504'
+                            content = ""
+                        response = Response(info)
+                        if cached_value:
+                            response.fromcache = True
+                        return (response, content)
+
+                    if entry_disposition == "STALE":
+                        if info.has_key('etag') and not self.ignore_etag and not 'if-none-match' in headers:
+                            headers['if-none-match'] = info['etag']
+                        if info.has_key('last-modified') and not 'last-modified' in headers:
+                            headers['if-modified-since'] = info['last-modified']
+                    elif entry_disposition == "TRANSPARENT":
+                        pass
+
+                    (response, new_content) = self._request(conn, authority, uri, request_uri, method, body, headers, redirections, cachekey)
+
+                if response.status == 304 and method == "GET":
+                    # Rewrite the cache entry with the new end-to-end headers
+                    # Take all headers that are in response 
+                    # and overwrite their values in info.
+                    # unless they are hop-by-hop, or are listed in the connection header.
+
+                    for key in _get_end2end_headers(response):
+                        info[key] = response[key]
+                    merged_response = Response(info)
+                    if hasattr(response, "_stale_digest"):
+                        merged_response._stale_digest = response._stale_digest
+                    _updateCache(headers, merged_response, content, self.cache, cachekey)
+                    response = merged_response
+                    response.status = 200
+                    response.fromcache = True 
+
+                elif response.status == 200:
+                    content = new_content
+                else:
+                    self.cache.delete(cachekey)
+                    content = new_content 
+            else: 
+                cc = _parse_cache_control(headers)
+                if cc.has_key('only-if-cached'):
+                    info['status'] = '504'
+                    response = Response(info)
+                    content = ""
+                else:
+                    (response, content) = self._request(conn, authority, uri, request_uri, method, body, headers, redirections, cachekey)
+        except Exception, e:
+            if self.force_exception_to_status_code:
+                if isinstance(e, HttpLib2ErrorWithResponse):
+                    response = e.response
+                    content = e.content
+                    response.status = 500
+                    response.reason = str(e) 
+                elif isinstance(e, socket.timeout):
+                    content = "Request Timeout"
+                    response = Response( {
+                            "content-type": "text/plain",
+                            "status": "408",
+                            "content-length": len(content)
+                            })
+                    response.reason = "Request Timeout"
+                else:
+                    content = str(e) 
+                    response = Response( {
+                            "content-type": "text/plain",
+                            "status": "400",
+                            "content-length": len(content)
+                            })
+                    response.reason = "Bad Request" 
+            else:
+                raise
+
+ 
+        return (response, content)
+
+ 
+
+class Response(dict):
+    """An object more like email.Message than httplib.HTTPResponse."""
+   
+    """Is this response from our local cache"""
+    fromcache = False
+
+    """HTTP protocol version used by server. 10 for HTTP/1.0, 11 for HTTP/1.1. """
+    version = 11
+
+    "Status code returned by server. "
+    status = 200
+
+    """Reason phrase returned by server."""
+    reason = "Ok"
+
+    previous = None
+
+    def __init__(self, info):
+        # info is either an email.Message or 
+        # an httplib.HTTPResponse object.
+        if isinstance(info, httplib.HTTPResponse):
+            for key, value in info.getheaders(): 
+                self[key.lower()] = value 
+            self.status = info.status
+            self['status'] = str(self.status)
+            self.reason = info.reason
+            self.version = info.version
+        elif isinstance(info, email.Message.Message):
+            for key, value in info.items(): 
+                self[key] = value 
+            self.status = int(self['status'])
+        else:
+            for key, value in info.iteritems(): 
+                self[key] = value 
+            self.status = int(self.get('status', self.status))
+
+
+    def __getattr__(self, name):
+        if name == 'dict':
+            return self 
+        else:  
+            raise AttributeError, name 
diff --git a/huTools/http/_httplib2/iri2uri.py b/huTools/http/_httplib2/iri2uri.py
new file mode 100644
index 0000000..70667ed
--- /dev/null
+++ b/huTools/http/_httplib2/iri2uri.py
@@ -0,0 +1,110 @@
+"""
+iri2uri
+
+Converts an IRI to a URI.
+
+"""
+__author__ = "Joe Gregorio (joe@bitworking.org)"
+__copyright__ = "Copyright 2006, Joe Gregorio"
+__contributors__ = []
+__version__ = "1.0.0"
+__license__ = "MIT"
+__history__ = """
+"""
+
+import urlparse
+
+
+# Convert an IRI to a URI following the rules in RFC 3987
+# 
+# The characters we need to enocde and escape are defined in the spec:
+#
+# iprivate =  %xE000-F8FF / %xF0000-FFFFD / %x100000-10FFFD
+# ucschar = %xA0-D7FF / %xF900-FDCF / %xFDF0-FFEF
+#         / %x10000-1FFFD / %x20000-2FFFD / %x30000-3FFFD
+#         / %x40000-4FFFD / %x50000-5FFFD / %x60000-6FFFD
+#         / %x70000-7FFFD / %x80000-8FFFD / %x90000-9FFFD
+#         / %xA0000-AFFFD / %xB0000-BFFFD / %xC0000-CFFFD
+#         / %xD0000-DFFFD / %xE1000-EFFFD
+
+escape_range = [
+   (0xA0, 0xD7FF ),
+   (0xE000, 0xF8FF ),
+   (0xF900, 0xFDCF ),
+   (0xFDF0, 0xFFEF),
+   (0x10000, 0x1FFFD ),
+   (0x20000, 0x2FFFD ),
+   (0x30000, 0x3FFFD),
+   (0x40000, 0x4FFFD ),
+   (0x50000, 0x5FFFD ),
+   (0x60000, 0x6FFFD),
+   (0x70000, 0x7FFFD ),
+   (0x80000, 0x8FFFD ),
+   (0x90000, 0x9FFFD),
+   (0xA0000, 0xAFFFD ),
+   (0xB0000, 0xBFFFD ),
+   (0xC0000, 0xCFFFD),
+   (0xD0000, 0xDFFFD ),
+   (0xE1000, 0xEFFFD),
+   (0xF0000, 0xFFFFD ),
+   (0x100000, 0x10FFFD)
+]
+ 
+def encode(c):
+    retval = c
+    i = ord(c)
+    for low, high in escape_range:
+        if i < low:
+            break
+        if i >= low and i <= high:
+            retval = "".join(["%%%2X" % ord(o) for o in c.encode('utf-8')])
+            break
+    return retval
+
+
+def iri2uri(uri):
+    """Convert an IRI to a URI. Note that IRIs must be 
+    passed in a unicode strings. That is, do not utf-8 encode
+    the IRI before passing it into the function.""" 
+    if isinstance(uri ,unicode):
+        (scheme, authority, path, query, fragment) = urlparse.urlsplit(uri)
+        authority = authority.encode('idna')
+        # For each character in 'ucschar' or 'iprivate'
+        #  1. encode as utf-8
+        #  2. then %-encode each octet of that utf-8 
+        uri = urlparse.urlunsplit((scheme, authority, path, query, fragment))
+        uri = "".join([encode(c) for c in uri])
+    return uri
+        
+if __name__ == "__main__":
+    import unittest
+
+    class Test(unittest.TestCase):
+
+        def test_uris(self):
+            """Test that URIs are invariant under the transformation."""
+            invariant = [ 
+                u"ftp://ftp.is.co.za/rfc/rfc1808.txt",
+                u"http://www.ietf.org/rfc/rfc2396.txt",
+                u"ldap://[2001:db8::7]/c=GB?objectClass?one",
+                u"mailto:John.Doe@example.com",
+                u"news:comp.infosystems.www.servers.unix",
+                u"tel:+1-816-555-1212",
+                u"telnet://192.0.2.16:80/",
+                u"urn:oasis:names:specification:docbook:dtd:xml:4.1.2" ]
+            for uri in invariant:
+                self.assertEqual(uri, iri2uri(uri))
+            
+        def test_iri(self):
+            """ Test that the right type of escaping is done for each part of the URI."""
+            self.assertEqual("http://xn--o3h.com/%E2%98%84", iri2uri(u"http://\N{COMET}.com/\N{COMET}"))
+            self.assertEqual("http://bitworking.org/?fred=%E2%98%84", iri2uri(u"http://bitworking.org/?fred=\N{COMET}"))
+            self.assertEqual("http://bitworking.org/#%E2%98%84", iri2uri(u"http://bitworking.org/#\N{COMET}"))
+            self.assertEqual("#%E2%98%84", iri2uri(u"#\N{COMET}"))
+            self.assertEqual("/fred?bar=%E2%98%9A#%E2%98%84", iri2uri(u"/fred?bar=\N{BLACK LEFT POINTING INDEX}#\N{COMET}"))
+            self.assertEqual("/fred?bar=%E2%98%9A#%E2%98%84", iri2uri(iri2uri(u"/fred?bar=\N{BLACK LEFT POINTING INDEX}#\N{COMET}")))
+            self.assertNotEqual("/fred?bar=%E2%98%9A#%E2%98%84", iri2uri(u"/fred?bar=\N{BLACK LEFT POINTING INDEX}#\N{COMET}".encode('utf-8')))
+
+    unittest.main()
+
+    
diff --git a/huTools/http/engine_appengine.py b/huTools/http/engine_appengine.py
new file mode 100644
index 0000000..0f5abc2
--- /dev/null
+++ b/huTools/http/engine_appengine.py
@@ -0,0 +1,33 @@
+#!/usr/bin/env python
+# encoding: utf-8
+"""
+engine_appengine.py implements urlfetch based queries for huTools.http.
+
+See http://code.google.com/appengine/docs/python/urlfetch/overview.html for the basics of the
+AppEngine capabilities.
+
+Created by Maximillian Dornseif on 2010-10-24.
+Copyright (c) 2010 HUDORA. All rights reserved.
+"""
+
+
+from google.appengine.api import urlfetch
+
+
+def request(url, method, content, headers):
+    """Does a HTTP Request via Google Appengine urlfetch Service.
+    
+    Incereases the default appengine timeout from 5 seconds to 10."""
+    
+    if method == 'GET':
+        method = urlfetch.GET
+    elif method == 'POST':
+        method = urlfetch.POST
+    elif method == 'DELETE':
+        method = urlfetch.DELETE
+    elif method == 'PUT':
+        method = urlfetch.PUT
+    elif method == 'HEAD':
+        method = urlfetch.HEAD
+    result = urlfetch.fetch(url=url, deadline=10, payload=content, method=method, headers=headers)
+    return int(result.status_code), result.headers, result.content
diff --git a/huTools/http/engine_httplib2.py b/huTools/http/engine_httplib2.py
new file mode 100644
index 0000000..88dd950
--- /dev/null
+++ b/huTools/http/engine_httplib2.py
@@ -0,0 +1,25 @@
+#!/usr/bin/env python
+# encoding: utf-8
+"""
+engine_httplib2.py implements httplib2 based queries for huTools.http
+
+Created by Maximillian Dornseif on 2010-10-24.
+Copyright (c) 2010 HUDORA. All rights reserved.
+"""
+
+
+_http = None
+
+
+def request(url, method, content, headers):
+    """Does a HTTP Request via httplib2 Service."""
+
+    global _http
+    if not _http:
+        import huTools.http._httplib2
+        _http = huTools.http._httplib2.Http()
+    
+    resp, content = _http.request(url, method, content, headers=headers)
+    replyheaders = {}
+    replyheaders.update(resp)
+    return int(resp.status), replyheaders, content
diff --git a/huTools/poster_encode.py b/huTools/http/poster_encode.py
similarity index 100%
rename from huTools/poster_encode.py
rename to huTools/http/poster_encode.py
diff --git a/huTools/http/test.py b/huTools/http/test.py
new file mode 100644
index 0000000..bd1819e
--- /dev/null
+++ b/huTools/http/test.py
@@ -0,0 +1,64 @@
+#!/usr/bin/env python
+# encoding: utf-8
+"""
+test.py
+
+Created by Maximillian Dornseif on 2010-10-24.
+Copyright (c) 2010 HUDORA. All rights reserved.
+"""
+
+import unittest
+from huTools.http import fetch
+
+
+class testTests(unittest.TestCase):
+
+    def test_fetch_get_basic(self):
+        status, header, body = fetch('http://www.google.com')
+        assert status == 200
+        status, header, body = fetch('http://www.postbin.org/186ndf2', {'q': 'hudora'})
+        assert status == 200
+        status, header, body = fetch('http://www.postbin.org/186ndf2', {'keyg': 'value', 'just a test': 212})
+        assert status == 200
+
+    def test_fetch_get_unicode(self):
+        status, header, body = fetch('http://www.postbin.org/186ndf2',
+                                     {'kühg1': 'Iñtërnâtiônàlizætiøn'})
+        assert status == 200
+        status, header, body = fetch('http://www.postbin.org/186ndf2',
+                                     {'kühg2': u'Iñtërnâtiônàlizætiøn'})
+        assert status == 200
+        status, header, body = fetch('http://www.postbin.org/186ndf2',
+                                     {u'kühg3': 'Iñtërnâtiônàlizætiøn'})
+        assert status == 200
+
+    def test_fetch_post_basic(self):
+        status, header, body = fetch('http://www.postbin.org/186ndf2',
+        {'keyp1': 'value', 'just a test': 212}, 'POST')
+        assert status == 201
+
+    def test_fetch_post_file(self):
+        status, header, body = fetch('http://www.postbin.org/186ndf2',
+                                     {'hosts': open('/etc/hosts', 'r')}, 'POST')
+        status, header, body = fetch('http://www.postbin.org/186ndf2',
+                                     {'hosts': open('/etc/hosts', 'r'), 
+                                      'unicode': u'Iñtërnâtiônàlizætiøn'}, 'POST')
+        assert status == 201
+
+    def test_fetch_post_unicode(self):
+        status, header, body = fetch('http://www.postbin.org/186ndf2',
+                                     {'kuehp1': 'Iñtërnâtiônàlizætiøn'}, 'POST')
+        assert status == 201
+        status, header, body = fetch('http://www.postbin.org/186ndf2',
+                                     {'kühp2': 'Iñtërnâtiônàlizætiøn'}, 'POST')
+        assert status == 201
+        status, header, body = fetch('http://www.postbin.org/186ndf2',
+                                     {'kühp3': u'Iñtërnâtiônàlizætiøn'}, 'POST')
+        assert status == 201
+        status, header, body = fetch('http://www.postbin.org/186ndf2',
+                                     {u'kühp4': u'Iñtërnâtiônàlizætiøn'}, 'POST')
+        assert status == 201
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/huTools/http/tools.py b/huTools/http/tools.py
new file mode 100644
index 0000000..da81166
--- /dev/null
+++ b/huTools/http/tools.py
@@ -0,0 +1,111 @@
+#!/usr/bin/env python
+# encoding: utf-8
+"""
+tools.py
+
+Created by Maximillian Dornseif on 2010-10-24.
+Copyright (c) 2010 HUDORA. All rights reserved.
+"""
+
+import urllib
+from poster_encode import multipart_encode
+import urlparse
+
+
+# quoting based on
+# http://svn.python.org/view/python/branches/release27-maint/Lib/urllib.py?view=markup&pathrev=82940
+# by Matt Giuca
+always_safe = ('ABCDEFGHIJKLMNOPQRSTUVWXYZ'
+               'abcdefghijklmnopqrstuvwxyz'
+               '0123456789' '_.-')
+_safe_map = {}
+for i, c in zip(xrange(256), str(bytearray(xrange(256)))):
+    _safe_map[c] = c if (i < 128 and c in always_safe) else ('%%%02X' % i)
+_safe_quoters = {}
+
+
+def quote(s, safe='/', encoding=None, errors=None):
+    """quote('abc def') -> 'abc%20def'
+
+    Each part of a URL, e.g. the path info, the query, etc., has a
+    different set of reserved characters that must be quoted.
+
+    RFC 2396 Uniform Resource Identifiers (URI): Generic Syntax lists
+    the following reserved characters.
+
+    reserved    = ";" | "/" | "?" | ":" | "@" | "&" | "=" | "+" |
+                  "$" | ","
+
+    Each of these characters is reserved in some component of a URL,
+    but not necessarily in all of them.
+
+    By default, the quote function is intended for quoting the path
+    section of a URL.  Thus, it will not encode '/'.  This character
+    is reserved, but in typical usage the quote function is being
+    called on a path where the existing slash characters are used as
+    reserved characters.
+
+    string and safe may be either str or unicode objects.
+
+    The optional encoding and errors parameters specify how to deal with the
+    non-ASCII characters, as accepted by the unicode.encode method.
+    By default, encoding='utf-8' (characters are encoded with UTF-8), and
+    errors='strict' (unsupported characters raise a UnicodeEncodeError).
+    """
+    # fastpath
+    if not s:
+        return s
+
+    if encoding is not None or isinstance(s, unicode):
+        if encoding is None:
+            encoding = 'utf-8'
+        if errors is None:
+            errors = 'strict'
+        s = s.encode(encoding, errors)
+    if isinstance(safe, unicode):
+        # Normalize 'safe' by converting to str and removing non-ASCII chars
+        safe = safe.encode('ascii', 'ignore')
+
+    cachekey = (safe, always_safe)
+    try:
+        (quoter, safe) = _safe_quoters[cachekey]
+    except KeyError:
+        safe_map = _safe_map.copy()
+        safe_map.update([(c, c) for c in safe])
+        quoter = safe_map.__getitem__
+        safe = always_safe + safe
+        _safe_quoters[cachekey] = (quoter, safe)
+    if not s.rstrip(safe):
+        return s
+    return ''.join(map(quoter, s))
+
+
+def quote_plus(s, safe='', encoding=None, errors=None):
+    """Quote the query fragment of a URL; replacing ' ' with '+'"""
+    if ' ' in s:
+        s = quote(s, safe + ' ', encoding, errors)
+        return s.replace(' ', '+')
+    return quote(s, safe, encoding, errors)
+
+
+def urlencode(query):
+    """Encode a sequence of two-element tuples or dictionary into a URL query string.
+
+    If the query arg is a sequence of two-element tuples, the order of the
+    parameters in the output will match the order of parameters in the
+    input.
+    """
+
+    if hasattr(query, 'items'):
+        # mapping objects
+        query = query.items()
+    l = []
+    for k, v in query:
+        k = quote_plus(k)
+        if isinstance(v, basestring):
+            v = quote_plus(v)
+            l.append(k + '=' + v)
+        else:
+            v = quote_plus(unicode(v))
+            l.append(k + '=' + v)
+    return '&'.join(l)
diff --git a/huTools/pyjasper.py b/huTools/pyjasper.py
index c0f5cc6..88708b7 100644
--- a/huTools/pyjasper.py
+++ b/huTools/pyjasper.py
@@ -2,65 +2,36 @@
 # encoding: utf-8
 
 """
-pyJasper client.py - Way to a pyJasper Server.
+pyJasper client.py - Way to talk to a pyJasper Server.
 See http://pypi.python.org/pypi/pyJasper/ for further enligthenment.
 
-You must tell the code where the pyJasper Servlet is running. Either give the URL via
-instatntion `JasperGenerator(serverurl='MYURL')`.
-
-Alternatively the code tries to import a module config and find in the the constant
-`PYJASPER_SERVLET_URL`. If that fails it tries to read `PYJASPER_SERVLET_URL` from the environment.
-Finally it falls back to `http://localhost:8080/pyJasper/jasper.py`.
+Created by Maximillian Dornseif on 2007-10-12.
+Moved into huTools in 2010
+Consider it BSD licensed.
 """
 
-# Created by Maximillian Dornseif on 2007-10-12.
-# Moved into huTools in 2010
-# Consider it BSD licensed.
-
 
 from cStringIO import StringIO
-from httplib2 import Http
+from huTools.http import fetch
 import logging
 import os
 import os.path
-import time
-import uuid
+import re
+import unittest
+import warnings
 import xml.etree.ElementTree as ET
 
 
+try:
+    from django.conf import settings
+    # trigger the lazy importer
+    getattr(settings, 'DUMMY', None)
+except ImportError:
+    settings = object()
 try:
     import config
 except:
-    config = None
-
-
-def fetch_httplib2(url, content, content_type):
-    """Fetch an url with httplib2"""
-    resp, content = Http().request(url, 'POST', body=content, headers={"Content-Type": content_type})
-    return resp.get('status'), content
-
-
-def fetch(url, content, content_type):
-    "fetch an url via appengine"
-    try:
-        result = urlfetch.fetch(url=url,
-                                payload=content,
-                                method=urlfetch.POST,
-                                headers={'Content-Type': content_type},
-                                deadline=10)
-    except urlfetch.DownloadError, msg:
-        logging.error('Error during access to %s: %s' % (url, msg))
-        raise
-    return str(result.status_code), result.content
-
-
-# Try to use appengine specific code to incerase appengine default timeout of 5 sec to 10 sec
-try:
-    from google.appengine.api import urlfetch
-    logging.info("using urlfetch for pyJasper")
-except ImportError:
-    fetch = fetch_httplib2
-    logging.info("using httplib2 for pyJasper")
+    config = object()
 
 
 class JasperException(RuntimeError):
@@ -68,42 +39,31 @@ class JasperException(RuntimeError):
     pass
 
 
-def encode_multipart_formdata(fields):
-    """
-    fields is a sequence of (name, value) elements for regular form fields.
-    files is a sequence of (name, filename, value) elements for data to be uploaded as files
-    Return (content_type, body) ready for httplib.HTTP instance
-    """
-    # Based on From http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/146306
-    boundary = '----------ThIs_Is_tHe_bouNdaRY_$%s' % (uuid.uuid4())
-    out = []
-    # if it's dict like then use the items method to get the fields
-    if hasattr(fields, "items"):
-        fields = fields.items()
-    for (key, value) in fields:
-        out.append('--' + boundary)
-        out.append('Content-Disposition: form-data; name="%s"' % key)
-        out.append('')
-        out.append(value)
-    out.append('--' + boundary + '--')
-    out.append('')
-    body = '\r\n'.join([str(x) for x in out])
-    content_type = 'multipart/form-data; boundary=%s' % boundary
-    return content_type, body
-
-
 def get_reportname(base, *args):
     """
     Construct path for report file relative to base
 
     In most cases, this will be JasperGenerator.__file__
     """
+    warnings.warn("pyjasper.get_reportname is deprecated", DeprecationWarning, stacklevel=2)
     path = os.path.join(os.path.dirname(base), 'reports', *args)
     return os.path.abspath(path)
 
 
+def _find_server(serverurl):
+    if not serverurl:
+        serverurl = getattr(settings, 'PYJASPER_SERVLET_URL', None)
+    if not serverurl:
+        serverurl = getattr(config, 'PYJASPER_SERVLET_URL', None)
+    if not serverurl:
+        serverurl = os.environ.get('PYJASPER_SERVLET_URL', None)
+    if not serverurl:
+        raise JasperException('set PYJASPER_SERVLET_URL')
+    return serverurl
+
+
 class JasperGenerator(object):
-    """Abstract class for generating Documents out with Jasperreports.
+    """Abstract class for generating PDF Documents with Jasperreports.
 
     You have to overwrite generate_xml to make meaningfull use of this class. Then call
     YourClass.generate(yourdata). Yourdata is passed to generate_xml() and hopfully you will get
@@ -115,22 +75,17 @@ def __init__(self, serverurl=None, debug=False):
         self.reportname = None
         self.xpath = None
         self.debug = debug
-        self.serverurl = serverurl
-        if not self.serverurl:
-            try:
-                self.serverurl = config.PYJASPER_SERVLET_URL
-            except:
-                self.serverurl = os.getenv('PYJASPER_SERVLET_URL',
-                                           default='http://localhost:8080/pyJasper/jasper.py')
+        self.serverurl = _find_server(serverurl)
 
     def generate_xml(self, data=None):
         """To be overwritten by subclasses.
 
         E.g.
         def generate_xml(self, movement):
-            ET.SubElement(self.root, 'generator').text = __revision__
-            ET.SubElement(self.root, 'generated_at').text = datetime.datetime.now().strftime("%Y-%m-%d %H:%M")
-            xml_movement  =  ET.SubElement(xmlroot, 'movement')
+            xmlroot = ET.Element('report')
+            ET.SubElement(xmlroot, 'generator').text = __revision__
+            ET.SubElement(xmlroot, 'created_at').text = datetime.datetime.now().strftime("%Y-%m-%d %H:%M")
+            xml_movement = ET.SubElement(xmlroot, 'movement')
             ET.SubElement(xml_movement, "location_from").text = unicode(movement.location_from)
             return xmlroot
         """
@@ -152,20 +107,13 @@ def get_report(self):
 
     def generate_pdf_server(self, design, xpath, xmldata, multi=False):
         """Generate report via pyJasperServer."""
-        url = self.serverurl
         if multi:
-            content_type, content = encode_multipart_formdata(fields=dict(designs=design, xpath=xpath,
-                                                                      xmldata=xmldata))
+            content = dict(designs=design, xpath=xpath, xmldata=xmldata)
         else:
-            content_type, content = encode_multipart_formdata(fields=dict(design=design, xpath=xpath,
-                                                                      xmldata=xmldata))
+            content = dict(design=design, xpath=xpath, xmldata=xmldata)
+        status, _headers, content = fetch(self.serverurl, content, 'POST')
 
-        logging.info('POSTing %d bytes to %s' % (len(content), url))
-        start = time.time()
-        status, content = fetch(url, content, content_type)
-        logging.debug('POSTing to %s took %f seconds' % (url, time.time()-start))
-
-        if not status == '200':
+        if not status == 200:
             raise JasperException("%s -- %r" % (content, status))
         return content
 
@@ -180,3 +128,67 @@ def generate_pdf(self, data=None):
     def generate(self, data=None):
         """Generates a report, returns the PDF."""
         return self.generate_pdf(data)
+
+
+def generate_report(reportdesign, xpath, xmldata, url=None):
+        url = _find_server(url)
+        content = dict(design=reportdesign, xpath=xpath, xmldata=xmldata)
+        status, _headers, content = fetch(url, content, 'POST')
+        if not status == 200:
+            raise JasperException("%s -- %r" % (content, status))
+        # remove Timestamps so the same reports hash the same.
+        return re.sub("/(ModDate|CreationDate)\(D:\d{14}[+-]\d{2}'\d{2}'\)", '', content)
+
+
+
+_testreport = """<?xml version="1.0" encoding="UTF-8"?>
+        <jasperReport xmlns="http://jasperreports.sourceforge.net/jasperreports" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://jasperreports.sourceforge.net/jasperreports http://jasperreports.sourceforge.net/xsd/jasperreport.xsd" name="Lieferschein" pageWidth="595" pageHeight="842" columnWidth="483" leftMargin="56" rightMargin="56" topMargin="70" bottomMargin="28" whenResourceMissingType="Key">
+            <queryString language="xPath"><![CDATA[/elements/element]]></queryString>
+            <field name="testdata" class="java.lang.String">
+                <fieldDescription><![CDATA[*/data]]></fieldDescription>
+            </field>
+            <detail>
+                <band height="32">
+                    <staticText>
+                        <reportElement x="20" y="20" width="200" height="10"/>
+                        <text><![CDATA[Hello World!]]></text>
+                    </staticText>
+                    <textField isBlankWhenNull="true">
+                        <reportElement key="field-1" x="36" y="0" width="300" height="10"/>
+                        <textElement><font size="8"/></textElement>
+                        <textFieldExpression class="java.lang.String"><![CDATA[$F{testdata}]]></textFieldExpression>
+                    </textField>
+                </band>
+            </detail>
+        </jasperReport>
+        """
+
+
+class _TestGenerator(JasperGenerator):
+    def generate_xml(self, dummy):
+        self.xpath = '/elements/element'
+        xmlroot = ET.Element('elements')
+        xml_movement = ET.SubElement(xmlroot, 'element')
+        ET.SubElement(xml_movement, "data").text = unicode('TESTTEXT')
+        return xmlroot
+
+    def get_report(self):
+        # unfortunately this example data always generates an empty report. Why?
+        # it's at least enough for testing
+        self.reportname = 'Nada'
+        return _testreport
+
+
+class testTests(unittest.TestCase):
+    def test_legacy_class(self):
+        gen = _TestGenerator()
+        content = gen.generate()
+
+    def test_function(self):
+        content = generate_report(_testreport, 
+                                  '/elements/element',
+                                  '<elements><element><data>TEST</data></element></elements>')
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/huTools/rest.py b/huTools/rest.py
index 7da2059..60b8e94 100755
--- a/huTools/rest.py
+++ b/huTools/rest.py
@@ -7,7 +7,7 @@
 Copyright (c) 2010 HUDORA. All rights reserved.
 """
 
-import httplib2
+import huTools.http._httplib2 as httplib2
 import os
 import tempfile
 import urllib
@@ -73,6 +73,7 @@ def __init__(self, username, password, endpoint=None):
         self.password = password
         self.endpoint = endpoint
         
+        # TODO: move to huTools.http.fetch
         cachedir = os.path.join(tempfile.gettempdir(), 'robotrock')
         self.connection = httplib2.Http(cache=cachedir, timeout=20)
         self.connection.add_credentials(username, password, domain=urlparse.urlsplit(self.endpoint).netloc)
diff --git a/requirements.txt b/requirements.txt
index c3f07d3..5e52096 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -1,2 +1,2 @@
 decorator
-http://pypi.python.org/packages/source/s/simplejson/simplejson-2.0.9.tar.gz
\ No newline at end of file
+http://pypi.python.org/packages/source/s/simplejson/simplejson-2.0.9.tar.gz