deleted file mode 100644

@@ -1,1545 +0,0 @@

-# -*- test-case-name: twisted.web.test.test_http -*-

-# Copyright (c) 2001-2008 Twisted Matrix Laboratories.

-# See LICENSE for details.

-

-"""

-HyperText Transfer Protocol implementation.

-

-This is used by twisted.web.

-

-Future Plans:

- - HTTP client support will at some point be refactored to support HTTP/1.1.

- - Accept chunked data from clients in server.

- - Other missing HTTP features from the RFC.

-

-Maintainer: Itamar Shtull-Trauring

-"""

-

-# system imports

-from cStringIO import StringIO

-import tempfile

-import base64, binascii

-import cgi

-import socket

-import math

-import time

-import calendar

-import warnings

-import os

-from urlparse import urlparse as _urlparse

-

-from zope.interface import implements

-

-# twisted imports

-from twisted.internet import interfaces, reactor, protocol, address

-from twisted.protocols import policies, basic

-from twisted.python import log

-try: # try importing the fast, C version

-    from twisted.protocols._c_urlarg import unquote

-except ImportError:

-    from urllib import unquote

-

-from twisted.web.http_headers import _DictHeaders, Headers

-

-protocol_version = "HTTP/1.1"

-

-_CONTINUE = 100

-SWITCHING = 101

-

-OK                              = 200

-CREATED                         = 201

-ACCEPTED                        = 202

-NON_AUTHORITATIVE_INFORMATION   = 203

-NO_CONTENT                      = 204

-RESET_CONTENT                   = 205

-PARTIAL_CONTENT                 = 206

-MULTI_STATUS                    = 207

-

-MULTIPLE_CHOICE                 = 300

-MOVED_PERMANENTLY               = 301

-FOUND                           = 302

-SEE_OTHER                       = 303

-NOT_MODIFIED                    = 304

-USE_PROXY                       = 305

-TEMPORARY_REDIRECT              = 307

-

-BAD_REQUEST                     = 400

-UNAUTHORIZED                    = 401

-PAYMENT_REQUIRED                = 402

-FORBIDDEN                       = 403

-NOT_FOUND                       = 404

-NOT_ALLOWED                     = 405

-NOT_ACCEPTABLE                  = 406

-PROXY_AUTH_REQUIRED             = 407

-REQUEST_TIMEOUT                 = 408

-CONFLICT                        = 409

-GONE                            = 410

-LENGTH_REQUIRED                 = 411

-PRECONDITION_FAILED             = 412

-REQUEST_ENTITY_TOO_LARGE        = 413

-REQUEST_URI_TOO_LONG            = 414

-UNSUPPORTED_MEDIA_TYPE          = 415

-REQUESTED_RANGE_NOT_SATISFIABLE = 416

-EXPECTATION_FAILED              = 417

-

-INTERNAL_SERVER_ERROR           = 500

-NOT_IMPLEMENTED                 = 501

-BAD_GATEWAY                     = 502

-SERVICE_UNAVAILABLE             = 503

-GATEWAY_TIMEOUT                 = 504

-HTTP_VERSION_NOT_SUPPORTED      = 505

-INSUFFICIENT_STORAGE_SPACE      = 507

-NOT_EXTENDED                    = 510

-

