o h ]b@sdZddlmZddlZddlZddlZddlZddlZddlZ ddl Z ddl Z ddl m Z edZdZdZGdd d eZGd d d eZGd d d eZGdddeZGdddeZdddZddZdddZddZddZdS)a Supports communication with sockets speaking Tor protocols. This allows us to send messages as basic strings, and receive responses as :class:`~stem.response.ControlMessage` instances. **This module only consists of low level components, and is not intended for users.** See our `tutorials <../tutorials.html>`_ and `Control Module `_ if you're new to Stem and looking to get started. With that aside, these can still be used for raw socket communication with Tor... :: import stem import stem.connection import stem.socket if __name__ == '__main__': try: control_socket = stem.socket.ControlPort(port = 9051) stem.connection.authenticate(control_socket) except stem.SocketError as exc: print 'Unable to connect to tor on port 9051: %s' % exc sys.exit(1) except stem.connection.AuthenticationFailure as exc: print 'Unable to authenticate: %s' % exc sys.exit(1) print "Issuing 'GETINFO version' query...\n" control_socket.send('GETINFO version') print control_socket.recv() :: % python example.py Issuing 'GETINFO version' query... version=0.2.4.10-alpha-dev (git-8be6058d8f31e578) OK **Module Overview:** :: BaseSocket - Thread safe socket. |- RelaySocket - Socket for a relay's ORPort. | |- send - sends a message to the socket | +- recv - receives a response from the socket | |- ControlSocket - Socket wrapper that speaks the tor control protocol. | |- ControlPort - Control connection via a port. | |- ControlSocketFile - Control connection via a local file socket. | | | |- send - sends a message to the socket | +- recv - receives a ControlMessage from the socket | |- is_alive - reports if the socket is known to be closed |- is_localhost - returns if the socket is for the local system or not |- connection_time - timestamp when socket last connected or disconnected |- connect - connects a new socket |- close - shuts down the socket +- __enter__ / __exit__ - manages socket connection send_message - Writes a message to a control socket. recv_message - Reads a ControlMessage from a control socket. send_formatting - Performs the formatting expected from sent messages. )absolute_importN)logs^[a-zA-Z0-9]{3}[-+ ]z0Error while receiving a control message (%s): %s c@seZdZdZddZddZddZdd Zd d Zd d Z ddZ ddZ ddZ ddZ ddZddZddZddZdS) BaseSocketz@ Thread safe socket, providing common socket functionality. cCs0d\|_|_d|_d|_t|_t|_dS)N)NNFg)_socket _socket_file _is_alive_connection_time threadingRLock _send_lock _recv_lockselfr-/usr/lib/python3/dist-packages/stem/socket.py__init__ds  zBaseSocket.__init__cC|jS)a Checks if the socket is known to be closed. We won't be aware if it is until we either use it or have explicitily shut it down. In practice a socket derived from a port knows about its disconnection after failing to receive data, whereas socket file derived connections know after either sending or receiving data. This means that to have reliable detection for when we're disconnected you need to continually pull from the socket (which is part of what the :class:`~stem.control.BaseController` does). :returns: **bool** that's **True** if our socket is connected and **False** otherwise )rrrrris_alivepszBaseSocket.is_alivecCdS)z Returns if the connection is for the local system or not. :returns: **bool** that's **True** if the connection is for the local host and **False** otherwise Frrrrr is_localhostszBaseSocket.is_localhostcCr)ae Provides the unix timestamp for when our socket was either connected or disconnected. That is to say, the time we connected if we're currently connected and the time we disconnected if we're not connected. .. versionadded:: 1.3.0 :returns: **float** for when we last connected or disconnected, zero if we've never connected )r rrrrconnection_times zBaseSocket.connection_timec Cs|jV|r ||j2||_|jjdd|_d|_t |_ z| Wnt j y9| YnwWdn1sDwYWddSWddS1s\wYdS)z Connects to a new socket, closing our previous one if we're already attached. :raises: :class:`stem.SocketError` if unable to make a socket Zrwb)modeTN)r rcloser _make_socketrZmakefilerrtimer _connectstem SocketErrorrrrrconnects$    "zBaseSocket.connectc Cs|j[|}|jr+z |jtjWn tjyYnwz|jWnY|jr:z|jWnYd|_d|_d|_ t |_ |rV| WddSWddS1sawYdS)zM Shuts down the socket. If it's already closed then this is a no-op. NF) r rrZshutdownsocketZ SHUT_RDWRerrorrrrrr _close)rZ is_changerrrrs4  $"zBaseSocket.closec Cst|j-z|s t||j|j|Wntjy'|r&|wWddS1s3wYdS)z Send message in a thread safe manner. Handler is expected to be of the form... :: my_handler(socket, socket_file, message) N)r rr SocketClosedrrr)rmessagehandlerrrr_sends "zBaseSocket._sendc Cs|j:z|j|j}}|r|st|||WWdStjy<|r;|jdr;||j w1s@wYdS)z Receives a message in a thread safe manner. Handler is expected to be of the form... :: my_handler(socket, socket_file) NF) r rrrr#rr acquirerrelease)rr%Z my_socketZmy_socket_filerrr_recvs     zBaseSocket._recvcCr)a} The send lock is useful to classes that interact with us at a deep level because it's used to lock :func:`stem.socket.ControlSocket.connect` / :func:`stem.socket.BaseSocket.close`, and by extension our :func:`stem.socket.BaseSocket.is_alive` state changes. :returns: **threading.RLock** that governs sending messages to our socket and state changes )r rrrr_get_send_lock)s zBaseSocket._get_send_lockcCs|SNrrrrr __enter__6zBaseSocket.__enter__cCs |dSr+)r)rZ exit_typevalue tracebackrrr__exit__9s zBaseSocket.__exit__cCr)zQ Connection callback that can be overwritten by subclasses and wrappers. Nrrrrrr<zBaseSocket._connectcCr)zT Disconnection callback that can be overwritten by subclasses and wrappers. Nrrrrrr"Cr1zBaseSocket._closecCstd)a Constructs and connects new socket. This is implemented by subclasses. :returns: **socket.socket** for our configuration :raises: * :class:`stem.SocketError` if unable to make a socket * **NotImplementedError** if not implemented by a subclass zLUnsupported Operation: this should be implemented by the BaseSocket subclass)NotImplementedErrorrrrrrJs zBaseSocket._make_socketN)__name__ __module__ __qualname____doc__rrrrrrr&r)r*r,r0rr"rrrrrr_s    ,*  rcsDeZdZdZdfdd ZddZdd d Zd d ZddZZ S) RelaySocketz `Link-level connection `_ to a Tor relay. .. versionadded:: 1.7.0 :var str address: address our socket connects to :var int port: ORPort our socket connects to 127.0.0.1Z#Tc.tt|||_||_|r|dSdS)aE RelaySocket constructor. :param str address: ip address of the relay :param int port: orport of the relay :param bool connect: connects to the socket if True, leaves it unconnected otherwise :raises: :class:`stem.SocketError` if connect is **True** and we're unable to establish a connection N)superr7raddressportrrr<r=r __class__rrrd   zRelaySocket.__init__cC||dddS)a Sends a message to the relay's ORPort. :param str message: message to be formatted and sent to the socket :raises: * :class:`stem.SocketError` if a problem arises in using the socket * :class:`stem.SocketClosed` if the socket is known to be shut down cS t||Sr+)_write_to_socketssfmsgrrr z"RelaySocket.send..Nr&rr$rrrsendws zRelaySocket.sendNcsfdd}||S)a Receives a message from the relay. :param float timeout: maxiumum number of seconds to await a response, this blocks indefinitely if **None** :returns: bytes for the message received :raises: * :class:`stem.ProtocolError` the content from the socket is malformed * :class:`stem.SocketClosed` if the socket closes before we receive a complete message c svdur|S|d|z"z |WW|dStjtjtjfy4YW|ddSw|dw)Nr)recvZ setblockingZ settimeoutr timeoutsslZSSLErrorZSSLWantReadErrorrFrGrPrr wrapped_recvs     z&RelaySocket.recv..wrapped_recvr))rrPrTrrSrrOs  zRelaySocket.recvcC |jdkSNr8r<rrrrr zRelaySocket.is_localhostc CsTzttjtj}||j|jft|WStjy)}zt |d}~wwr+) r AF_INET SOCK_STREAMrr<r=rQZ wrap_socketr!rr)rZ relay_socketexcrrrrs  zRelaySocket._make_socket)r8r9Tr+) r3r4r5r6rrMrOrr __classcell__rrr?rr7Xs  r7cs0eZdZdZfddZddZddZZS) ControlSocketaK Wrapper for a socket connection that speaks the Tor control protocol. To the better part this transparently handles the formatting for sending and receiving complete messages. Callers should not instantiate this class directly, but rather use subclasses which are expected to implement the **_make_socket()** method. cstt|dSr+)r;r^rrr?rrrszControlSocket.__init__cCrB)a& Formats and sends a message to the control socket. For more information see the :func:`~stem.socket.send_message` function. .. deprecated:: 1.7.0 The **raw** argument was unhelpful and be removed. Use :func:`stem.socket.send_message` if you need this level of control instead. :param str message: message to be formatted and sent to the socket :raises: * :class:`stem.SocketError` if a problem arises in using the socket * :class:`stem.SocketClosed` if the socket is known to be shut down cSrCr+) send_messagerErrrrIrJz$ControlSocket.send..NrKrLrrrrMszControlSocket.sendcCs|ddS)a Receives a message from the control socket, blocking until we've received one. For more information see the :func:`~stem.socket.recv_message` function. :returns: :class:`~stem.response.ControlMessage` for the message received :raises: * :class:`stem.ProtocolError` the content from the socket is malformed * :class:`stem.SocketClosed` if the socket closes before we receive a complete message cSst|Sr+) recv_messagerRrrrrIsz$ControlSocket.recv..rUrrrrrOs zControlSocket.recv)r3r4r5r6rrMrOr]rrr?rr^s  r^csBeZdZdZdfdd ZddZd d Zd d Zd dZZ S) ControlPortz Control connection to tor. For more information see tor's ControlPort torrc option. :var str address: address our socket connects to :var int port: ControlPort our socket connects to r8[#Tcr:)aT ControlPort constructor. :param str address: ip address of the controller :param int port: port number of the controller :param bool connect: connects to the socket if True, leaves it unconnected otherwise :raises: :class:`stem.SocketError` if connect is **True** and we're unable to establish a connection N)r;rarr<r=rr>r?rrrrAzControlPort.__init__cCr)z Provides the ip address our socket connects to. .. deprecated:: 1.7.0 Use the **address** attribute instead. :returns: str with the ip address of our socket rXrrrr get_address zControlPort.get_addresscCr)z Provides the port our socket connects to. .. deprecated:: 1.7.0 Use the **port** attribute instead. :returns: int with the port of our socket )r=rrrrget_portrdzControlPort.get_portcCrVrWrXrrrrrrYzControlPort.is_localhostc CsNzttjtj}||j|jf|WStjy&}zt|d}~wwr+) r rZr[rr<r=r!rrrZcontrol_socketr\rrrrs zControlPort._make_socket)r8rbT) r3r4r5r6rrcrerrr]rrr?rras  racs:eZdZdZd fdd ZddZdd Zd d ZZS) ControlSocketFilez Control connection to tor. For more information see tor's ControlSocket torrc option. :var str path: filesystem path of the socket we connect to /var/run/tor/controlTcs(tt|||_|r|dSdS)a7 ControlSocketFile constructor. :param str socket_path: path where the control socket is located :param bool connect: connects to the socket if True, leaves it unconnected otherwise :raises: :class:`stem.SocketError` if connect is **True** and we're unable to establish a connection N)r;rgrpathr)rrirr?rrr%s   zControlSocketFile.__init__cCr)z Provides the path our socket connects to. .. deprecated:: 1.7.0 Use the **path** attribute instead. :returns: str with the path for our control socket )rirrrrget_socket_path6rdz!ControlSocketFile.get_socket_pathcCr)NTrrrrrrBr-zControlSocketFile.is_localhostc CsHzttjtj}||j|WStjy#}zt|d}~wwr+)r ZAF_UNIXr[rrir!rrrfrrrrEs  zControlSocketFile._make_socket)rhT) r3r4r5r6rrjrrr]rrr?rrgs  rgFcCsX|st|}t||tr*|dd}d|vrdnd}td||fdSdS)a Sends a message to the control socket, adding the expected formatting for single verses multi-line messages. Neither message type should contain an ending newline (if so it'll be treated as a multi-line message with a blank line at the end). If the message doesn't contain a newline then it's sent as... :: \r\n and if it does contain newlines then it's split on ``\n`` and sent as... :: +\r\n \r\n \r\n .\r\n :param file control_file: file derived from the control socket (see the socket's makefile() method for more information) :param str message: message to be sent on the control socket :param bool raw: leaves the message formatting untouched, passing it to the socket as-is :raises: * :class:`stem.SocketError` if a problem arises in using the socket * :class:`stem.SocketClosed` if the socket is known to be shut down    zSent to tor:%s%sN)send_formattingrDr is_tracingreplacerstriptrace) control_filer$raw log_messageZmsg_divrrrr_Ns  r_c Csz|tjj||WdStjy5}zt d|t |dkr,t |t |d}~wt yEt dt dw)NzFailed to send: %sz[Errno 32] Broken pipez$Failed to send: file has been closedzfile has been closed)writerutil str_toolsZ _to_bytesflushr r!rinfostrr#rAttributeError)Z socket_filer$r\rrrrDys      rDc Csd\}}} z|}Wn1tyttdtdtjt fy=}zttdd|ft|d}~ww|sLttdtd t |sdttd d t |ft d |d s|ttd dt |ft d|dd|dd|dd}}} tjrtjj|}tjj|}|r|dkrt|tjj||| fg||dSgtd}}}||7}|dkr|||| fn|dkr|||| ftt|tjj|t||dS|dkrpt| } z |}||7}Wn%tjy*}zttdd|t t|fft|d}~ww|d sFttd dt t|ft d|dkrLn|dd}|dr^|dd}| d|7} q|||t| fnttd d|ft d|tjj|fq) a Pulls from a control socket until we either have a complete message or encounter a problem. :param file control_file: file derived from the control socket (see the socket's makefile() method for more information) :returns: :class:`~stem.response.ControlMessage` read from the socket :raises: * :class:`stem.ProtocolError` the content from the socket is malformed * :class:`stem.SocketClosed` if the socket closes before we receive a complete message )NNTT)r#socket file has been closedr}r#zreceived exception "%s"N)r#zempty socket contentzReceived empty socket content. ProtocolErrorz#malformed status code/divider, "%s"z2Badly formatted reply line: beginning is malformed zno CRLF linebreak, "%s"zAll lines should end with CRLFrm) arrived_atF-+z^received an exception while mid-way through a data reply (exception: "%s", read content: "%s")z/CRLF linebreaks missing from a data reply, "%s"s. s..rN z$"%s" isn't a recognized divider typez"Unrecognized divider type '%s': %s)readliner|rrz ERROR_MSGrr#r r! ValueErrorMESSAGE_PREFIXmatchescaper~endswithZprereqZ is_python_3rwrx _to_unicode _log_traceresponseZControlMessage bytearrayappendbytes startswithwarn) rsrZparsed_contentZ raw_contentZ first_lineliner\Z status_codeZdividerZcontentZ content_blockrrrr`s|          (    $         r`cCs,|dd}d|vrd|ddS|dS)a Performs the formatting expected from sent control messages. For more information see the :func:`~stem.socket.send_message` function. :param str message: message to be formatted :returns: **str** of the message wrapped by the formatting expected from controllers rkrlz+%s . )rp)r$rrrrn s rncCstsdStjj|dd}|d}t r2t |t kr2d |dt dt |t g}t |dkrAt d|dSt d|dddS) Nrrrlz... %i more lines...zReceived from tor: %szReceived from tor: %sz\n) rrorrwrxrrprqsplit TRUNCATE_LOGSlenjoinrr)rruZlog_message_linesrrrr(s $ r)Fr+)r6Z __future__rrer rQr rZ stem.prereqrZ stem.responseZstem.util.str_toolsZ stem.utilrcompilerrrobjectrr7r^rargr_rDr`rnrrrrrs2 E  zV/@ 1+ {