o ]J@sdZddlZddlZddlZddlZddlZddlZddlZddl ZgdZ e dZ ddZ GdddeZGd d d eZd d Zd dZGdddeZdS)a Parses replies from the control socket. **Module Overview:** :: convert - translates a ControlMessage into a particular response subclass ControlMessage - Message that's read from the control socket. |- SingleLineResponse - Simple tor response only including a single line of information. | |- from_str - provides a ControlMessage for the given string |- is_ok - response had a 250 status |- content - provides the parsed message content +- raw_content - unparsed socket data ControlLine - String subclass with methods for parsing controller responses. |- remainder - provides the unparsed content |- is_empty - checks if the remaining content is empty |- is_next_quoted - checks if the next entry is a quoted value |- is_next_mapping - checks if the next entry is a KEY=VALUE mapping |- peek_key - provides the key of the next entry |- pop - removes and returns the next entry +- pop_mapping - removes and returns the next entry as a KEY=VALUE mapping N) add_onioneventsgetinfogetconf protocolinfo authchallengeconvertControlMessage ControlLineSingleLineResponsez^(\S+)=c Ksddl}ddl}ddl}ddl}ddl}ddl}ddl}t|ts%t d|j j j |j j j|j jj|j jj|j jj|j jj|j jjtd}z||}Wn t yXt d|w||_|jdi|dS)aG Converts a :class:`~stem.response.ControlMessage` into a particular kind of tor response. This does an in-place conversion of the message from being a :class:`~stem.response.ControlMessage` to a subclass for its response type. Recognized types include... =================== ===== response_type Class =================== ===== **ADD_ONION** :class:`stem.response.add_onion.AddOnionResponse` **AUTHCHALLENGE** :class:`stem.response.authchallenge.AuthChallengeResponse` **EVENT** :class:`stem.response.events.Event` subclass **GETCONF** :class:`stem.response.getconf.GetConfResponse` **GETINFO** :class:`stem.response.getinfo.GetInfoResponse` **MAPADDRESS** :class:`stem.response.mapaddress.MapAddressResponse` **PROTOCOLINFO** :class:`stem.response.protocolinfo.ProtocolInfoResponse` **SINGLELINE** :class:`stem.response.SingleLineResponse` =================== ===== :param str response_type: type of tor response to convert to :param stem.response.ControlMessage message: message to be converted :param kwargs: optional keyword arguments to be passed to the parser method :raises: * :class:`stem.ProtocolError` the message isn't a proper response of that type * :class:`stem.InvalidArguments` the arguments given as input are invalid, this is can only be raised if the response_type is: **GETINFO**, **GETCONF** * :class:`stem.InvalidRequest` the arguments given as input are invalid, this is can only be raised if the response_type is: **MAPADDRESS** * :class:`stem.OperationFailed` if the action the event represents failed, this is can only be raised if the response_type is: **MAPADDRESS** * **TypeError** if argument isn't a :class:`~stem.response.ControlMessage` or response_type isn't supported rNz;Only able to convert stem.response.ControlMessage instances)Z ADD_ONIONZ AUTHCHALLENGEZEVENTZGETCONFZGETINFOZ MAPADDRESSZ PROTOCOLINFOZ SINGLELINEzUnsupported response type: %s)Zstem.response.add_onionZstem.response.authchallengeZstem.response.eventsZstem.response.getinfoZstem.response.getconfZstem.response.mapaddressZstem.response.protocolinfo isinstancer TypeErrorZresponserZAddOnionResponserZAuthChallengeResponserZEventrZGetConfResponserZGetInfoResponseZ mapaddressZMapAddressResponserZProtocolInfoResponser __class___parse_message)Z response_typemessagekwargsstemZresponse_typesZresponse_classr r 8/usr/lib/python3/dist-packages/stem/response/__init__.pyr9s2'    rc@s|eZdZdZedddZdddZdd Zdd d Zdd d Z ddZ ddZ ddZ ddZ ddZddZddZdS)r a Message from the control socket. This is iterable and can be stringified for individual message components stripped of protocol formatting. Messages are never empty. :var int arrived_at: unix timestamp for when the message arrived .. versionchanged:: 1.7.0 Implemented equality and hashing. .. versionchanged:: 1.8.0 Moved **arrived_at** from the Event class up to this base ControlMessage. NFcKsj|r|ds |d7}tdd|}tjjttjj || ddd}|dur3t ||fi||S)a Provides a ControlMessage for the given content. .. versionadded:: 1.1.0 .. versionchanged:: 1.6.0 Added the normalize argument. :param str content: message to construct the message from :param str msg_type: type of tor reply to parse the content as :param bool normalize: ensures expected carriage return and ending newline are present :param kwargs: optional keyword arguments to be passed to the parser method :returns: stem.response.ControlMessage instance  z([ ]?) z arrived_atN)r) endswithresubrZsocketZ recv_messageioBytesIOutil str_tools _to_bytespopr)contentZmsg_type normalizermsgr r rfrom_strs (zControlMessage.from_strcCsH|std|r |ntt|_||_||_d|_tj |d|_ dS)NzControlMessages can't be empty _raw_content) ValueErrorinttimer_parsed_contentr$_strrrZ _hash_attr_hash)selfZparsed_content raw_contentrr r r__init__szControlMessage.__init__cCs$|jD] \}}}|dkrdSqdS)z Checks if any of our lines have a 250 response. :returns: **True** if any lines have a 250 response code, **False** otherwise 250TF)r()r+code_r r ris_oks zControlMessage.is_okcCs(tjr|sdd|jDSt|jS)a Provides the parsed message content. These are entries of the form... :: (status_code, divider, content) **status_code** Three character code for the type of response (defined in section 4 of the control-spec). **divider** Single character to indicate if this is mid-reply, data, or an end to the message (defined in section 2.3 of the control-spec). **content** The following content is the actual payload of the line. For data entries the content is the full multi-line payload with newline linebreaks and leading periods unescaped. The **status_code** and **divider** are both strings (**bytes** in python 2.x and **unicode** in python 3.x). The **content** however is **bytes** if **get_bytes** is **True**. .. versionchanged:: 1.1.0 Added the get_bytes argument. :param bool get_bytes: provides **bytes** for the **content** rather than a **str** :returns: **list** of (str, str, str) tuples for the components of this message cSs&g|]\}}}||tjj|fqSr )rrr _to_unicode).0r/Zdivr r r r s&z*ControlMessage.content..)rprereq is_python_3r(listr+ get_bytesr r rr s" zControlMessage.contentcCs$tjr|stjj|jS|jS)a, Provides the unparsed content read from the control socket. .. versionchanged:: 1.1.0 Added the get_bytes argument. :param bool get_bytes: if **True** then this provides **bytes** rather than a **str** :returns: **str** of the socket data used to generate this message )rr5r6rrr2r$r8r r rr,s zControlMessage.raw_contentcCs |jdur dt||_|jS)z^ Content of the message, stripped of status code and divider protocol formatting. Nr)r)joinr7r+r r r__str__s zControlMessage.__str__ccs:|jD]\}}}tjrtjj|}t|VqdS)a Provides :class:`~stem.response.ControlLine` instances for the content of the message. This is stripped of status codes and dividers, for instance... :: 250+info/names= desc/id/* -- Router descriptors by ID. desc/name/* -- Router descriptors by nickname. . 250 OK Would provide two entries... :: 1st - "info/names= desc/id/* -- Router descriptors by ID. desc/name/* -- Router descriptors by nickname." 2nd - "OK" Nr(rr5r6rrr2r )r+r0r r r r__iter__ s   zControlMessage.__iter__cCs t|jS)z* :returns: number of ControlLines )lenr(r;r r r__len__&s zControlMessage.__len__cCs.|j|d}tjrtjj|}t|S)zD :returns: :class:`~stem.response.ControlLine` at the index r=)r+indexr r r r __getitem__-s zControlMessage.__getitem__cC|jSN)r*r;r r r__hash__9szControlMessage.__hash__cCst|tr t|t|kSdSNF)r r hashr+otherr r r__eq__<szControlMessage.__eq__cCs ||k SrEr rIr r r__ne__?s zControlMessage.__ne__rGrEF)__name__ __module__ __qualname____doc__ staticmethodr#r-r1r r,r<r>r@rCrFrKrLr r r rr s   '   r c@s`eZdZdZddZddZddZdd Zdd d ZdddZ ddZ dddZ dddZ d S)r aR String subclass that represents a line of controller output. This behaves as a normal string with additional methods for parsing and popping entries from a space delimited series of elements like a stack. None of these additional methods effect ourselves as a string (which is still immutable). All methods are thread safe. cCs t||SrE)str__new__r+valuer r rrTMs zControlLine.__new__cCs||_t|_dSrE) _remainder threadingRLock_remainder_lockrUr r rr-PszControlLine.__init__cCrD)z Provides our unparsed content. This is an empty string after we've popped all entries. :returns: **str** of the unparsed content rWr;r r r remainderTszControlLine.remaindercCs |jdkS)z Checks if we have further content to pop or not. :returns: **True** if we have additional content, **False** otherwise r[r;r r ris_empty^s zControlLine.is_emptyFcCs t|j|\}}|dko|dkS)z Checks if our next entry is a quoted value or not. :param bool escaped: unescapes the string :returns: **True** if the next entry can be parsed as a quoted value, **False** otherwise r)_get_quote_indicesrW)r+escaped start_quote end_quoter r ris_next_quotedgs zControlLine.is_next_quotedNcCsZ|j}t|}|r+|r||dkrdS|r)t||\}}||ko(|dkSdSdS)az Checks if our next entry is a KEY=VALUE mapping or not. :param str key: checks that the key matches this value, skipping the check if **None** :param bool quoted: checks that the mapping is to a quoted value :param bool escaped: unescapes the string :returns: **True** if the next entry can be parsed as a key=value mapping, **False** otherwise rFr_T)rWKEY_ARGmatchgroupsr`end)r+keyquotedrar\ key_matchrbrcr r ris_next_mappingss zControlLine.is_next_mappingcCs$|j}t|}|r|dSdS)z Provides the key of the next entry, providing **None** if it isn't a key/value mapping. :returns: **str** with the next entry's key rN)rWrerfrg)r+r\rkr r rpeek_keys   zControlLine.peek_keycCsH|jt|j||d\}}||_|WdS1swYdS)aq Parses the next space separated entry, removing it and the space from our remaining content. Examples... :: >>> line = ControlLine("\"We're all mad here.\" says the grinning cat.") >>> print line.pop(True) "We're all mad here." >>> print line.pop() "says" >>> print line.remainder() "the grinning cat." >>> line = ControlLine("\"this has a \\\" and \\\\ in it\" foo=bar more_data") >>> print line.pop(True, True) "this has a \" and \\ in it" :param bool quoted: parses the next entry as a quoted value, removing the quotes :param bool escaped: unescapes the string :returns: **str** of the next space separated entry :raises: * **ValueError** if quoted is True without the value being quoted * **IndexError** if we don't have any remaining content left to parse FN)rZ _parse_entryrW)r+rjra next_entryr\r r rrs $zControlLine.popcCs|j>|r tdt|j}|std|j|d}|j|d}t ||||\}}||_||fWdS1sDwYdS)a Parses the next space separated entry as a KEY=VALUE mapping, removing it and the space from our remaining content. .. versionchanged:: 1.6.0 Added the get_bytes argument. :param bool quoted: parses the value as being quoted, removing the quotes :param bool escaped: unescapes the string :param bool get_bytes: provides **bytes** for the **value** rather than a **str** :returns: **tuple** of the form (key, value) :raises: **ValueError** if this isn't a KEY=VALUE mapping or if quoted is **True** without the value being quoted :raises: **IndexError** if there's nothing to parse from the line no remaining content to parsez*the next entry isn't a KEY=VALUE mapping: rN) rZr^ IndexErrorrerfrWr%rgrhrn)r+rjrar9rkrir\ror r r pop_mappings  $zControlLine.pop_mappingrM)NFF)FF)FFF) rNrOrPrQrTr-r\r^rdrlrmrrrr r r rr Cs   "r cCs|dkrtdd|}}|r4t||\}}|dks|dkr$td||d|||dd}}nd|vrA|dd\}}n|d}}|r]t|d}tjr]|s]tj j |}|rftj j |}|| fS) a Parses the next entry from the given space separated content. :param str line: content to be parsed :param bool quoted: parses the next entry as a quoted value, removing the quotes :param bool escaped: unescapes the string :returns: **tuple** of the form (entry, remainder) :raises: * **ValueError** if quoted is True without the next value being quoted * **IndexError** if there's nothing to parse from the line r]rprr_z%the next entry isn't a quoted value: N )rqr`r%splitcodecs escape_decoderr5r6rrr2rlstrip)linerjrar9ror\rbrcr r rrns$     rncCs~gd}}tdD]1}|d|d}|r5|dkr5||ddkr5|d|d}|dkr5||ddks!||q t|S)z Provides the indices of the next two quotes in the given content. :param str line: content to be parsed :param bool escaped: unescapes the string :returns: **tuple** of two ints, indices being -1 if a quote doesn't exist r_rA"rs\)rangefindappendtuple)ryraindicesZ quote_indexr0r r rr`"s  r`c@s"eZdZdZdddZddZdS) r a Reply to a request that performs an action rather than querying data. These requests only contain a single line, which is 'OK' if successful, and a description of the problem if not. :var str code: status code for our line :var str message: content of the line FcCs(|r |ddkS|dddkS)a} Checks if the response code is "250". If strict is **True** then this checks if the response is "250 OK" :param bool strict: checks for a "250 OK" message if **True** :returns: * If strict is **False**: **True** if the response code is "250", **False** otherwise * If strict is **True**: **True** if the response is "250 OK", **False** otherwise r)r.rtZOKr.)r )r+strictr r rr1Fs zSingleLineResponse.is_okcCsJ|}t|dkrtdt|dkrtd|d\|_}|_dS)NrszReceived multi-line responserzReceived empty response)r r?rZ ProtocolErrorr/r)r+r r0r r rrWs     z!SingleLineResponse._parse_messageNrM)rNrOrPrQr1rr r r rr <s r )rQrvrrr'rXZ stem.socketrZ stem.utilZstem.util.str_tools__all__compilererobjectr rSr rnr`r r r r rs& FE$<