-RESPONSES = {

-    # 100

-    _CONTINUE: "Continue",

-    SWITCHING: "Switching Protocols",

-

-    # 200

-    OK: "OK",

-    CREATED: "Created",

-    ACCEPTED: "Accepted",

-    NON_AUTHORITATIVE_INFORMATION: "Non-Authoritative Information",

-    NO_CONTENT: "No Content",

-    RESET_CONTENT: "Reset Content.",

-    PARTIAL_CONTENT: "Partial Content",

-    MULTI_STATUS: "Multi-Status",

-

-    # 300

-    MULTIPLE_CHOICE: "Multiple Choices",

-    MOVED_PERMANENTLY: "Moved Permanently",

-    FOUND: "Found",

-    SEE_OTHER: "See Other",

-    NOT_MODIFIED: "Not Modified",

-    USE_PROXY: "Use Proxy",

-    # 306 not defined??

-    TEMPORARY_REDIRECT: "Temporary Redirect",

-

-    # 400

-    BAD_REQUEST: "Bad Request",

-    UNAUTHORIZED: "Unauthorized",

-    PAYMENT_REQUIRED: "Payment Required",

-    FORBIDDEN: "Forbidden",

-    NOT_FOUND: "Not Found",

-    NOT_ALLOWED: "Method Not Allowed",

-    NOT_ACCEPTABLE: "Not Acceptable",

-    PROXY_AUTH_REQUIRED: "Proxy Authentication Required",

-    REQUEST_TIMEOUT: "Request Time-out",

-    CONFLICT: "Conflict",

-    GONE: "Gone",

-    LENGTH_REQUIRED: "Length Required",

-    PRECONDITION_FAILED: "Precondition Failed",

-    REQUEST_ENTITY_TOO_LARGE: "Request Entity Too Large",

-    REQUEST_URI_TOO_LONG: "Request-URI Too Long",

-    UNSUPPORTED_MEDIA_TYPE: "Unsupported Media Type",

-    REQUESTED_RANGE_NOT_SATISFIABLE: "Requested Range not satisfiable",

-    EXPECTATION_FAILED: "Expectation Failed",

-

-    # 500

-    INTERNAL_SERVER_ERROR: "Internal Server Error",

-    NOT_IMPLEMENTED: "Not Implemented",

-    BAD_GATEWAY: "Bad Gateway",

-    SERVICE_UNAVAILABLE: "Service Unavailable",

-    GATEWAY_TIMEOUT: "Gateway Time-out",

-    HTTP_VERSION_NOT_SUPPORTED: "HTTP Version not supported",

-    INSUFFICIENT_STORAGE_SPACE: "Insufficient Storage Space",

-    NOT_EXTENDED: "Not Extended"

-    }

-

-CACHED = """Magic constant returned by http.Request methods to set cache

-validation headers when the request is conditional and the value fails

-the condition."""

-

-# backwards compatability

-responses = RESPONSES

-

-

-# datetime parsing and formatting

-weekdayname = ['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun']

-monthname = [None,

-             'Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun',

-             'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec']

-weekdayname_lower = [name.lower() for name in weekdayname]

-monthname_lower = [name and name.lower() for name in monthname]

-

-def urlparse(url):

-    """

-    Parse an URL into six components.

-

-    This is similar to L{urlparse.urlparse}, but rejects C{unicode} input

-    and always produces C{str} output.

-

-    @type url: C{str}

-

-    @raise TypeError: The given url was a C{unicode} string instead of a

-    C{str}.

-

-    @rtype: six-tuple of str

-    @return: The scheme, net location, path, params, query string, and fragment

-    of the URL.

-    """

-    if isinstance(url, unicode):

-        raise TypeError("url must be str, not unicode")

-    scheme, netloc, path, params, query, fragment = _urlparse(url)

-    if isinstance(scheme, unicode):

-        scheme = scheme.encode('ascii')

-        netloc = netloc.encode('ascii')

-        path = path.encode('ascii')

-        query = query.encode('ascii')

-        fragment = fragment.encode('ascii')

-    return scheme, netloc, path, params, query, fragment

-

-

-def parse_qs(qs, keep_blank_values=0, strict_parsing=0, unquote=unquote):

-    """like cgi.parse_qs, only with custom unquote function"""

-    d = {}

-    items = [s2 for s1 in qs.split("&") for s2 in s1.split(";")]

-    for item in items:

-        try:

-            k, v = item.split("=", 1)

-        except ValueError:

-            if strict_parsing:

-                raise

-            continue

-        if v or keep_blank_values:

-            k = unquote(k.replace("+", " "))

-            v = unquote(v.replace("+", " "))

-            if k in d:

-                d[k].append(v)

-            else:

-                d[k] = [v]

-    return d

-

-def datetimeToString(msSinceEpoch=None):

-    """Convert seconds since epoch to HTTP datetime string."""

-    if msSinceEpoch == None:

-        msSinceEpoch = time.time()

-    year, month, day, hh, mm, ss, wd, y, z = time.gmtime(msSinceEpoch)

