Your IP : 172.28.240.42

Current Path : /usr/lib/python2.7/dist-packages/twisted/protocols/
Upload File :
Current File : //usr/lib/python2.7/dist-packages/twisted/protocols/basic.pyc


Nc@sedZddlZddlmZmZmZddlZddlZddlZddl	m
Z
ddlmZm
Z
mZmZddlmZmZmZed\ZZZejdZejd	d
ddZd
Zx0ddddgD]ZejeeeeqW[[[dZ de!fdYZ"de#fdYZ$dej%fdYZ&dej%fdYZ'dfdYZ(dej%e(fdYZ)de*fdYZ+d e,fd!YZ-d"ej%e(fd#YZ.d$e.fd%YZ/d&e.fd'YZ0d(e.fd)YZ1d*fd+YZ2d,fd-YZ3dS(.sr
Basic protocols, such as line-oriented, netstring, and int prefixed strings.

Maintainer: Itamar Shtull-Trauring
iN(tpacktunpacktcalcsize(t
implements(tprotocoltdefert
interfacesterror(tlogt	deprecatetversionsis	(\d*)(:?)tTwistedi
iis*NetstringReceiver parser state is private.tLENGTHtDATAtCOMMAtNUMBERtNetstringParseErrorcBseZdZRS(s=
    The incoming data is not in valid Netstring format.
    (t__name__t
__module__t__doc__(((s;/usr/lib/python2.7/dist-packages/twisted/protocols/basic.pyR&stIncompleteNetstringcBseZdZRS(s2
    Not enough data to complete a netstring.
    (RRR(((s;/usr/lib/python2.7/dist-packages/twisted/protocols/basic.pyR-stNetstringReceivercBseZdZdZejdZejdZdZdZ	dZ
dZdZe
d	\ZZd
ZdZdZd
ZdZdZdZdZdZdZdZdZdZdZdZdZdZ dZ!RS(sE

    A protocol that sends and receives netstrings.

    See U{http://cr.yp.to/proto/netstrings.txt} for the specification of
    netstrings. Every netstring starts with digits that specify the length
    of the data. This length specification is separated from the data by
    a colon. The data is terminated with a comma.

    Override L{stringReceived} to handle received netstrings. This
    method is called with the netstring payload as a single argument
    whenever a complete netstring is received.

    Security features:
        1. Messages are limited in size, useful if you don't want
           someone sending you a 500MB netstring (change C{self.MAX_LENGTH}
           to the maximum length you wish to accept).
        2. The connection is lost if an illegal message is received.

    @ivar MAX_LENGTH: Defines the maximum length of netstrings that can be
        received.
    @type MAX_LENGTH: C{int}

    @ivar _LENGTH: A pattern describing all strings that contain a netstring
        length specification. Examples for length specifications are '0:',
        '12:', and '179:'. '007:' is no valid length specification, since
        leading zeros are not allowed.
    @type _LENGTH: C{re.Match}

    @ivar _LENGTH_PREFIX: A pattern describing all strings that contain
        the first part of a netstring length specification (without the
        trailing comma). Examples are '0', '12', and '179'. '007' does not
        start a netstring length specification, since leading zeros are
        not allowed.
    @type _LENGTH_PREFIX: C{re.Match}

    @ivar _PARSING_LENGTH: Indicates that the C{NetstringReceiver} is in
        the state of parsing the length portion of a netstring.
    @type _PARSING_LENGTH: C{int}

    @ivar _PARSING_PAYLOAD: Indicates that the C{NetstringReceiver} is in
        the state of parsing the payload portion (data and trailing comma)
        of a netstring.
    @type _PARSING_PAYLOAD: C{int}

    @ivar brokenPeer: Indicates if the connection is still functional
    @type brokenPeer: C{int}

    @ivar _state: Indicates if the protocol is consuming the length portion
        (C{PARSING_LENGTH}) or the payload (C{PARSING_PAYLOAD}) of a netstring
    @type _state: C{int}

    @ivar _remainingData: Holds the chunk of data that has not yet been consumed
    @type _remainingData: C{string}

    @ivar _payload: Holds the payload portion of a netstring including the
        trailing comma
    @type _payload: C{cStringIO.StringIO}

    @ivar _expectedPayloadSize: Holds the payload size plus one for the trailing
        comma.
    @type _expectedPayloadSize: C{int}
    is(0|[1-9]\d*)(:)s
(0|[1-9]\d*)$sBThe received netstring does not start with a length specification.spThe length specification of the received netstring cannot be represented in Python - it causes an OverflowError!sQThe received netstring is longer than the maximum %s specified by self.MAX_LENGTHs4The received netstring is not terminated by a comma.saData passed to sendString() must be a string. Non-string support is deprecated since Twisted 10.0icCsVtjj||d|_d|_tj|_|j|_	d|_
d|_dS(s+
        Initializes the protocol.
        tiN(RtProtocoltmakeConnectiont_remainingDatat_currentPayloadSizet	cStringIOtStringIOt_payloadt_PARSING_LENGTHt_statet_expectedPayloadSizet
brokenPeer(tselft	transport((s;/usr/lib/python2.7/dist-packages/twisted/protocols/basic.pyRs			cCsXt|ts4tj|jtdt|}n|jjdt||fdS(s/
        Sends a netstring.

        Wraps up C{string} by adding length information and a
        trailing comma; writes the result to the transport.

        @param string: The string to send.  The necessary framing (length
            prefix, etc) will be added.
        @type string: C{str}
        is%d:%s,N(	t
isinstancetstrtwarningstwarnt_DATA_SUPPORT_DEPRECATEDtDeprecationWarningR#twritetlen(R"tstring((s;/usr/lib/python2.7/dist-packages/twisted/protocols/basic.pyt
sendStringscCsa|j|7_xK|jr\y|jWqtk
r=Pqtk
rX|jPqXqWdS(s;
        Receives some characters of a netstring.

        Whenever a complete netstring is received, this method extracts
        its payload and calls L{stringReceived} to process it.

        @param data: A chunk of data representing a (possibly partial)
            netstring
        @type data: C{str}
        N(Rt_consumeDataRRt_handleParseError(R"tdata((s;/usr/lib/python2.7/dist-packages/twisted/protocols/basic.pytdataReceiveds


cCs
tdS(s\
        Override this for notification when each complete string is received.

        @param string: The complete string which was received with all
            framing (length prefix, etc) removed.
        @type string: C{str}

        @raise NotImplementedError: because the method has to be implemented
            by the child class.
        N(tNotImplementedError(R"R,((s;/usr/lib/python2.7/dist-packages/twisted/protocols/basic.pytstringReceivedscCstjtj|jdS(s
        Calculate and return the string size of C{self.MAX_LENGTH}.

        @return: The size of the string representation for C{self.MAX_LENGTH}
        @rtype: C{float}
        i(tmathtceiltlog10t
MAX_LENGTH(R"((s;/usr/lib/python2.7/dist-packages/twisted/protocols/basic.pyt_maxLengthSizescCsL|j|jkr)|j|jn|j|jkrH|jndS(s0
        Consumes the content of C{self._remainingData}.

        @raise IncompleteNetstring: if C{self._remainingData} does not
            contain enough data to complete the current netstring.
        @raise NetstringParseError: if the received data do not
            form a valid netstring.
        N(RRt_consumeLengtht_prepareForPayloadConsumptiont_PARSING_PAYLOADt_consumePayload(R"((s;/usr/lib/python2.7/dist-packages/twisted/protocols/basic.pyR.s
	

cCsB|jj|j}|s1|jtn|j|dS(sL
        Consumes the length portion of C{self._remainingData}.

        @raise IncompleteNetstring: if C{self._remainingData} contains
            a partial length specification (digits without trailing
            comma).
        @raise NetstringParseError: if the received data do not form a valid
            netstring.
        N(t_LENGTHtmatchRt _checkPartialLengthSpecificationRt_processLength(R"tlengthMatch((s;/usr/lib/python2.7/dist-packages/twisted/protocols/basic.pyR9s


cCsM|jj|j}|s-t|jn|jd}|j|dS(sA
        Makes sure that the received data represents a valid number.

        Checks if C{self._remainingData} represents a number smaller or
        equal to C{self.MAX_LENGTH}.

        @raise NetstringParseError: if C{self._remainingData} is no
            number or is too big (checked by L{extractLength}).
        iN(t_LENGTH_PREFIXR>RRt_MISSING_LENGTHtgroupt_extractLength(R"tpartialLengthMatchtlengthSpecification((s;/usr/lib/python2.7/dist-packages/twisted/protocols/basic.pyR?s

cCsU|jd}|jd}|j| }|j|d|_|j||_dS(sY
        Processes the length definition of a netstring.

        Extracts and stores in C{self._expectedPayloadSize} the number
        representing the netstring size.  Removes the prefix
        representing the length specification from
        C{self._remainingData}.

        @raise NetstringParseError: if the received netstring does not
            start with a number or the number is bigger than
            C{self.MAX_LENGTH}.
        @param lengthMatch: A regular expression match object matching
            a netstring length specification
        @type lengthMatch: C{re.Match}
        iiN(tendRRER (R"RAtendOfNumbertstartOfDatatlengthString((s;/usr/lib/python2.7/dist-packages/twisted/protocols/basic.pyR@s

cCsH|j|t|}||jkrDt|j|jfn|S(sw
        Attempts to extract the length information of a netstring.

        @raise NetstringParseError: if the number is bigger than
            C{self.MAX_LENGTH}.
        @param lengthAsString: A chunk of data starting with a length
            specification
        @type lengthAsString: C{str}
        @return: The length of the netstring
        @rtype: C{int}
        (t_checkStringSizetintR7Rt	_TOO_LONG(R"tlengthAsStringtlength((s;/usr/lib/python2.7/dist-packages/twisted/protocols/basic.pyREs

cCs8t||jkr4t|j|jfndS(s>
        Checks the sanity of lengthAsString.

        Checks if the size of the length specification exceeds the
        size of the string representing self.MAX_LENGTH. If this is
        not the case, the number represented by lengthAsString is
        certainly bigger than self.MAX_LENGTH, and a
        NetstringParseError can be raised.

        This method should make sure that netstrings with extremely
        long length specifications are refused before even attempting
        to convert them to an integer (which might trigger a
        MemoryError).
        N(R+R8RRNR7(R"RO((s;/usr/lib/python2.7/dist-packages/twisted/protocols/basic.pyRL2scCs6|j|_d|_|jjd|jjdS(sW
        Sets up variables necessary for consuming the payload of a netstring.
        iN(R;RRRtseekttruncate(R"((s;/usr/lib/python2.7/dist-packages/twisted/protocols/basic.pyR:Es	cCsL|j|j|jkr(tn|j|j|_|jdS(s
        Consumes the payload portion of C{self._remainingData}.

        If the payload is complete, checks for the trailing comma and
        processes the payload. If not, raises an L{IncompleteNetstring}
        exception.

        @raise IncompleteNetstring: if the payload received so far
            contains fewer characters than expected.
        @raise NetstringParseError: if the payload does not end with a
        comma.
        N(t_extractPayloadRR Rt_checkForTrailingCommaRRt_processPayload(R"((s;/usr/lib/python2.7/dist-packages/twisted/protocols/basic.pyR<Os

cCs|jrR|j|j}|jj|j| |j||_|j|_n4|jj|j|jt|j7_d|_dS(s
        Extracts payload information from C{self._remainingData}.

        Splits C{self._remainingData} at the end of the netstring.  The
        first part becomes C{self._payload}, the second part is stored
        in C{self._remainingData}.

        If the netstring is not yet complete, the whole content of
        C{self._remainingData} is moved to C{self._payload}.
        RN(t_payloadCompleteR RRR*RR+(R"tremainingPayloadSize((s;/usr/lib/python2.7/dist-packages/twisted/protocols/basic.pyRSds
cCst|j|j|jkS(s

        Checks if enough data have been received to complete the netstring.

        @return: C{True} iff the received data contain at least as many
            characters as specified in the length section of the
            netstring
        @rtype: C{bool}
        (R+RRR (R"((s;/usr/lib/python2.7/dist-packages/twisted/protocols/basic.pyRV{s	cCs|j|jjd dS(s
        Processes the actual payload with L{stringReceived}.

        Strips C{self._payload} of the trailing comma and calls
        L{stringReceived} with the result.
        iN(R3Rtgetvalue(R"((s;/usr/lib/python2.7/dist-packages/twisted/protocols/basic.pyRUscCs/|jjddkr+t|jndS(s
        Checks if the netstring has a trailing comma at the expected position.

        @raise NetstringParseError: if the last payload character is
            anything but a comma.
        it,N(RRXRt_MISSING_COMMA(R"((s;/usr/lib/python2.7/dist-packages/twisted/protocols/basic.pyRTscCs|jjd|_dS(sQ
        Terminates the connection and sets the flag C{self.brokenPeer}.
        iN(R#tloseConnectionR!(R"((s;/usr/lib/python2.7/dist-packages/twisted/protocols/basic.pyR/s
("RRRR7tretcompileR=RBRCt	_OVERFLOWRNRZR(trangeRR;RR-R1R3R8R.R9R?R@RERLR:R<RSRVRURTR/(((s;/usr/lib/python2.7/dist-packages/twisted/protocols/basic.pyR4s8>	
				
							
			
	
	tLineOnlyReceivercBsDeZdZdZdZdZdZdZdZdZ	RS(s
    A protocol that receives only lines.

    This is purely a speed optimisation over LineReceiver, for the
    cases that raw mode is known to be unnecessary.

    @cvar delimiter: The line-ending delimiter to use. By default this is
                     '\r\n'.
    @cvar MAX_LENGTH: The maximum length of a line to allow (If a
                      sent line is longer than this, the connection is dropped).
                      Default is 16384.
    Rs
i@cCs|j|j|j}|jd|_xM|D]E}|jjrHdSt||jkrj|j|S|j	|q2Wt|j|jkr|j|jSdS(sF
        Translates bytes into lines, and calls lineReceived.
        iN(
t_buffertsplitt	delimitertpopR#t
disconnectingR+R7tlineLengthExceededtlineReceived(R"R0tlinestline((s;/usr/lib/python2.7/dist-packages/twisted/protocols/basic.pyR1s

cCs
tdS(s
        Override this for when each line is received.

        @param line: The line which was received with the delimiter removed.
        @type line: C{str}
        N(R2(R"Ri((s;/usr/lib/python2.7/dist-packages/twisted/protocols/basic.pyRgscCs|jj||jfS(s
        Sends a line to the other end of the connection.

        @param line: The line to send, not including the delimiter.
        @type line: C{str}
        (R#t
writeSequenceRc(R"Ri((s;/usr/lib/python2.7/dist-packages/twisted/protocols/basic.pytsendLinescCs
tjdS(s
        Called when the maximum line length has been reached.
        Override if it needs to be dealt with in some special way.
        sLine length exceeded(RtConnectionLost(R"Ri((s;/usr/lib/python2.7/dist-packages/twisted/protocols/basic.pyRfs(
RRRRaRcR7R1RgRkRf(((s;/usr/lib/python2.7/dist-packages/twisted/protocols/basic.pyR`s		
	
t_PauseableMixincBs)eZeZdZdZdZRS(cCst|_|jjdS(N(tTruetpausedR#tpauseProducing(R"((s;/usr/lib/python2.7/dist-packages/twisted/protocols/basic.pyRps	cCs't|_|jj|jddS(NR(tFalseRoR#tresumeProducingR1(R"((s;/usr/lib/python2.7/dist-packages/twisted/protocols/basic.pyRrs	
cCst|_|jjdS(N(RnRoR#t
stopProducing(R"((s;/usr/lib/python2.7/dist-packages/twisted/protocols/basic.pyRss	(RRRqRoRpRrRs(((s;/usr/lib/python2.7/dist-packages/twisted/protocols/basic.pyRms		tLineReceivercBsqeZdZdZdZdZdZdZdZddZ	dZ
d	Zd
ZdZ
dZRS(
s
    A protocol that receives lines and/or raw data, depending on mode.

    In line mode, each line that's received becomes a callback to
    L{lineReceived}.  In raw data mode, each chunk of raw data becomes a
    callback to L{rawDataReceived}.  The L{setLineMode} and L{setRawMode}
    methods switch between the two modes.

    This is useful for line-oriented protocols such as IRC, HTTP, POP, etc.

    @cvar delimiter: The line-ending delimiter to use. By default this is
                     '\r\n'.
    @cvar MAX_LENGTH: The maximum length of a line to allow (If a
                      sent line is longer than this, the connection is dropped).
                      Default is 16384.
    iRs
i@cCs|j}d|_|S(sq
        Clear buffered data.

        @return: All of the cleared buffered data.
        @rtype: C{str}
        R(t_LineReceiver__buffer(R"tb((s;/usr/lib/python2.7/dist-packages/twisted/protocols/basic.pytclearLineBuffers		cCs=|j||_x&|jr|jry%|jj|jd\}|_WnJtk
rt|j|jkr|jd}|_|j|SPqXt|}||jkr||j}d|_|j|S|j	|}|s|j
r|j
jr|SqW|js9|j}d|_|r9|j|SndS(s
        Protocol.dataReceived.
        Translates bytes into lines, and calls lineReceived (or
        rawDataReceived, depending on mode.)
        iRN(
Rut	line_modeRoRbRct
ValueErrorR+R7RfRgR#RetrawDataReceived(R"R0Rit
linelengthtexceededtwhy((s;/usr/lib/python2.7/dist-packages/twisted/protocols/basic.pyR1s,%


	
			cCs d|_|r|j|SdS(s
        Sets the line-mode of this receiver.

        If you are calling this from a rawDataReceived callback,
        you can pass in extra unhandled data, and that data will
        be parsed for lines.  Further data received will be sent
        to lineReceived rather than rawDataReceived.

        Do not pass extra data if calling this function from
        within a lineReceived callback.
        iN(RxR1(R"textra((s;/usr/lib/python2.7/dist-packages/twisted/protocols/basic.pytsetLineMode?s	cCs
d|_dS(s
        Sets the raw mode of this receiver.
        Further data received will be sent to rawDataReceived rather
        than lineReceived.
        iN(Rx(R"((s;/usr/lib/python2.7/dist-packages/twisted/protocols/basic.pyt
setRawModePscCs
tdS(s>
        Override this for when raw data is received.
        N(R2(R"R0((s;/usr/lib/python2.7/dist-packages/twisted/protocols/basic.pyRzYscCs
tdS(s
        Override this for when each line is received.

        @param line: The line which was received with the delimiter removed.
        @type line: C{str}
        N(R2(R"Ri((s;/usr/lib/python2.7/dist-packages/twisted/protocols/basic.pyRg`scCs|jj||jS(s
        Sends a line to the other end of the connection.

        @param line: The line to send, not including the delimiter.
        @type line: C{str}
        (R#R*Rc(R"Ri((s;/usr/lib/python2.7/dist-packages/twisted/protocols/basic.pyRkjscCs
|jjS(sw
        Called when the maximum line length has been reached.
        Override if it needs to be dealt with in some special way.

        The argument 'line' contains the remainder of the buffer, starting
        with (at least some part) of the line which is too long. This may
        be more than one line, or may be only the initial portion of the
        line.
        (R#R[(R"Ri((s;/usr/lib/python2.7/dist-packages/twisted/protocols/basic.pyRfts
(RRRRxRuRcR7RwR1RRRzRgRkRf(((s;/usr/lib/python2.7/dist-packages/twisted/protocols/basic.pyRts		 				
	
tStringTooLongErrorcBseZdZRS(sZ
    Raised when trying to send a string too long for a length prefixed
    protocol.
    (RRR(((s;/usr/lib/python2.7/dist-packages/twisted/protocols/basic.pyRst_RecvdCompatHackcBseZdZddZRS(sK
    Emulates the to-be-deprecated C{IntNStringReceiver.recvd} attribute.

    The C{recvd} attribute was where the working buffer for buffering and
    parsing netstrings was kept.  It was updated each time new data arrived and
    each time some of that data was parsed and delivered to application code.
    The piecemeal updates to its string value were expensive and have been
    removed from C{IntNStringReceiver} in the normal case.  However, for
    applications directly reading this attribute, this descriptor restores that
    behavior.  It only copies the working buffer when necessary (ie, when
    accessed).  This avoids the cost for applications not using the data.

    This is a custom descriptor rather than a property, because we still need
    the default __set__ behavior in both new-style and old-style subclasses.
    cCs|j|jS(N(t_unprocessedt_compatibilityOffset(R"toselfttype((s;/usr/lib/python2.7/dist-packages/twisted/protocols/basic.pyt__get__sN(RRRtNoneR(((s;/usr/lib/python2.7/dist-packages/twisted/protocols/basic.pyRstIntNStringReceivercBsMeZdZdZdZdZeZdZdZ	dZ
dZRS(s,
    Generic class for length prefixed protocols.

    @ivar _unprocessed: bytes received, but not yet broken up into messages /
        sent to stringReceived.  _compatibilityOffset must be updated when this
        value is updated so that the C{recvd} attribute can be generated
        correctly.
    @type _unprocessed: C{bytes}

    @ivar structFormat: format used for struct packing/unpacking. Define it in
        subclass.
    @type structFormat: C{str}

    @ivar prefixLength: length of the prefix, in bytes. Define it in subclass,
        using C{struct.calcsize(structFormat)}
    @type prefixLength: C{int}

    @ivar _compatibilityOffset: the offset within C{_unprocessed} to the next
        message to be parsed. (used to generate the recvd attribute)
    @type _compatibilityOffset: C{int}
    iRicCs
tdS(s
        Override this for notification when each complete string is received.

        @param string: The complete string which was received with all
            framing (length prefix, etc) removed.
        @type string: C{str}
        N(R2(R"R,((s;/usr/lib/python2.7/dist-packages/twisted/protocols/basic.pyR3scCs|jjdS(s
        Callback invoked when a length prefix greater than C{MAX_LENGTH} is
        received.  The default implementation disconnects the transport.
        Override this.

        @param length: The length prefix which was received.
        @type length: C{int}
        N(R#R[(R"RP((s;/usr/lib/python2.7/dist-packages/twisted/protocols/basic.pytlengthLimitExceededs	c
CsT|j|}d}|j}|j}||_x	t|||kr9|jr9||}t||||!\}||jkr||_||_|j|dS||}t||krPn|||!}	|}||_|j	|	d|j
kr1|j
jd}||_d|_}|r2q1ndSq1W|||_d|_dS(sL
        Convert int prefixed strings into calls to stringReceived.
        iNtrecvd(RtprefixLengthtstructFormatR+RoRR7RRR3t__dict__Rd(
R"R0talldatat
currentOffsetRtfmttmessageStartRPt
messageEndtpacket((s;/usr/lib/python2.7/dist-packages/twisted/protocols/basic.pyR1s:
			#
		


	
	

cCsqt|dd|jkrGtdt|dd|jfn|jjt|jt||dS(s
        Send a prefixed string to the other end of the connection.

        @param string: The string to send.  The necessary framing (length
            prefix, etc) will be added.
        @type string: C{str}
        iis*Try to send %s bytes whereas maximum is %sN(R+RRR#R*RR(R"R,((s;/usr/lib/python2.7/dist-packages/twisted/protocols/basic.pyR-s$	(RRRR7RRRRR3RR1R-(((s;/usr/lib/python2.7/dist-packages/twisted/protocols/basic.pyRs				2tInt32StringReceivercBs eZdZdZeeZRS(s
    A receiver for int32-prefixed strings.

    An int32 string is a string prefixed by 4 bytes, the 32-bit length of
    the string encoded in network byte order.

    This class publishes the same interface as NetstringReceiver.
    s!I(RRRRRR(((s;/usr/lib/python2.7/dist-packages/twisted/protocols/basic.pyRstInt16StringReceivercBs eZdZdZeeZRS(s
    A receiver for int16-prefixed strings.

    An int16 string is a string prefixed by 2 bytes, the 16-bit length of
    the string encoded in network byte order.

    This class publishes the same interface as NetstringReceiver.
    s!H(RRRRRR(((s;/usr/lib/python2.7/dist-packages/twisted/protocols/basic.pyR&stInt8StringReceivercBs eZdZdZeeZRS(s
    A receiver for int8-prefixed strings.

    An int8 string is a string prefixed by 1 byte, the 8-bit length of
    the string.

    This class publishes the same interface as NetstringReceiver.
    s!B(RRRRRR(((s;/usr/lib/python2.7/dist-packages/twisted/protocols/basic.pyR4stStatefulStringProtocolcBseZdZdZdZRS(sN
    A stateful string protocol.

    This is a mixin for string protocols (Int32StringReceiver,
    NetstringReceiver) which translates stringReceived into a callback
    (prefixed with 'proto_') depending on state.

    The state 'done' is special; if a proto_* method returns it, the
    connection will be closed immediately.
    tinitcCs|y d|j}t||}Wn'tk
rItjd|jdn/X|||_|jdkrx|jjndS(s
        Choose a protocol phase function and call it.

        Call back to the appropriate protocol phase; this begins with
        the function proto_init and moves on to proto_* depending on
        what each proto_* function returns.  (For example, if
        self.proto_init returns 'foo', then self.proto_foo will be the
        next function called when a protocol message is received.
        tproto_tcallbacks	not foundtdoneN(tstatetgetattrtAttributeErrorRtmsgR#R[(R"R,tptotstatehandler((s;/usr/lib/python2.7/dist-packages/twisted/protocols/basic.pyR3Ps


(RRRRR3(((s;/usr/lib/python2.7/dist-packages/twisted/protocols/basic.pyRBs
t
FileSendercBsTeZdZeejdZdZd	Z	d	dZ
dZdZdZ
RS(
s
    A producer that sends the contents of a file to a consumer.

    This is a helper for protocols that, at some point, will take a
    file-like object, read its contents, and write them out to the network,
    optionally performing some transformation on the bytes in between.
    iiRcCsE||_||_||_tj|_}|jj|t|S(s
        Begin transferring a file

        @type file: Any file-like object
        @param file: The file object to read data from

        @type consumer: Any implementor of IConsumer
        @param consumer: The object to write data to

        @param transform: A callable taking one string argument and returning
        the same.  All bytes read from the file are passed through this before
        being written to the consumer.

        @rtype: C{Deferred}
        @return: A deferred whose callback will be invoked when the file has
        been completely written to the consumer. The last byte written to the
        consumer is passed to the callback.
        (tfiletconsumert	transformRtDeferredtdeferredtregisterProducerRq(R"RRRR((s;/usr/lib/python2.7/dist-packages/twisted/protocols/basic.pytbeginFileTransferus			cCsd}|jr'|jj|j}n|sod|_|jj|jrk|jj|jd|_ndS|j	r|j	|}n|jj
||d|_dS(NRi(Rtreadt
CHUNK_SIZERRtunregisterProducerRRtlastSentRR*(R"tchunk((s;/usr/lib/python2.7/dist-packages/twisted/protocols/basic.pyRrs		
		cCsdS(N((R"((s;/usr/lib/python2.7/dist-packages/twisted/protocols/basic.pyRpscCs/|jr+|jjtdd|_ndS(Ns#Consumer asked us to stop producing(Rterrbackt	ExceptionR(R"((s;/usr/lib/python2.7/dist-packages/twisted/protocols/basic.pyRss		
i@N(RRRRRt	IProducerRRRRRRrRpRs(((s;/usr/lib/python2.7/dist-packages/twisted/protocols/basic.pyRfs
		(4RR\tstructRRRR&RR4tzope.interfaceRttwisted.internetRRRRttwisted.pythonRR	R
R_RR
RR]RtVersiontdeprecatedSincetmessagetattrtdeprecatedModuleAttributeRtDEBUGRyRRRRRR`RmRttAssertionErrorRtobjectRRRRRRR(((s;/usr/lib/python2.7/dist-packages/twisted/protocols/basic.pyt<module>
s@"	sCy$