754 lines
27 KiB
Python
754 lines
27 KiB
Python
from __future__ import absolute_import
|
|
|
|
import datetime
|
|
import os
|
|
import re
|
|
import sys
|
|
import time
|
|
import warnings
|
|
|
|
from io import BytesIO
|
|
from pprint import pformat
|
|
from urllib import urlencode, quote
|
|
from urlparse import urljoin, parse_qsl
|
|
|
|
import Cookie
|
|
# Some versions of Python 2.7 and later won't need this encoding bug fix:
|
|
_cookie_encodes_correctly = Cookie.SimpleCookie().value_encode(';') == (';', '"\\073"')
|
|
# See ticket #13007, http://bugs.python.org/issue2193 and http://trac.edgewall.org/ticket/2256
|
|
_tc = Cookie.SimpleCookie()
|
|
try:
|
|
_tc.load('foo:bar=1')
|
|
_cookie_allows_colon_in_names = True
|
|
except Cookie.CookieError:
|
|
_cookie_allows_colon_in_names = False
|
|
|
|
if _cookie_encodes_correctly and _cookie_allows_colon_in_names:
|
|
SimpleCookie = Cookie.SimpleCookie
|
|
else:
|
|
Morsel = Cookie.Morsel
|
|
|
|
class SimpleCookie(Cookie.SimpleCookie):
|
|
if not _cookie_encodes_correctly:
|
|
def value_encode(self, val):
|
|
# Some browsers do not support quoted-string from RFC 2109,
|
|
# including some versions of Safari and Internet Explorer.
|
|
# These browsers split on ';', and some versions of Safari
|
|
# are known to split on ', '. Therefore, we encode ';' and ','
|
|
|
|
# SimpleCookie already does the hard work of encoding and decoding.
|
|
# It uses octal sequences like '\\012' for newline etc.
|
|
# and non-ASCII chars. We just make use of this mechanism, to
|
|
# avoid introducing two encoding schemes which would be confusing
|
|
# and especially awkward for javascript.
|
|
|
|
# NB, contrary to Python docs, value_encode returns a tuple containing
|
|
# (real val, encoded_val)
|
|
val, encoded = super(SimpleCookie, self).value_encode(val)
|
|
|
|
encoded = encoded.replace(";", "\\073").replace(",","\\054")
|
|
# If encoded now contains any quoted chars, we need double quotes
|
|
# around the whole string.
|
|
if "\\" in encoded and not encoded.startswith('"'):
|
|
encoded = '"' + encoded + '"'
|
|
|
|
return val, encoded
|
|
|
|
if not _cookie_allows_colon_in_names:
|
|
def load(self, rawdata):
|
|
self.bad_cookies = set()
|
|
super(SimpleCookie, self).load(rawdata)
|
|
for key in self.bad_cookies:
|
|
del self[key]
|
|
|
|
# override private __set() method:
|
|
# (needed for using our Morsel, and for laxness with CookieError
|
|
def _BaseCookie__set(self, key, real_value, coded_value):
|
|
try:
|
|
M = self.get(key, Morsel())
|
|
M.set(key, real_value, coded_value)
|
|
dict.__setitem__(self, key, M)
|
|
except Cookie.CookieError:
|
|
self.bad_cookies.add(key)
|
|
dict.__setitem__(self, key, Cookie.Morsel())
|
|
|
|
|
|
from django.conf import settings
|
|
from django.core import signing
|
|
from django.core.exceptions import ImproperlyConfigured
|
|
from django.core.files import uploadhandler
|
|
from django.http.multipartparser import MultiPartParser
|
|
from django.http.utils import *
|
|
from django.utils.datastructures import MultiValueDict, ImmutableList
|
|
from django.utils.encoding import smart_str, iri_to_uri, force_unicode
|
|
from django.utils.http import cookie_date
|
|
from django.utils import timezone
|
|
|
|
RESERVED_CHARS="!*'();:@&=+$,/?%#[]"
|
|
|
|
absolute_http_url_re = re.compile(r"^https?://", re.I)
|
|
|
|
class Http404(Exception):
|
|
pass
|
|
|
|
RAISE_ERROR = object()
|
|
|
|
|
|
def build_request_repr(request, path_override=None, GET_override=None,
|
|
POST_override=None, COOKIES_override=None,
|
|
META_override=None):
|
|
"""
|
|
Builds and returns the request's representation string. The request's
|
|
attributes may be overridden by pre-processed values.
|
|
"""
|
|
# Since this is called as part of error handling, we need to be very
|
|
# robust against potentially malformed input.
|
|
try:
|
|
get = (pformat(GET_override)
|
|
if GET_override is not None
|
|
else pformat(request.GET))
|
|
except:
|
|
get = '<could not parse>'
|
|
if request._post_parse_error:
|
|
post = '<could not parse>'
|
|
else:
|
|
try:
|
|
post = (pformat(POST_override)
|
|
if POST_override is not None
|
|
else pformat(request.POST))
|
|
except:
|
|
post = '<could not parse>'
|
|
try:
|
|
cookies = (pformat(COOKIES_override)
|
|
if COOKIES_override is not None
|
|
else pformat(request.COOKIES))
|
|
except:
|
|
cookies = '<could not parse>'
|
|
try:
|
|
meta = (pformat(META_override)
|
|
if META_override is not None
|
|
else pformat(request.META))
|
|
except:
|
|
meta = '<could not parse>'
|
|
path = path_override if path_override is not None else request.path
|
|
return smart_str(u'<%s\npath:%s,\nGET:%s,\nPOST:%s,\nCOOKIES:%s,\nMETA:%s>' %
|
|
(request.__class__.__name__,
|
|
path,
|
|
unicode(get),
|
|
unicode(post),
|
|
unicode(cookies),
|
|
unicode(meta)))
|
|
|
|
class UnreadablePostError(IOError):
|
|
pass
|
|
|
|
class HttpRequest(object):
|
|
"""A basic HTTP request."""
|
|
|
|
# The encoding used in GET/POST dicts. None means use default setting.
|
|
_encoding = None
|
|
_upload_handlers = []
|
|
|
|
def __init__(self):
|
|
self.GET, self.POST, self.COOKIES, self.META, self.FILES = {}, {}, {}, {}, {}
|
|
self.path = ''
|
|
self.path_info = ''
|
|
self.method = None
|
|
self._post_parse_error = False
|
|
|
|
def __repr__(self):
|
|
return build_request_repr(self)
|
|
|
|
def get_host(self):
|
|
"""Returns the HTTP host using the environment or request headers."""
|
|
# We try three options, in order of decreasing preference.
|
|
if settings.USE_X_FORWARDED_HOST and (
|
|
'HTTP_X_FORWARDED_HOST' in self.META):
|
|
host = self.META['HTTP_X_FORWARDED_HOST']
|
|
elif 'HTTP_HOST' in self.META:
|
|
host = self.META['HTTP_HOST']
|
|
else:
|
|
# Reconstruct the host using the algorithm from PEP 333.
|
|
host = self.META['SERVER_NAME']
|
|
server_port = str(self.META['SERVER_PORT'])
|
|
if server_port != (self.is_secure() and '443' or '80'):
|
|
host = '%s:%s' % (host, server_port)
|
|
return host
|
|
|
|
def get_full_path(self):
|
|
# RFC 3986 requires query string arguments to be in the ASCII range.
|
|
# Rather than crash if this doesn't happen, we encode defensively.
|
|
return '%s%s' % (self.path, self.META.get('QUERY_STRING', '') and ('?' + iri_to_uri(self.META.get('QUERY_STRING', ''))) or '')
|
|
|
|
def get_signed_cookie(self, key, default=RAISE_ERROR, salt='', max_age=None):
|
|
"""
|
|
Attempts to return a signed cookie. If the signature fails or the
|
|
cookie has expired, raises an exception... unless you provide the
|
|
default argument in which case that value will be returned instead.
|
|
"""
|
|
try:
|
|
cookie_value = self.COOKIES[key].encode('utf-8')
|
|
except KeyError:
|
|
if default is not RAISE_ERROR:
|
|
return default
|
|
else:
|
|
raise
|
|
try:
|
|
value = signing.get_cookie_signer(salt=key + salt).unsign(
|
|
cookie_value, max_age=max_age)
|
|
except signing.BadSignature:
|
|
if default is not RAISE_ERROR:
|
|
return default
|
|
else:
|
|
raise
|
|
return value
|
|
|
|
def build_absolute_uri(self, location=None):
|
|
"""
|
|
Builds an absolute URI from the location and the variables available in
|
|
this request. If no location is specified, the absolute URI is built on
|
|
``request.get_full_path()``.
|
|
"""
|
|
if not location:
|
|
location = self.get_full_path()
|
|
if not absolute_http_url_re.match(location):
|
|
current_uri = '%s://%s%s' % (self.is_secure() and 'https' or 'http',
|
|
self.get_host(), self.path)
|
|
location = urljoin(current_uri, location)
|
|
return iri_to_uri(location)
|
|
|
|
def _is_secure(self):
|
|
return os.environ.get("HTTPS") == "on"
|
|
|
|
def is_secure(self):
|
|
# First, check the SECURE_PROXY_SSL_HEADER setting.
|
|
if settings.SECURE_PROXY_SSL_HEADER:
|
|
try:
|
|
header, value = settings.SECURE_PROXY_SSL_HEADER
|
|
except ValueError:
|
|
raise ImproperlyConfigured('The SECURE_PROXY_SSL_HEADER setting must be a tuple containing two values.')
|
|
if self.META.get(header, None) == value:
|
|
return True
|
|
|
|
# Failing that, fall back to _is_secure(), which is a hook for
|
|
# subclasses to implement.
|
|
return self._is_secure()
|
|
|
|
def is_ajax(self):
|
|
return self.META.get('HTTP_X_REQUESTED_WITH') == 'XMLHttpRequest'
|
|
|
|
def _set_encoding(self, val):
|
|
"""
|
|
Sets the encoding used for GET/POST accesses. If the GET or POST
|
|
dictionary has already been created, it is removed and recreated on the
|
|
next access (so that it is decoded correctly).
|
|
"""
|
|
self._encoding = val
|
|
if hasattr(self, '_get'):
|
|
del self._get
|
|
if hasattr(self, '_post'):
|
|
del self._post
|
|
|
|
def _get_encoding(self):
|
|
return self._encoding
|
|
|
|
encoding = property(_get_encoding, _set_encoding)
|
|
|
|
def _initialize_handlers(self):
|
|
self._upload_handlers = [uploadhandler.load_handler(handler, self)
|
|
for handler in settings.FILE_UPLOAD_HANDLERS]
|
|
|
|
def _set_upload_handlers(self, upload_handlers):
|
|
if hasattr(self, '_files'):
|
|
raise AttributeError("You cannot set the upload handlers after the upload has been processed.")
|
|
self._upload_handlers = upload_handlers
|
|
|
|
def _get_upload_handlers(self):
|
|
if not self._upload_handlers:
|
|
# If there are no upload handlers defined, initialize them from settings.
|
|
self._initialize_handlers()
|
|
return self._upload_handlers
|
|
|
|
upload_handlers = property(_get_upload_handlers, _set_upload_handlers)
|
|
|
|
def parse_file_upload(self, META, post_data):
|
|
"""Returns a tuple of (POST QueryDict, FILES MultiValueDict)."""
|
|
self.upload_handlers = ImmutableList(
|
|
self.upload_handlers,
|
|
warning = "You cannot alter upload handlers after the upload has been processed."
|
|
)
|
|
parser = MultiPartParser(META, post_data, self.upload_handlers, self.encoding)
|
|
return parser.parse()
|
|
|
|
@property
|
|
def body(self):
|
|
if not hasattr(self, '_body'):
|
|
if self._read_started:
|
|
raise Exception("You cannot access body after reading from request's data stream")
|
|
try:
|
|
self._body = self.read()
|
|
except IOError as e:
|
|
raise UnreadablePostError, e, sys.exc_traceback
|
|
self._stream = BytesIO(self._body)
|
|
return self._body
|
|
|
|
@property
|
|
def raw_post_data(self):
|
|
warnings.warn('HttpRequest.raw_post_data has been deprecated. Use HttpRequest.body instead.', DeprecationWarning)
|
|
return self.body
|
|
|
|
def _mark_post_parse_error(self):
|
|
self._post = QueryDict('')
|
|
self._files = MultiValueDict()
|
|
self._post_parse_error = True
|
|
|
|
def _load_post_and_files(self):
|
|
# Populates self._post and self._files
|
|
if self.method != 'POST':
|
|
self._post, self._files = QueryDict('', encoding=self._encoding), MultiValueDict()
|
|
return
|
|
if self._read_started and not hasattr(self, '_body'):
|
|
self._mark_post_parse_error()
|
|
return
|
|
|
|
if self.META.get('CONTENT_TYPE', '').startswith('multipart'):
|
|
if hasattr(self, '_body'):
|
|
# Use already read data
|
|
data = BytesIO(self._body)
|
|
else:
|
|
data = self
|
|
try:
|
|
self._post, self._files = self.parse_file_upload(self.META, data)
|
|
except:
|
|
# An error occured while parsing POST data. Since when
|
|
# formatting the error the request handler might access
|
|
# self.POST, set self._post and self._file to prevent
|
|
# attempts to parse POST data again.
|
|
# Mark that an error occured. This allows self.__repr__ to
|
|
# be explicit about it instead of simply representing an
|
|
# empty POST
|
|
self._mark_post_parse_error()
|
|
raise
|
|
else:
|
|
self._post, self._files = QueryDict(self.body, encoding=self._encoding), MultiValueDict()
|
|
|
|
## File-like and iterator interface.
|
|
##
|
|
## Expects self._stream to be set to an appropriate source of bytes by
|
|
## a corresponding request subclass (e.g. WSGIRequest).
|
|
## Also when request data has already been read by request.POST or
|
|
## request.body, self._stream points to a BytesIO instance
|
|
## containing that data.
|
|
|
|
def read(self, *args, **kwargs):
|
|
self._read_started = True
|
|
return self._stream.read(*args, **kwargs)
|
|
|
|
def readline(self, *args, **kwargs):
|
|
self._read_started = True
|
|
return self._stream.readline(*args, **kwargs)
|
|
|
|
def xreadlines(self):
|
|
while True:
|
|
buf = self.readline()
|
|
if not buf:
|
|
break
|
|
yield buf
|
|
__iter__ = xreadlines
|
|
|
|
def readlines(self):
|
|
return list(iter(self))
|
|
|
|
class QueryDict(MultiValueDict):
|
|
"""
|
|
A specialized MultiValueDict that takes a query string when initialized.
|
|
This is immutable unless you create a copy of it.
|
|
|
|
Values retrieved from this class are converted from the given encoding
|
|
(DEFAULT_CHARSET by default) to unicode.
|
|
"""
|
|
# These are both reset in __init__, but is specified here at the class
|
|
# level so that unpickling will have valid values
|
|
_mutable = True
|
|
_encoding = None
|
|
|
|
def __init__(self, query_string, mutable=False, encoding=None):
|
|
MultiValueDict.__init__(self)
|
|
if not encoding:
|
|
encoding = settings.DEFAULT_CHARSET
|
|
self.encoding = encoding
|
|
for key, value in parse_qsl((query_string or ''), True): # keep_blank_values=True
|
|
self.appendlist(force_unicode(key, encoding, errors='replace'),
|
|
force_unicode(value, encoding, errors='replace'))
|
|
self._mutable = mutable
|
|
|
|
def _get_encoding(self):
|
|
if self._encoding is None:
|
|
self._encoding = settings.DEFAULT_CHARSET
|
|
return self._encoding
|
|
|
|
def _set_encoding(self, value):
|
|
self._encoding = value
|
|
|
|
encoding = property(_get_encoding, _set_encoding)
|
|
|
|
def _assert_mutable(self):
|
|
if not self._mutable:
|
|
raise AttributeError("This QueryDict instance is immutable")
|
|
|
|
def __setitem__(self, key, value):
|
|
self._assert_mutable()
|
|
key = str_to_unicode(key, self.encoding)
|
|
value = str_to_unicode(value, self.encoding)
|
|
MultiValueDict.__setitem__(self, key, value)
|
|
|
|
def __delitem__(self, key):
|
|
self._assert_mutable()
|
|
super(QueryDict, self).__delitem__(key)
|
|
|
|
def __copy__(self):
|
|
result = self.__class__('', mutable=True, encoding=self.encoding)
|
|
for key, value in dict.items(self):
|
|
dict.__setitem__(result, key, value)
|
|
return result
|
|
|
|
def __deepcopy__(self, memo):
|
|
import copy
|
|
result = self.__class__('', mutable=True, encoding=self.encoding)
|
|
memo[id(self)] = result
|
|
for key, value in dict.items(self):
|
|
dict.__setitem__(result, copy.deepcopy(key, memo), copy.deepcopy(value, memo))
|
|
return result
|
|
|
|
def setlist(self, key, list_):
|
|
self._assert_mutable()
|
|
key = str_to_unicode(key, self.encoding)
|
|
list_ = [str_to_unicode(elt, self.encoding) for elt in list_]
|
|
MultiValueDict.setlist(self, key, list_)
|
|
|
|
def setlistdefault(self, key, default_list=()):
|
|
self._assert_mutable()
|
|
if key not in self:
|
|
self.setlist(key, default_list)
|
|
return MultiValueDict.getlist(self, key)
|
|
|
|
def appendlist(self, key, value):
|
|
self._assert_mutable()
|
|
key = str_to_unicode(key, self.encoding)
|
|
value = str_to_unicode(value, self.encoding)
|
|
MultiValueDict.appendlist(self, key, value)
|
|
|
|
def update(self, other_dict):
|
|
self._assert_mutable()
|
|
f = lambda s: str_to_unicode(s, self.encoding)
|
|
if hasattr(other_dict, 'lists'):
|
|
for key, valuelist in other_dict.lists():
|
|
for value in valuelist:
|
|
MultiValueDict.update(self, {f(key): f(value)})
|
|
else:
|
|
d = dict([(f(k), f(v)) for k, v in other_dict.items()])
|
|
MultiValueDict.update(self, d)
|
|
|
|
def pop(self, key, *args):
|
|
self._assert_mutable()
|
|
return MultiValueDict.pop(self, key, *args)
|
|
|
|
def popitem(self):
|
|
self._assert_mutable()
|
|
return MultiValueDict.popitem(self)
|
|
|
|
def clear(self):
|
|
self._assert_mutable()
|
|
MultiValueDict.clear(self)
|
|
|
|
def setdefault(self, key, default=None):
|
|
self._assert_mutable()
|
|
key = str_to_unicode(key, self.encoding)
|
|
default = str_to_unicode(default, self.encoding)
|
|
return MultiValueDict.setdefault(self, key, default)
|
|
|
|
def copy(self):
|
|
"""Returns a mutable copy of this object."""
|
|
return self.__deepcopy__({})
|
|
|
|
def urlencode(self, safe=None):
|
|
"""
|
|
Returns an encoded string of all query string arguments.
|
|
|
|
:arg safe: Used to specify characters which do not require quoting, for
|
|
example::
|
|
|
|
>>> q = QueryDict('', mutable=True)
|
|
>>> q['next'] = '/a&b/'
|
|
>>> q.urlencode()
|
|
'next=%2Fa%26b%2F'
|
|
>>> q.urlencode(safe='/')
|
|
'next=/a%26b/'
|
|
|
|
"""
|
|
output = []
|
|
if safe:
|
|
encode = lambda k, v: '%s=%s' % ((quote(k, safe), quote(v, safe)))
|
|
else:
|
|
encode = lambda k, v: urlencode({k: v})
|
|
for k, list_ in self.lists():
|
|
k = smart_str(k, self.encoding)
|
|
output.extend([encode(k, smart_str(v, self.encoding))
|
|
for v in list_])
|
|
return '&'.join(output)
|
|
|
|
def parse_cookie(cookie):
|
|
if cookie == '':
|
|
return {}
|
|
if not isinstance(cookie, Cookie.BaseCookie):
|
|
try:
|
|
c = SimpleCookie()
|
|
c.load(cookie)
|
|
except Cookie.CookieError:
|
|
# Invalid cookie
|
|
return {}
|
|
else:
|
|
c = cookie
|
|
cookiedict = {}
|
|
for key in c.keys():
|
|
cookiedict[key] = c.get(key).value
|
|
return cookiedict
|
|
|
|
class BadHeaderError(ValueError):
|
|
pass
|
|
|
|
class HttpResponse(object):
|
|
"""A basic HTTP response, with content and dictionary-accessed headers."""
|
|
|
|
status_code = 200
|
|
|
|
def __init__(self, content='', mimetype=None, status=None,
|
|
content_type=None):
|
|
# _headers is a mapping of the lower-case name to the original case of
|
|
# the header (required for working with legacy systems) and the header
|
|
# value. Both the name of the header and its value are ASCII strings.
|
|
self._headers = {}
|
|
self._charset = settings.DEFAULT_CHARSET
|
|
if mimetype: # For backwards compatibility.
|
|
content_type = mimetype
|
|
if not content_type:
|
|
content_type = "%s; charset=%s" % (settings.DEFAULT_CONTENT_TYPE,
|
|
self._charset)
|
|
self.content = content
|
|
self.cookies = SimpleCookie()
|
|
if status:
|
|
self.status_code = status
|
|
|
|
self['Content-Type'] = content_type
|
|
|
|
def __str__(self):
|
|
"""Full HTTP message, including headers."""
|
|
return '\n'.join(['%s: %s' % (key, value)
|
|
for key, value in self._headers.values()]) \
|
|
+ '\n\n' + self.content
|
|
|
|
def _convert_to_ascii(self, *values):
|
|
"""Converts all values to ascii strings."""
|
|
for value in values:
|
|
if isinstance(value, unicode):
|
|
try:
|
|
value = value.encode('us-ascii')
|
|
except UnicodeError as e:
|
|
e.reason += ', HTTP response headers must be in US-ASCII format'
|
|
raise
|
|
else:
|
|
value = str(value)
|
|
if '\n' in value or '\r' in value:
|
|
raise BadHeaderError("Header values can't contain newlines (got %r)" % (value))
|
|
yield value
|
|
|
|
def __setitem__(self, header, value):
|
|
header, value = self._convert_to_ascii(header, value)
|
|
self._headers[header.lower()] = (header, value)
|
|
|
|
def __delitem__(self, header):
|
|
try:
|
|
del self._headers[header.lower()]
|
|
except KeyError:
|
|
pass
|
|
|
|
def __getitem__(self, header):
|
|
return self._headers[header.lower()][1]
|
|
|
|
def __getstate__(self):
|
|
# SimpleCookie is not pickeable with pickle.HIGHEST_PROTOCOL, so we
|
|
# serialise to a string instead
|
|
state = self.__dict__.copy()
|
|
state['cookies'] = str(state['cookies'])
|
|
return state
|
|
|
|
def __setstate__(self, state):
|
|
self.__dict__.update(state)
|
|
self.cookies = SimpleCookie(self.cookies)
|
|
|
|
def has_header(self, header):
|
|
"""Case-insensitive check for a header."""
|
|
return header.lower() in self._headers
|
|
|
|
__contains__ = has_header
|
|
|
|
def items(self):
|
|
return self._headers.values()
|
|
|
|
def get(self, header, alternate=None):
|
|
return self._headers.get(header.lower(), (None, alternate))[1]
|
|
|
|
def set_cookie(self, key, value='', max_age=None, expires=None, path='/',
|
|
domain=None, secure=False, httponly=False):
|
|
"""
|
|
Sets a cookie.
|
|
|
|
``expires`` can be:
|
|
- a string in the correct format,
|
|
- a naive ``datetime.datetime`` object in UTC,
|
|
- an aware ``datetime.datetime`` object in any time zone.
|
|
If it is a ``datetime.datetime`` object then ``max_age`` will be calculated.
|
|
|
|
"""
|
|
self.cookies[key] = value
|
|
if expires is not None:
|
|
if isinstance(expires, datetime.datetime):
|
|
if timezone.is_aware(expires):
|
|
expires = timezone.make_naive(expires, timezone.utc)
|
|
delta = expires - expires.utcnow()
|
|
# Add one second so the date matches exactly (a fraction of
|
|
# time gets lost between converting to a timedelta and
|
|
# then the date string).
|
|
delta = delta + datetime.timedelta(seconds=1)
|
|
# Just set max_age - the max_age logic will set expires.
|
|
expires = None
|
|
max_age = max(0, delta.days * 86400 + delta.seconds)
|
|
else:
|
|
self.cookies[key]['expires'] = expires
|
|
if max_age is not None:
|
|
self.cookies[key]['max-age'] = max_age
|
|
# IE requires expires, so set it if hasn't been already.
|
|
if not expires:
|
|
self.cookies[key]['expires'] = cookie_date(time.time() +
|
|
max_age)
|
|
if path is not None:
|
|
self.cookies[key]['path'] = path
|
|
if domain is not None:
|
|
self.cookies[key]['domain'] = domain
|
|
if secure:
|
|
self.cookies[key]['secure'] = True
|
|
if httponly:
|
|
self.cookies[key]['httponly'] = True
|
|
|
|
def set_signed_cookie(self, key, value, salt='', **kwargs):
|
|
value = signing.get_cookie_signer(salt=key + salt).sign(value)
|
|
return self.set_cookie(key, value, **kwargs)
|
|
|
|
def delete_cookie(self, key, path='/', domain=None):
|
|
self.set_cookie(key, max_age=0, path=path, domain=domain,
|
|
expires='Thu, 01-Jan-1970 00:00:00 GMT')
|
|
|
|
def _get_content(self):
|
|
if self.has_header('Content-Encoding'):
|
|
return ''.join([str(e) for e in self._container])
|
|
return ''.join([smart_str(e, self._charset) for e in self._container])
|
|
|
|
def _set_content(self, value):
|
|
if hasattr(value, '__iter__'):
|
|
self._container = value
|
|
self._base_content_is_iter = True
|
|
else:
|
|
self._container = [value]
|
|
self._base_content_is_iter = False
|
|
|
|
content = property(_get_content, _set_content)
|
|
|
|
def __iter__(self):
|
|
self._iterator = iter(self._container)
|
|
return self
|
|
|
|
def next(self):
|
|
chunk = next(self._iterator)
|
|
if isinstance(chunk, unicode):
|
|
chunk = chunk.encode(self._charset)
|
|
return str(chunk)
|
|
|
|
def close(self):
|
|
if hasattr(self._container, 'close'):
|
|
self._container.close()
|
|
|
|
# The remaining methods partially implement the file-like object interface.
|
|
# See http://docs.python.org/lib/bltin-file-objects.html
|
|
def write(self, content):
|
|
if self._base_content_is_iter:
|
|
raise Exception("This %s instance is not writable" % self.__class__)
|
|
self._container.append(content)
|
|
|
|
def flush(self):
|
|
pass
|
|
|
|
def tell(self):
|
|
if self._base_content_is_iter:
|
|
raise Exception("This %s instance cannot tell its position" % self.__class__)
|
|
return sum([len(str(chunk)) for chunk in self._container])
|
|
|
|
class HttpResponseRedirect(HttpResponse):
|
|
status_code = 302
|
|
|
|
def __init__(self, redirect_to):
|
|
super(HttpResponseRedirect, self).__init__()
|
|
self['Location'] = iri_to_uri(redirect_to)
|
|
|
|
class HttpResponsePermanentRedirect(HttpResponse):
|
|
status_code = 301
|
|
|
|
def __init__(self, redirect_to):
|
|
super(HttpResponsePermanentRedirect, self).__init__()
|
|
self['Location'] = iri_to_uri(redirect_to)
|
|
|
|
class HttpResponseNotModified(HttpResponse):
|
|
status_code = 304
|
|
|
|
class HttpResponseBadRequest(HttpResponse):
|
|
status_code = 400
|
|
|
|
class HttpResponseNotFound(HttpResponse):
|
|
status_code = 404
|
|
|
|
class HttpResponseForbidden(HttpResponse):
|
|
status_code = 403
|
|
|
|
class HttpResponseNotAllowed(HttpResponse):
|
|
status_code = 405
|
|
|
|
def __init__(self, permitted_methods):
|
|
super(HttpResponseNotAllowed, self).__init__()
|
|
self['Allow'] = ', '.join(permitted_methods)
|
|
|
|
class HttpResponseGone(HttpResponse):
|
|
status_code = 410
|
|
|
|
class HttpResponseServerError(HttpResponse):
|
|
status_code = 500
|
|
|
|
# A backwards compatible alias for HttpRequest.get_host.
|
|
def get_host(request):
|
|
return request.get_host()
|
|
|
|
# It's neither necessary nor appropriate to use
|
|
# django.utils.encoding.smart_unicode for parsing URLs and form inputs. Thus,
|
|
# this slightly more restricted function.
|
|
def str_to_unicode(s, encoding):
|
|
"""
|
|
Converts basestring objects to unicode, using the given encoding. Illegally
|
|
encoded input characters are replaced with Unicode "unknown" codepoint
|
|
(\ufffd).
|
|
|
|
Returns any non-basestring objects without change.
|
|
"""
|
|
if isinstance(s, str):
|
|
return unicode(s, encoding, 'replace')
|
|
else:
|
|
return s
|
|
|