-    s = "%s, %02d %3s %4d %02d:%02d:%02d GMT" % (

-        weekdayname[wd],

-        day, monthname[month], year,

-        hh, mm, ss)

-    return s

-

-def datetimeToLogString(msSinceEpoch=None):

-    """Convert seconds since epoch to log datetime string."""

-    if msSinceEpoch == None:

-        msSinceEpoch = time.time()

-    year, month, day, hh, mm, ss, wd, y, z = time.gmtime(msSinceEpoch)

-    s = "[%02d/%3s/%4d:%02d:%02d:%02d +0000]" % (

-        day, monthname[month], year,

-        hh, mm, ss)

-    return s

-

-

-# a hack so we don't need to recalculate log datetime every hit,

-# at the price of a small, unimportant, inaccuracy.

-_logDateTime = None

-_logDateTimeUsers = 0

-_resetLogDateTimeID = None

-

-def _resetLogDateTime():

-    global _logDateTime

-    global _resetLogDateTime

-    global _resetLogDateTimeID

-    _logDateTime = datetimeToLogString()

-    _resetLogDateTimeID = reactor.callLater(1, _resetLogDateTime)

-

-def _logDateTimeStart():

-    global _logDateTimeUsers

-    if not _logDateTimeUsers:

-        _resetLogDateTime()

-    _logDateTimeUsers += 1

-

-def _logDateTimeStop():

-    global _logDateTimeUsers

-    _logDateTimeUsers -= 1;

-    if (not _logDateTimeUsers and _resetLogDateTimeID

-        and _resetLogDateTimeID.active()):

-        _resetLogDateTimeID.cancel()

-

-def timegm(year, month, day, hour, minute, second):

-    """Convert time tuple in GMT to seconds since epoch, GMT"""

-    EPOCH = 1970

-    assert year >= EPOCH

-    assert 1 <= month <= 12

-    days = 365*(year-EPOCH) + calendar.leapdays(EPOCH, year)

-    for i in range(1, month):

-        days = days + calendar.mdays[i]

-    if month > 2 and calendar.isleap(year):

-        days = days + 1

-    days = days + day - 1

-    hours = days*24 + hour

-    minutes = hours*60 + minute

-    seconds = minutes*60 + second

-    return seconds

-

-def stringToDatetime(dateString):

-    """Convert an HTTP date string (one of three formats) to seconds since epoch."""

-    parts = dateString.split()

-

-    if not parts[0][0:3].lower() in weekdayname_lower:

-        # Weekday is stupid. Might have been omitted.

-        try:

-            return stringToDatetime("Sun, "+dateString)

-        except ValueError:

-            # Guess not.

-            pass

-

-    partlen = len(parts)

-    if (partlen == 5 or partlen == 6) and parts[1].isdigit():

-        # 1st date format: Sun, 06 Nov 1994 08:49:37 GMT

-        # (Note: "GMT" is literal, not a variable timezone)

-        # (also handles without "GMT")

-        # This is the normal format

-        day = parts[1]

-        month = parts[2]

-        year = parts[3]

-        time = parts[4]

-    elif (partlen == 3 or partlen == 4) and parts[1].find('-') != -1:

-        # 2nd date format: Sunday, 06-Nov-94 08:49:37 GMT

-        # (Note: "GMT" is literal, not a variable timezone)

-        # (also handles without without "GMT")

-        # Two digit year, yucko.

-        day, month, year = parts[1].split('-')

-        time = parts[2]

-        year=int(year)

-        if year < 69:

-            year = year + 2000

-        elif year < 100:

-            year = year + 1900

-    elif len(parts) == 5:

-        # 3rd date format: Sun Nov  6 08:49:37 1994

-        # ANSI C asctime() format.

-        day = parts[2]

-        month = parts[1]

-        year = parts[4]

-        time = parts[3]

-    else:

-        raise ValueError("Unknown datetime format %r" % dateString)

-

-    day = int(day)

-    month = int(monthname_lower.index(month.lower()))

-    year = int(year)

-    hour, min, sec = map(int, time.split(':'))

-    return int(timegm(year, month, day, hour, min, sec))

-

-def toChunk(data):

-    """Convert string to a chunk.

-

-    @returns: a tuple of strings representing the chunked encoding of data"""

-    return ("%x\r\n" % len(data), data, "\r\n")

-

-def fromChunk(data):

-    """Convert chunk to string.

-

-    @returns: tuple (result, remaining), may raise ValueError.

-    """

-    prefix, rest = data.split('\r\n', 1)

-    length = int(prefix, 16)

-    if length < 0:

-        raise ValueError("Chunk length must be >= 0, not %d" % (length,))

-    if not rest[length:length + 2] == '\r\n':

-        raise ValueError, "chunk must end with CRLF"

-    return rest[:length], rest[length + 2:]

-

-

-def parseContentRange(header):

-    """Parse a content-range header into (start, end, realLength).

-

-    realLength might be None if real length is not known ('*').

-    """

-    kind, other = header.strip().split()

-    if kind.lower() != "bytes":

-        raise ValueError, "a range of type %r is not supported"

-    startend, realLength = other.split("/")

-    start, end = map(int, startend.split("-"))

-    if realLength == "*":

-        realLength = None

-    else:

-        realLength = int(realLength)

-    return (start, end, realLength)

-

-

-class StringTransport:

-    """

-    I am a StringIO wrapper that conforms for the transport API. I support

-    the `writeSequence' method.

-    """

-    def __init__(self):

-        self.s = StringIO()

-    def writeSequence(self, seq):

-        self.s.write(''.join(seq))

-    def __getattr__(self, attr):

-        return getattr(self.__dict__['s'], attr)

-

-

-class HTTPClient(basic.LineReceiver):

-    """A client for HTTP 1.0

-

-    Notes:

-    You probably want to send a 'Host' header with the name of

-    the site you're connecting to, in order to not break name

-    based virtual hosting.

-    """

-    length = None

-    firstLine = 1

-    __buffer = None

-

-    def sendCommand(self, command, path):

-        self.transport.write('%s %s HTTP/1.0\r\n' % (command, path))

-

-    def sendHeader(self, name, value):

-        self.transport.write('%s: %s\r\n' % (name, value))

-

-    def endHeaders(self):

-        self.transport.write('\r\n')

-

-    def lineReceived(self, line):

-        if self.firstLine:

-            self.firstLine = 0

-            l = line.split(None, 2)

-            version = l[0]

-            status = l[1]

-            try:

-                message = l[2]

-            except IndexError:

-                # sometimes there is no message

-                message = ""

-            self.handleStatus(version, status, message)

-            return

-        if line:

-            key, val = line.split(':', 1)

-            val = val.lstrip()

-            self.handleHeader(key, val)

-            if key.lower() == 'content-length':

-                self.length = int(val)

-        else:

-            self.__buffer = StringIO()

-            self.handleEndHeaders()

-            self.setRawMode()

-

-    def connectionLost(self, reason):

-        self.handleResponseEnd()

-

-    def handleResponseEnd(self):

-        if self.__buffer is not None:

-            b = self.__buffer.getvalue()

-            self.__buffer = None

-            self.handleResponse(b)

-

-    def handleResponsePart(self, data):

-        self.__buffer.write(data)

-

-    def connectionMade(self):

-        pass

-

-    def handleStatus(self, version, status, message):

-        """

-        Called when the status-line is received.

-

-        @param version: e.g. 'HTTP/1.0'

-        @param status: e.g. '200'

-        @type status: C{str}

-        @param message: e.g. 'OK'

-        """

-

-    def handleHeader(self, key, val):

-        """

-        Called every time a header is received.

-        """

-

-    def handleEndHeaders(self):

-        """

-        Called when all headers have been received.

-        """

-

-

-    def rawDataReceived(self, data):

-        if self.length is not None:

-            data, rest = data[:self.length], data[self.length:]

-            self.length -= len(data)

-        else:

-            rest = ''

-        self.handleResponsePart(data)

-        if self.length == 0:

-            self.handleResponseEnd()

-            self.setLineMode(rest)

-

-

-

-# response codes that must have empty bodies

-NO_BODY_CODES = (204, 304)

-

-class Request:

-    """

-    A HTTP request.

-

-    Subclasses should override the process() method to determine how

-    the request will be processed.

-

-    @ivar method: The HTTP method that was used.

-    @ivar uri: The full URI that was requested (includes arguments).

-    @ivar path: The path only (arguments not included).

-    @ivar args: All of the arguments, including URL and POST arguments.

-    @type args: A mapping of strings (the argument names) to lists of values.

-                i.e., ?foo=bar&foo=baz&quux=spam results in

-                {'foo': ['bar', 'baz'], 'quux': ['spam']}.

-

-    @type requestHeaders: L{http_headers.Headers}

-    @ivar requestHeaders: All received HTTP request headers.

-

-    @ivar received_headers: Backwards-compatibility access to

-        C{requestHeaders}.  Use C{requestHeaders} instead.  C{received_headers}

-        behaves mostly like a C{dict} and does not provide access to all header

-        values.

-

-    @type responseHeaders: L{http_headers.Headers}

-    @ivar responseHeaders: All HTTP response headers to be sent.

-

-    @ivar headers: Backwards-compatibility access to C{responseHeaders}.  Use

-        C{responseHeaders} instead.  C{headers} behaves mostly like a C{dict}

-        and does not provide access to all header values nor does it allow

-        multiple values for one header to be set.

-    """

-    implements(interfaces.IConsumer)

-

-    producer = None

-    finished = 0

-    code = OK

-    code_message = RESPONSES[OK]

-    method = "(no method yet)"

-    clientproto = "(no clientproto yet)"

-    uri = "(no uri yet)"

-    startedWriting = 0

-    chunked = 0

-    sentLength = 0 # content-length of response, or total bytes sent via chunking

-    etag = None

-    lastModified = None

-    _forceSSL = 0

-

-    def __init__(self, channel, queued):

-        """

-        @param channel: the channel we're connected to.

-        @param queued: are we in the request queue, or can we start writing to

-            the transport?

-        """

-        self.channel = channel

-        self.queued = queued

-        self.requestHeaders = Headers()

-        self.received_cookies = {}

-        self.responseHeaders = Headers()

-        self.cookies = [] # outgoing cookies

-

-        if queued:

-            self.transport = StringTransport()

-        else:

-            self.transport = self.channel.transport

-

-

-    def __setattr__(self, name, value):

-        """

-        Support assignment of C{dict} instances to C{received_headers} for

-        backwards-compatibility.

-        """

-        if name == 'received_headers':

-            # A property would be nice, but Request is classic.

-            self.requestHeaders = headers = Headers()

-            for k, v in value.iteritems():

-                headers.setRawHeaders(k, [v])

-        elif name == 'requestHeaders':

-            self.__dict__[name] = value

-            self.__dict__['received_headers'] = _DictHeaders(value)

-        elif name == 'headers':

-            self.responseHeaders = headers = Headers()

-            for k, v in value.iteritems():

-                headers.setRawHeaders(k, [v])

-        elif name == 'responseHeaders':

-            self.__dict__[name] = value

-            self.__dict__['headers'] = _DictHeaders(value)

-        else:

-            self.__dict__[name] = value

-

-

-    def _cleanup(self):

-        """Called when have finished responding and are no longer queued."""

-        if self.producer:

-            log.err(RuntimeError("Producer was not unregistered for %s" % self.uri))

-            self.unregisterProducer()

-        self.channel.requestDone(self)

-        del self.channel

-        try:

-            self.content.close()

-        except OSError:

-            # win32 suckiness, no idea why it does this

-            pass

-        del self.content

-

-    # methods for channel - end users should not use these

-

-    def noLongerQueued(self):

-        """Notify the object that it is no longer queued.

-

-        We start writing whatever data we have to the transport, etc.

-

-        This method is not intended for users.

-        """

-        if not self.queued:

-            raise RuntimeError, "noLongerQueued() got called unnecessarily."

-

-        self.queued = 0

-

-        # set transport to real one and send any buffer data

-        data = self.transport.getvalue()

-        self.transport = self.channel.transport

-        if data:

-            self.transport.write(data)

-

-        # if we have producer, register it with transport

-        if (self.producer is not None) and not self.finished:

-            self.transport.registerProducer(self.producer, self.streamingProducer)

-

-        # if we're finished, clean up

-        if self.finished:

-            self._cleanup()

-

-    def gotLength(self, length):

-        """

-        Called when HTTP channel got length of content in this request.

-

-        This method is not intended for users.

-

-        @param length: The length of the request body, as indicated by the

-            request headers.  C{None} if the request headers do not indicate a

-            length.

-        """

-        if length is not None and length < 100000:

-            self.content = StringIO()

-        else:

-            self.content = tempfile.TemporaryFile()

-

-

-    def parseCookies(self):

-        """

-        Parse cookie headers.

-

-        This method is not intended for users.

-        """

-        cookieheaders = self.requestHeaders.getRawHeaders("cookie")

-

-        if cookieheaders is None:

-            return

-

-        for cookietxt in cookieheaders:

-            if cookietxt:

-                for cook in cookietxt.split(';'):

-                    cook = cook.lstrip()

-                    try:

-                        k, v = cook.split('=', 1)

-                        self.received_cookies[k] = v

-                    except ValueError:

-                        pass

-

-

-    def handleContentChunk(self, data):

-        """Write a chunk of data.

-

-        This method is not intended for users.

-        """

-        self.content.write(data)

-

-

-    def requestReceived(self, command, path, version):

-        """

-        Called by channel when all data has been received.

-

-        This method is not intended for users.

-

-        @type command: C{str}

-        @param command: The HTTP verb of this request.  This has the case

-            supplied by the client (eg, it maybe "get" rather than "GET").

-

-        @type path: C{str}

-        @param path: The URI of this request.

-

-        @type version: C{str}

-        @param version: The HTTP version of this request.

-        """

-        self.content.seek(0,0)

-        self.args = {}

-        self.stack = []

-

-        self.method, self.uri = command, path

-        self.clientproto = version

-        x = self.uri.split('?', 1)

-

-        if len(x) == 1:

-            self.path = self.uri

-        else:

-            self.path, argstring = x

-            self.args = parse_qs(argstring, 1)

-

-        # cache the client and server information, we'll need this later to be

-        # serialized and sent with the request so CGIs will work remotely

-        self.client = self.channel.transport.getPeer()

-        self.host = self.channel.transport.getHost()

-

-        # Argument processing

-        args = self.args

-        ctype = self.requestHeaders.getRawHeaders('content-type')

-        if ctype is not None:

-            ctype = ctype[0]

-

-        if self.method == "POST" and ctype:

-            mfd = 'multipart/form-data'

-            key, pdict = cgi.parse_header(ctype)

-            if key == 'application/x-www-form-urlencoded':

-                args.update(parse_qs(self.content.read(), 1))

-            elif key == mfd:

-                try:

-                    args.update(cgi.parse_multipart(self.content, pdict))

-                except KeyError, e:

-                    if e.args[0] == 'content-disposition':

-                        # Parse_multipart can't cope with missing

-                        # content-dispostion headers in multipart/form-data

-                        # parts, so we catch the exception and tell the client

-                        # it was a bad request.

-                        self.channel.transport.write(

-                                "HTTP/1.1 400 Bad Request\r\n\r\n")

-                        self.channel.transport.loseConnection()

-                        return

-                    raise

-

-        self.process()

-

-

-    def __repr__(self):

-        return '<%s %s %s>'% (self.method, self.uri, self.clientproto)

-

-    def process(self):

-        """Override in subclasses.

-

-        This method is not intended for users.

-        """

-        pass

-

-

-    # consumer interface

-

-    def registerProducer(self, producer, streaming):

-        """Register a producer."""

-        if self.producer:

-            raise ValueError, "registering producer %s before previous one (%s) was unregistered" % (producer, self.producer)

-

-        self.streamingProducer = streaming

-        self.producer = producer

-

-        if self.queued:

-            producer.pauseProducing()

-        else:

-            self.transport.registerProducer(producer, streaming)

-

-    def unregisterProducer(self):

-        """Unregister the producer."""

-        if not self.queued:

-            self.transport.unregisterProducer()

-        self.producer = None

-

-    # private http response methods

-

-    def _sendError(self, code, resp=''):

-        self.transport.write('%s %s %s\r\n\r\n' % (self.clientproto, code, resp))

-

-

-    # The following is the public interface that people should be

-    # writing to.

-    def getHeader(self, key):

-        """

-        Get an HTTP request header.

-

-        @type key: C{str}

-        @param key: The name of the header to get the value of.

-

-        @rtype: C{str} or C{NoneType}

-        @return: The value of the specified header, or C{None} if that header

-            was not present in the request.

-        """

-        value = self.requestHeaders.getRawHeaders(key)

-        if value is not None:

-            return value[-1]

-

-

-    def getCookie(self, key):

-        """Get a cookie that was sent from the network.

-        """

-        return self.received_cookies.get(key)

-

-

-    def finish(self):

-        """We are finished writing data."""

-        if self.finished:

-            warnings.warn("Warning! request.finish called twice.", stacklevel=2)

-            return

-

-        if not self.startedWriting:

-            # write headers

-            self.write('')

-

-        if self.chunked:

-            # write last chunk and closing CRLF

-            self.transport.write("0\r\n\r\n")

-

-        # log request

-        if hasattr(self.channel, "factory"):

-            self.channel.factory.log(self)

-

-        self.finished = 1

-        if not self.queued:

-            self._cleanup()

-

-    def write(self, data):

-        """

-        Write some data as a result of an HTTP request.  The first

-        time this is called, it writes out response data.

-

-        @type data: C{str}

-        @param data: Some bytes to be sent as part of the response body.

-        """

-        if not self.startedWriting:

-            self.startedWriting = 1

-            version = self.clientproto

-            l = []

-            l.append('%s %s %s\r\n' % (version, self.code,

-                                       self.code_message))

-            # if we don't have a content length, we send data in

-            # chunked mode, so that we can support pipelining in

-            # persistent connections.

-            if ((version == "HTTP/1.1") and

-                (self.responseHeaders.getRawHeaders('content-length') is None) and

-                self.method != "HEAD" and self.code not in NO_BODY_CODES):

-                l.append("%s: %s\r\n" % ('Transfer-Encoding', 'chunked'))

-                self.chunked = 1

-

-            if self.lastModified is not None:

-                if self.responseHeaders.hasHeader('last-modified'):

-                    log.msg("Warning: last-modified specified both in"

-                            " header list and lastModified attribute.")

-                else:

-                    self.responseHeaders.setRawHeaders(

-                        'last-modified',

-                        [datetimeToString(self.lastModified)])

-

-            if self.etag is not None:

-                self.responseHeaders.setRawHeaders('ETag', [self.etag])

-

-            for name, values in self.responseHeaders.getAllRawHeaders():

-                for value in values:

-                    l.append("%s: %s\r\n" % (name, value))

-

-            for cookie in self.cookies:

-                l.append('%s: %s\r\n' % ("Set-Cookie", cookie))

-

-            l.append("\r\n")

-

-            self.transport.writeSequence(l)

-

-            # if this is a "HEAD" request, we shouldn't return any data

-            if self.method == "HEAD":

-                self.write = lambda data: None

-                return

-

-            # for certain result codes, we should never return any data

-            if self.code in NO_BODY_CODES:

-                self.write = lambda data: None

-                return

-

-        self.sentLength = self.sentLength + len(data)

-        if data:

-            if self.chunked:

-                self.transport.writeSequence(toChunk(data))

-            else:

-                self.transport.write(data)

-

-    def addCookie(self, k, v, expires=None, domain=None, path=None, max_age=None, comment=None, secure=None):

-        """Set an outgoing HTTP cookie.

-

-        In general, you should consider using sessions instead of cookies, see

-        twisted.web.server.Request.getSession and the

-        twisted.web.server.Session class for details.

-        """

-        cookie = '%s=%s' % (k, v)

-        if expires is not None:

-            cookie = cookie +"; Expires=%s" % expires

-        if domain is not None:

-            cookie = cookie +"; Domain=%s" % domain

-        if path is not None:

-            cookie = cookie +"; Path=%s" % path

-        if max_age is not None:

-            cookie = cookie +"; Max-Age=%s" % max_age

-        if comment is not None:

-            cookie = cookie +"; Comment=%s" % comment

-        if secure: