stem-1.6.0/ 0000775 0001750 0001750 00000000000 13177674754 013235 5 ustar atagar atagar 0000000 0000000 stem-1.6.0/tox.ini 0000664 0001750 0001750 00000000320 13115423200 014505 0 ustar atagar atagar 0000000 0000000 [tox]
envlist = py26,py27,py31,py32,py33,py34
skipsdist = True
[testenv]
commands =
pip install --allow-all-external -e .
python run_tests.py {posargs:-a}
rm -rf stem.egg-info
deps =
-rrequirements.txt
stem-1.6.0/test/ 0000775 0001750 0001750 00000000000 13177674754 014214 5 ustar atagar atagar 0000000 0000000 stem-1.6.0/test/settings.cfg 0000664 0001750 0001750 00000030662 13177114716 016527 0 ustar atagar atagar 0000000 0000000 # Testing Configuration
#
# The following contains customizable configuration information for stem's
# testing framework.
#
# integ.test_directory
# Path used for our data directory and any temporary test resources. Relative
# paths are expanded in reference to the location of 'run_tests.py'.
#
# If set then the directory's contents are reused for future tests (so we
# have a faster startup and lower load on authorities). If set to an empty
# value then this makes a fresh data directory for each test run.
#
# integ.log
# Path runtime logs are placed. Relative paths are expanded in reference to
# 'run_tests.py'. Logging is disabled if set ot an empty value.
integ.test_directory ./test/data
exclude_paths .*/stem/test/data/.*
integ.log ./test/data/log
# The following are less testing framework attributes that aren't as commonly
# reconfigured.
#
# msg.*
# Rendered text.
#
# target.*
# Attributes of the integration testing targets. This helps determine what is
# ran when the user runs with '--target'.
msg.help
|Usage run_tests.py [OPTION]
|Runs tests for the stem library.
|
| -a, --all runs unit, integ, and style checks (same as '-ui')
| -u, --unit runs unit tests
| -i, --integ runs integration tests
| -t, --target TARGET comma separated list of extra targets for integ tests
| --test TEST_NAME only run tests modules containing the given name
| -l, --log RUNLEVEL includes logging output with test results, runlevels:
| TRACE, DEBUG, INFO, NOTICE, WARN, ERROR
| --tor PATH custom tor binary to run testing against
| -v, --verbose provides additional test output
| -h, --help presents this help
|
| Examples:
| run_tests.py --unit --integ
| Run unit and integration tests.
|
| run_tests.py --integ --target RUN_ALL
| Run integration tests against all tor configurations.
|
| run_tests.py --integ --test test.integ.util
| Only run integration tests for the util modules.
|
| Integration targets:
##################
# CATEGORY: TARGET #
##################
# The '--help' description of the target.
target.description ONLINE => Includes tests that require network activity.
target.description RELATIVE => Uses a relative path for tor's data directory.
target.description CHROOT => Simulates a chroot setup.
target.description RUN_NONE => Configuration without a way for controllers to connect.
target.description RUN_OPEN => Configuration with an open control port (default).
target.description RUN_PASSWORD => Configuration with password authentication.
target.description RUN_COOKIE => Configuration with an authentication cookie.
target.description RUN_MULTIPLE => Configuration with both password and cookie authentication.
target.description RUN_SOCKET => Configuration with a control socket.
target.description RUN_SCOOKIE => Configuration with a control socket and authentication cookie.
target.description RUN_PTRACE => Configuration with an open control port and 'DisableDebuggerAttachment 0'
target.description RUN_ALL => Runs integration tests for all connection configurations.
# Torrc configuration options included with the target. Having this option set
# means that each of these targets will have a dedicated integration test run.
target.torrc RUN_NONE =>
target.torrc RUN_OPEN => PORT
target.torrc RUN_PASSWORD => PORT, PASSWORD
target.torrc RUN_COOKIE => PORT, COOKIE
target.torrc RUN_MULTIPLE => PORT, PASSWORD, COOKIE
target.torrc RUN_SOCKET => SOCKET
target.torrc RUN_SCOOKIE => SOCKET, COOKIE
target.torrc RUN_PTRACE => PORT, PTRACE
# Pycodestyle compliance issues that we're ignoreing...
#
# * E251 no spaces around keyword / parameter equals
#
# This one I dislike a great deal. It makes keyword arguments different
# from assignments which looks... aweful. I'm not sure what Pycodestyle's
# author was on when he wrote this one but it's stupid.
#
# Someone else can change this if they really care.
#
# * E501 line is over 79 characters
#
# We're no longer on TTY terminals. Overly constraining line length makes
# things far less readable, encouraging bad practices like abbreviated
# variable names.
#
# If the code fits on my tiny netbook screen then it's narrow enough.
#
# * E111, E114, and E121 four space indentations
#
# Ahhh, indentation. The holy war that'll never die. Sticking with two
# space indentations since it leads to shorter lines.
#
# * E127 and E131 continuation line over-indented for visual indent
#
# Pycodestyle only works with this one if we have four space indents (its
# detection is based on multiples of four).
#
# * E722 do not use bare except
#
# Iirc they advise against this because it catches KeyboardInterrups and
# interpreter termination. That's a fair concern, but on the other hand we
# don't have strong assurance that socket errors and the like will be caught
# without it. We've been doing this for years without issue but I'd be
# ameanable to a patch if this causes issues for someone.
pycodestyle.ignore E111
pycodestyle.ignore E114
pycodestyle.ignore E121
pycodestyle.ignore E501
pycodestyle.ignore E251
pycodestyle.ignore E127
pycodestyle.ignore E131
pycodestyle.ignore E722
pycodestyle.ignore stem/__init__.py => E402: import stem.util.enum
pycodestyle.ignore stem/descriptor/__init__.py => E402: import stem.descriptor.server_descriptor
pycodestyle.ignore stem/descriptor/__init__.py => E402: import stem.descriptor.extrainfo_descriptor
pycodestyle.ignore stem/descriptor/__init__.py => E402: import stem.descriptor.networkstatus
pycodestyle.ignore stem/descriptor/__init__.py => E402: import stem.descriptor.microdescriptor
pycodestyle.ignore stem/descriptor/__init__.py => E402: import stem.descriptor.tordnsel
pycodestyle.ignore stem/descriptor/__init__.py => E402: import stem.descriptor.hidden_service_descriptor
pycodestyle.ignore test/unit/util/connection.py => W291: _tor tor 15843 10 pipe 0x0 state:
pycodestyle.ignore test/unit/util/connection.py => W291: _tor tor 15843 11 pipe 0x0 state:
# False positives from pyflakes. These are mappings between the path and the
# issue.
pyflakes.ignore run_tests.py => 'unittest' imported but unused
pyflakes.ignore stem/util/__init__.py => undefined name 'long'
pyflakes.ignore stem/util/__init__.py => undefined name 'unicode'
pyflakes.ignore stem/control.py => undefined name 'controller'
pyflakes.ignore stem/manual.py => undefined name 'unichr'
pyflakes.ignore stem/prereq.py => 'int_to_bytes' imported but unused
pyflakes.ignore stem/prereq.py => 'int_from_bytes' imported but unused
pyflakes.ignore stem/prereq.py => 'default_backend' imported but unused
pyflakes.ignore stem/prereq.py => 'load_der_public_key' imported but unused
pyflakes.ignore stem/prereq.py => 'modes' imported but unused
pyflakes.ignore stem/prereq.py => 'Cipher' imported but unused
pyflakes.ignore stem/prereq.py => 'algorithms' imported but unused
pyflakes.ignore stem/prereq.py => 'unittest' imported but unused
pyflakes.ignore stem/prereq.py => 'unittest.mock' imported but unused
pyflakes.ignore stem/prereq.py => 'long_to_bytes' imported but unused
pyflakes.ignore stem/prereq.py => 'encoding' imported but unused
pyflakes.ignore stem/prereq.py => 'signing' imported but unused
pyflakes.ignore stem/prereq.py => 'sqlite3' imported but unused
pyflakes.ignore stem/prereq.py => 'cryptography.utils.int_to_bytes' imported but unused
pyflakes.ignore stem/prereq.py => 'cryptography.utils.int_from_bytes' imported but unused
pyflakes.ignore stem/prereq.py => 'cryptography.hazmat.backends.default_backend' imported but unused
pyflakes.ignore stem/prereq.py => 'cryptography.hazmat.primitives.serialization.load_der_public_key' imported but unused
pyflakes.ignore stem/prereq.py => 'cryptography.hazmat.primitives.ciphers.modes' imported but unused
pyflakes.ignore stem/prereq.py => 'cryptography.hazmat.primitives.ciphers.Cipher' imported but unused
pyflakes.ignore stem/prereq.py => 'cryptography.hazmat.primitives.ciphers.algorithms' imported but unused
pyflakes.ignore stem/prereq.py => 'nacl.encoding' imported but unused
pyflakes.ignore stem/prereq.py => 'nacl.signing' imported but unused
pyflakes.ignore stem/interpreter/__init__.py => undefined name 'raw_input'
pyflakes.ignore stem/util/conf.py => undefined name 'unicode'
pyflakes.ignore stem/util/test_tools.py => 'pyflakes' imported but unused
pyflakes.ignore stem/util/test_tools.py => 'pycodestyle' imported but unused
pyflakes.ignore test/unit/descriptor/reader.py => 'bz2' imported but unused
pyflakes.ignore test/unit/response/events.py => 'from stem import *' used; unable to detect undefined names
pyflakes.ignore test/unit/response/events.py => *may be undefined, or defined from star imports: stem
pyflakes.ignore test/__init__.py => undefined name 'test'
# Test modules we want to run. Modules are roughly ordered by the dependencies
# so the lowest level tests come first. This is because a problem in say,
# controller message parsing, will cause all higher level tests to fail too.
# Hence we want the test that most narrowly exhibits problems to come first.
test.unit_tests
|test.unit.util.enum.TestEnum
|test.unit.util.connection.TestConnection
|test.unit.util.conf.TestConf
|test.unit.util.log.TestLog
|test.unit.util.proc.TestProc
|test.unit.util.str_tools.TestStrTools
|test.unit.util.system.TestSystem
|test.unit.util.term.TestTerminal
|test.unit.util.tor_tools.TestTorTools
|test.unit.util.__init__.TestBaseUtil
|test.unit.installation.TestInstallation
|test.unit.descriptor.export.TestExport
|test.unit.descriptor.reader.TestDescriptorReader
|test.unit.descriptor.remote.TestDescriptorDownloader
|test.unit.descriptor.server_descriptor.TestServerDescriptor
|test.unit.descriptor.extrainfo_descriptor.TestExtraInfoDescriptor
|test.unit.descriptor.microdescriptor.TestMicrodescriptor
|test.unit.descriptor.router_status_entry.TestRouterStatusEntry
|test.unit.descriptor.tordnsel.TestTorDNSELDescriptor
|test.unit.descriptor.networkstatus.directory_authority.TestDirectoryAuthority
|test.unit.descriptor.networkstatus.key_certificate.TestKeyCertificate
|test.unit.descriptor.networkstatus.document_v2.TestNetworkStatusDocument
|test.unit.descriptor.networkstatus.document_v3.TestNetworkStatusDocument
|test.unit.descriptor.networkstatus.bridge_document.TestBridgeNetworkStatusDocument
|test.unit.descriptor.hidden_service_descriptor.TestHiddenServiceDescriptor
|test.unit.descriptor.certificate.TestEd25519Certificate
|test.unit.exit_policy.rule.TestExitPolicyRule
|test.unit.exit_policy.policy.TestExitPolicy
|test.unit.version.TestVersion
|test.unit.manual.TestManual
|test.unit.tutorial.TestTutorial
|test.unit.tutorial_examples.TestTutorialExamples
|test.unit.response.add_onion.TestAddOnionResponse
|test.unit.response.control_message.TestControlMessage
|test.unit.response.control_line.TestControlLine
|test.unit.response.events.TestEvents
|test.unit.response.getinfo.TestGetInfoResponse
|test.unit.response.getconf.TestGetConfResponse
|test.unit.response.singleline.TestSingleLineResponse
|test.unit.response.authchallenge.TestAuthChallengeResponse
|test.unit.response.protocolinfo.TestProtocolInfoResponse
|test.unit.response.mapaddress.TestMapAddressResponse
|test.unit.connection.authentication.TestAuthenticate
|test.unit.connection.connect.TestConnect
|test.unit.control.controller.TestControl
|test.unit.interpreter.arguments.TestArgumentParsing
|test.unit.interpreter.autocomplete.TestAutocompletion
|test.unit.interpreter.help.TestHelpResponses
|test.unit.interpreter.commands.TestInterpreterCommands
|test.unit.doctest.TestDocumentation
test.integ_tests
|test.integ.util.conf.TestConf
|test.integ.util.connection.TestConnection
|test.integ.util.proc.TestProc
|test.integ.util.system.TestSystem
|test.integ.interpreter.TestInterpreter
|test.integ.version.TestVersion
|test.integ.manual.TestManual
|test.integ.response.protocolinfo.TestProtocolInfo
|test.integ.socket.control_socket.TestControlSocket
|test.integ.socket.control_message.TestControlMessage
|test.integ.connection.authentication.TestAuthenticate
|test.integ.connection.connect.TestConnect
|test.integ.control.base_controller.TestBaseController
|test.integ.control.controller.TestController
|test.integ.descriptor.remote.TestDescriptorDownloader
|test.integ.descriptor.server_descriptor.TestServerDescriptor
|test.integ.descriptor.extrainfo_descriptor.TestExtraInfoDescriptor
|test.integ.descriptor.microdescriptor.TestMicrodescriptor
|test.integ.descriptor.networkstatus.TestNetworkStatus
|test.integ.installation.TestInstallation
|test.integ.process.TestProcess
stem-1.6.0/test/require.py 0000664 0001750 0001750 00000006030 13124757510 016221 0 ustar atagar atagar 0000000 0000000 # Copyright 2012-2017, Damian Johnson and The Tor Project
# See LICENSE for licensing information
"""
Testing requirements. This provides annotations to skip tests that shouldn't be
run.
::
Test Requirements
|- only_run_once - skip test if it has been ran before
|- needs - skips the test unless a requirement is met
|
|- cryptography - skips test unless the cryptography module is present
|- pynacl - skips test unless the pynacl module is present
|- command - requires a command to be on the path
|- proc - requires the platform to have recognized /proc contents
|
|- controller - skips test unless tor provides a controller endpoint
|- version - skips test unless we meet a tor version requirement
|- ptrace - requires 'DisableDebuggerAttachment' to be set
+- online - skips unless targets allow for online tests
"""
import stem.util.system
import stem.version
import test
import test.runner
RAN_TESTS = []
def only_run_once(func):
"""
Skips the test if it has ran before. If it hasn't then flags it as being ran.
This is useful to prevent lengthy tests that are independent of integ targets
from being run repeatedly with ``RUN_ALL``.
"""
def wrapped(self, *args, **kwargs):
if self.id() not in RAN_TESTS:
RAN_TESTS.append(self.id())
return func(self, *args, **kwargs)
else:
self.skipTest('(already ran)')
return wrapped
def needs(condition, message):
"""
Skips teh test unless the conditional evaluates to 'true'.
"""
def decorator(func):
def wrapped(self, *args, **kwargs):
if condition():
return func(self, *args, **kwargs)
else:
self.skipTest('(%s)' % message)
return wrapped
return decorator
def _can_access_controller():
return test.runner.get_runner().is_accessible()
def _can_ptrace():
# If we're running a tor version where ptrace is disabled and we didn't
# set 'DisableDebuggerAttachment=1' then we can infer that it's disabled.
has_option = test.tor_version() >= stem.version.Requirement.TORRC_DISABLE_DEBUGGER_ATTACHMENT
return not has_option or test.runner.Torrc.PTRACE in test.runner.get_runner().get_options()
def _is_online():
return test.Target.ONLINE in test.runner.get_runner().attribute_targets
def command(cmd):
"""
Skips the test unless a command is available on the path.
"""
return needs(lambda: stem.util.system.is_available(cmd), '%s unavailable' % cmd)
def version(req_version):
"""
Skips the test unless we meet the required version.
:param stem.version.Version req_version: required tor version for the test
"""
return needs(lambda: test.tor_version() >= req_version, 'requires %s' % req_version)
cryptography = needs(stem.prereq.is_crypto_available, 'requires cryptography')
pynacl = needs(stem.prereq._is_pynacl_available, 'requires pynacl module')
proc = needs(stem.util.proc.is_available, 'proc unavailable')
controller = needs(_can_access_controller, 'no connection')
ptrace = needs(_can_ptrace, 'DisableDebuggerAttachment is set')
online = needs(_is_online, 'requires online target')
stem-1.6.0/test/network.py 0000664 0001750 0001750 00000022770 13124757510 016247 0 ustar atagar atagar 0000000 0000000 # Copyright 2012-2017, Damian Johnson and The Tor Project
# See LICENSE for licensing information
"""
Helper functions and classes to support tests which need to connect through
the tor network.
::
ProxyError - Base error for proxy issues.
+- SocksError - Reports problems returned by the SOCKS proxy.
Socks - Communicate through a SOCKS5 proxy with a socket interface
SocksPatch - Force socket-using code to use test.network.Socks
"""
import functools
import socket
import struct
import stem.util.connection
import stem.util.str_tools
from stem import ProtocolError, SocketError
# Store a reference to the original class so we can find it after
# monkey patching.
_socket_socket = socket.socket
SOCKS5_NOAUTH_GREETING = (0x05, 0x01, 0x00)
SOCKS5_NOAUTH_RESPONSE = (0x05, 0x00)
SOCKS5_CONN_BY_IPV4 = (0x05, 0x01, 0x00, 0x01)
SOCKS5_CONN_BY_NAME = (0x05, 0x01, 0x00, 0x03)
error_msgs = {
0x5a: 'SOCKS4A request granted',
0x5b: 'SOCKS4A request rejected or failed',
0x5c: 'SOCKS4A request failed because client is not running identd (or not reachable from the server)',
0x5d: "SOCKS4A request failed because client's identd could not confirm the user ID string in the request",
}
ip_request = """GET /ip HTTP/1.0
Host: ifconfig.me
Accept-Encoding: identity
"""
class ProxyError(Exception):
'Base error for proxy issues.'
class SocksError(ProxyError):
"""
Exception raised for any problems returned by the SOCKS proxy.
:var int code: error code returned by the SOCKS proxy
"""
# Error messages copied from http://en.wikipedia.org/wiki/SOCKS,
# retrieved 2012-12-15 17:09:21.
_ERROR_MESSAGE = {
0x01: 'general failure',
0x02: 'connection not allowed by ruleset',
0x03: 'network unreachable',
0x04: 'host unreachable',
0x05: 'connection refused by destination host',
0x06: 'TTL expired',
0x07: 'command not supported / protocol error',
0x08: 'address type not supported',
}
def __init__(self, code):
self.code = code
def __str__(self):
code = 0x01
if self.code in self._ERROR_MESSAGE:
code = self.code
return '[%s] %s' % (code, self._ERROR_MESSAGE[code])
class Socks(_socket_socket):
"""
A **socket.socket**-like interface through a SOCKS5 proxy connection.
Tor does not support proxy authentication, so neither does this class.
This class supports the context manager protocol. When used this way, the
socket will automatically close when leaving the context. An example:
::
from test.network import Socks
with Socks(('127.0.0.1', 9050)) as socks:
socks.settimeout(2)
socks.connect(('www.torproject.org', 443))
"""
def __init__(self, proxy_addr, family = socket.AF_INET,
type_ = socket.SOCK_STREAM, proto = 0, _sock = None):
"""
Creates a SOCKS5-aware socket which will route connections through the
proxy_addr SOCKS5 proxy. Currently, only IPv4 TCP connections are
supported, so the defaults for family and type_ are your best option.
:param tuple proxy_addr: address of the SOCKS5 proxy, for IPv4 this
contains (host, port)
:param int family: address family of the socket
:param int type_: address type of the socket (see **socket.socket** for
more information about family and type_)
:returns: :class:`~test.network.Socks`
"""
_socket_socket.__init__(self, family, type_, proto, _sock)
self._proxy_addr = proxy_addr
def __enter__(self, *args, **kwargs):
return self
def __exit__(self, exit_type, value, traceback):
self.close()
return False
def _recvall(self, expected_size):
"""
Returns expected number bytes from the socket, or dies trying.
:param int expected_size: number of bytes to return
:returns:
* **str** in Python 2 (bytes is str)
* **bytes** in Python 3
:raises:
* :class:`socket.error` for socket errors
* :class:`test.SocksError` if the received data was more that expected
"""
while True:
response = self.recv(expected_size * 2)
if len(response) == 0:
raise socket.error('socket closed unexpectedly?')
elif len(response) == expected_size:
return response
elif len(response) > expected_size:
raise SocksError(0x01)
def _ints_to_bytes(self, integers):
"""
Returns a byte string converted from integers.
:param list integers: list of ints to convert
:returns:
* **str** in Python 2 (bytes is str)
* **bytes** in Python 3
"""
if bytes is str:
bytes_ = ''.join([chr(x) for x in integers]) # Python 2
else:
bytes_ = bytes(integers) # Python 3
return bytes_
def _bytes_to_ints(self, bytes_):
"""
Returns a tuple of integers converted from a string (Python 2) or
bytes (Python 3).
:param str,bytes bytes_: byte string to convert
:returns: **list** of ints
"""
try:
integers = [ord(x) for x in bytes_] # Python 2
except TypeError:
integers = [x for x in bytes_] # Python 3
return tuple(integers)
def _pack_string(self, string_):
"""
Returns a packed string for sending over a socket.
:param str string_: string to convert
:returns:
* **str** in Python 2 (bytes is str)
* **bytes** in Python 3
"""
try:
return struct.pack('>%ss' % len(string_), string_)
except struct.error:
# Python 3: encode str to bytes
return struct.pack('>%ss' % len(string_), string_.encode())
def connect(self, address):
"""
Establishes a connection to address through the SOCKS5 proxy.
:param tuple address: target address, for IPv4 this contains
(host, port)
:raises: :class:`test.SocksError` for any errors
"""
_socket_socket.connect(self, (self._proxy_addr[0], self._proxy_addr[1]))
# ask for non-authenticated connection
self.sendall(self._ints_to_bytes(SOCKS5_NOAUTH_GREETING))
response = self._bytes_to_ints(self._recvall(2))
if response != SOCKS5_NOAUTH_RESPONSE:
raise SocksError(0x01)
if stem.util.connection.is_valid_ipv4_address(address[0]):
header = self._ints_to_bytes(SOCKS5_CONN_BY_IPV4)
header = header + socket.inet_aton(address[0])
else:
# As a last gasp, try connecting by name
header = self._ints_to_bytes(SOCKS5_CONN_BY_NAME)
header = header + self._ints_to_bytes([len(address[0])])
header = header + self._pack_string(address[0])
header = header + struct.pack('>H', address[1])
self.sendall(header)
response = self._bytes_to_ints(self._recvall(10))
# check the status byte
if response[1] != 0x00:
raise SocksError(response[1])
def connect_ex(self, address):
"""
Not Implemented.
"""
raise NotImplementedError
class SocksPatch(object):
"""
Monkey-patch **socket.socket** to use :class:`~test.network.Socks`, instead.
Classes in the patched context (e.g. urllib.urlopen in the example below)
do not use the SOCKS5 proxy for domain name resolution and such information
may be leaked.
::
import urllib
from test.network import SocksPatch
with SocksPatch(('127.0.0.1', 9050)):
with urllib.urlopen('https://www.torproject.org') as f:
for line in f.readline():
print line
"""
def __init__(self, *args, **kwargs):
self._partial = functools.partial(Socks, *args, **kwargs)
def __enter__(self):
socket.socket = self._partial
return self
def __exit__(self, exit_type, value, traceback):
socket.socket = _socket_socket
def external_ip(host, port):
"""
Returns the externally visible IP address when using a SOCKS4a proxy.
Negotiates the socks connection, connects to ipconfig.me and requests
http://ifconfig.me/ip to find out the externally visible IP.
Supports only SOCKS4a proxies.
:param str host: hostname/IP of the proxy server
:param int port: port on which the proxy server is listening
:returns: externally visible IP address, or None if it isn't able to
:raises: :class:`stem.socket.SocketError`: unable to connect a socket to the socks server
"""
try:
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect((host, int(port)))
except Exception as exc:
raise SocketError('Failed to connect to the socks server: ' + str(exc))
try:
negotiate_socks(sock, 'ifconfig.me', 80)
sock.sendall(ip_request)
response = sock.recv(1000)
# everything after the blank line is the 'data' in a HTTP response
# The response data for our request for request should be an IP address + '\n'
return response[response.find('\r\n\r\n'):].strip()
except Exception as exc:
return None
def negotiate_socks(sock, host, port):
"""
Negotiate with a socks4a server. Closes the socket and raises an exception on
failure.
:param socket sock: socket connected to socks4a server
:param str host: hostname/IP to connect to
:param int port: port to connect to
:raises: :class:`stem.ProtocolError` if the socks server doesn't grant our request
:returns: a list with the IP address and the port that the proxy connected to
"""
# SOCKS4a request here - http://en.wikipedia.org/wiki/SOCKS#Protocol
request = b'\x04\x01' + struct.pack('!H', port) + b'\x00\x00\x00\x01' + b'\x00' + stem.util.str_tools._to_bytes(host) + b'\x00'
sock.sendall(request)
response = sock.recv(8)
if len(response) != 8 or response[0:2] != b'\x00\x5a':
sock.close()
raise ProtocolError(error_msgs.get(response[1], 'SOCKS server returned unrecognized error code'))
return [socket.inet_ntoa(response[4:]), struct.unpack('!H', response[2:4])[0]]
stem-1.6.0/test/__init__.py 0000664 0001750 0001750 00000010202 13165210535 016274 0 ustar atagar atagar 0000000 0000000 # Copyright 2011-2017, Damian Johnson and The Tor Project
# See LICENSE for licensing information
"""
Unit and integration tests for the stem library. Helpers include...
::
get_new_capabilities - missing capabilities found while testing
register_new_capability - note that tor feature stem lacks
get_all_combinations - provides all combinations of attributes
tor_version - provides the version of tor we're testing against
"""
import collections
import itertools
import os
import stem.util.enum
import stem.version
__all__ = [
'network',
'output',
'prompt',
'runner',
]
# Integration targets fall into two categories:
#
# * Run Targets (like RUN_COOKIE and RUN_PTRACE) which customize our torrc.
# We do an integration test run for each run target we get.
#
# * Attribute Target (like CHROOT and ONLINE) which indicates
# non-configuration changes to your test runs. These are applied to all
# integration runs that we perform.
Target = stem.util.enum.UppercaseEnum(
'ONLINE',
'RELATIVE',
'CHROOT',
'RUN_NONE',
'RUN_OPEN',
'RUN_PASSWORD',
'RUN_COOKIE',
'RUN_MULTIPLE',
'RUN_SOCKET',
'RUN_SCOOKIE',
'RUN_PTRACE',
'RUN_ALL',
)
AsyncTestArgs = collections.namedtuple('AsyncTestArgs', ['test_dir', 'tor_cmd'])
TOR_VERSION = None
# We make some paths relative to stem's base directory (the one above us)
# rather than the process' cwd. This doesn't end with a slash.
STEM_BASE = os.path.sep.join(__file__.split(os.path.sep)[:-2])
# Store new capabilities (events, descriptor entries, etc.)
NEW_CAPABILITIES = []
NEW_CAPABILITIES_SUPPRESSION_TOKENS = set()
# File extensions of contents that should be ignored.
IGNORED_FILE_TYPES = []
with open(os.path.join(STEM_BASE, '.gitignore')) as ignore_file:
for line in ignore_file:
if line.startswith('*.'):
IGNORED_FILE_TYPES.append(line[2:].strip())
if os.path.exists(os.path.join(STEM_BASE, '.travis.yml')):
IGNORED_FILE_TYPES.append('.travis.yml')
def get_new_capabilities():
"""
Provides a list of capabilities tor supports but stem doesn't, as discovered
while running our tests.
:returns: **list** of (type, message) tuples for the capabilities
"""
return NEW_CAPABILITIES
def register_new_capability(capability_type, msg, suppression_token = None):
"""
Register new capability found during the tests.
:param str capability_type: type of capability this is
:param str msg: description of what we found
:param str suppression_token: skip registration if this token's already been
provided
"""
if suppression_token not in NEW_CAPABILITIES_SUPPRESSION_TOKENS:
NEW_CAPABILITIES.append((capability_type, msg))
if suppression_token:
NEW_CAPABILITIES_SUPPRESSION_TOKENS.add(suppression_token)
def get_all_combinations(attr, include_empty = False):
"""
Provides an iterator for all combinations of a set of attributes. For
instance...
::
>>> list(test.get_all_combinations(['a', 'b', 'c']))
[('a',), ('b',), ('c',), ('a', 'b'), ('a', 'c'), ('b', 'c'), ('a', 'b', 'c')]
:param list attr: attributes to provide combinations for
:param bool include_empty: includes an entry with zero items if True
:returns: iterator for all combinations
"""
# Makes an itertools.product() call for 'i' copies of attr...
#
# * itertools.product(attr) => all one-element combinations
# * itertools.product(attr, attr) => all two-element combinations
# * ... etc
if include_empty:
yield ()
seen = set()
for index in range(1, len(attr) + 1):
product_arg = [attr for _ in range(index)]
for item in itertools.product(*product_arg):
# deduplicate, sort, and only provide if we haven't seen it yet
item = tuple(sorted(set(item)))
if item not in seen:
seen.add(item)
yield item
def tor_version(tor_path = None):
"""
Provides the version of tor we're testing against.
:param str tor_path: location of tor executable to cehck the version of
:returns: :class:`~stem.version.Version` of tor invoked by our integration
tests
"""
global TOR_VERSION
if TOR_VERSION is None or tor_path:
TOR_VERSION = stem.version.get_system_tor_version(tor_path)
return TOR_VERSION
stem-1.6.0/test/runner.py 0000664 0001750 0001750 00000044712 13136412262 016062 0 ustar atagar atagar 0000000 0000000 # Copyright 2011-2017, Damian Johnson and The Tor Project
# See LICENSE for licensing information
"""
Runtime context for the integration tests. This is used both by the test runner
to start and stop tor, and by the integration tests themselves for information
about the tor test instance they're running against.
::
RunnerStopped - Runner doesn't have an active tor instance
TorInaccessable - Tor can't be queried for the information
exercise_controller - basic sanity check that a controller connection can be used
get_runner - Singleton for fetching our runtime context.
Runner - Runtime context for our integration tests.
|- start - prepares and starts a tor instance for our tests to run against
|- stop - stops our tor instance and cleans up any temporary files
|- is_running - checks if our tor test instance is running
|- is_accessible - checks if our tor instance can be connected to
|- get_options - custom torrc options used for our test instance
|- get_test_dir - testing directory path
|- get_torrc_path - path to our tor instance's torrc
|- get_torrc_contents - contents of our tor instance's torrc
|- get_auth_cookie_path - path for our authentication cookie if we have one
|- get_tor_cwd - current working directory of our tor process
|- get_chroot - provides the path of our emulated chroot if we have one
|- get_pid - process id of our tor process
|- get_tor_socket - provides a socket to our test instance
|- get_tor_controller - provides a controller for our test instance
+- get_tor_command - provides the command used to start tor
"""
import logging
import os
import shutil
import stat
import tempfile
import threading
import time
import uuid
import stem.connection
import stem.prereq
import stem.process
import stem.socket
import stem.util.conf
import stem.util.enum
import test
from test.output import println, STATUS, ERROR, SUBSTATUS, NO_NL
CONFIG = stem.util.conf.config_dict('test', {
'integ.test_directory': './test/data',
'integ.log': './test/data/log',
'target.torrc': {},
})
SOCKS_PORT = 1112
BASE_TORRC = """# configuration for stem integration tests
DataDirectory %%s
SocksPort %i
DownloadExtraInfo 1
Log notice stdout
Log notice file %%s/tor_log
""" % SOCKS_PORT
# singleton Runner instance
INTEG_RUNNER = None
# control authentication options and attributes
CONTROL_PASSWORD = 'pw'
CONTROL_PORT = 1111
CONTROL_SOCKET_PATH = os.path.join(tempfile.gettempdir(), str(uuid.uuid4()), 'socket')
Torrc = stem.util.enum.Enum(
('PORT', 'ControlPort %i' % CONTROL_PORT),
('COOKIE', 'CookieAuthentication 1'),
('PASSWORD', 'HashedControlPassword 16:8C423A41EF4A542C6078985270AE28A4E04D056FB63F9F201505DB8E06'),
('SOCKET', 'ControlSocket %s' % CONTROL_SOCKET_PATH),
('PTRACE', 'DisableDebuggerAttachment 0'),
)
class RunnerStopped(Exception):
"Raised when we try to use a Runner that doesn't have an active tor instance"
class TorInaccessable(Exception):
'Raised when information is needed from tor but the instance we have is inaccessible'
def exercise_controller(test_case, controller):
"""
Checks that we can now use the socket by issuing a 'GETINFO config-file'
query. Controller can be either a :class:`stem.socket.ControlSocket` or
:class:`stem.control.BaseController`.
:param unittest.TestCase test_case: test being ran
:param controller: tor controller connection to be authenticated
"""
runner = get_runner()
torrc_path = runner.get_torrc_path()
if isinstance(controller, stem.socket.ControlSocket):
controller.send('GETINFO config-file')
config_file_response = controller.recv()
else:
config_file_response = controller.msg('GETINFO config-file')
test_case.assertEqual('config-file=%s\nOK' % torrc_path, str(config_file_response))
def get_runner():
"""
Singleton for the runtime context of integration tests.
:returns: :class:`test.runner.Runner` with context for our integration tests
"""
global INTEG_RUNNER
if not INTEG_RUNNER:
INTEG_RUNNER = Runner()
return INTEG_RUNNER
class _MockChrootFile(object):
"""
Wrapper around a file object that strips given content from readline()
responses. This is used to simulate a chroot setup by removing the prefix
directory from the paths we report.
"""
def __init__(self, wrapped_file, strip_text):
self.wrapped_file = wrapped_file
self.strip_text = strip_text
def readline(self):
return self.wrapped_file.readline().replace(self.strip_text, '')
class Runner(object):
def __init__(self):
self.attribute_targets = []
self._runner_lock = threading.RLock()
# runtime attributes, set by the start method
self._test_dir = ''
self._tor_cmd = None
self._tor_cwd = ''
self._torrc_contents = ''
self._custom_opts = None
self._tor_process = None
self._chroot_path = None
# set if we monkey patch stem.socket.recv_message()
self._original_recv_message = None
# The first controller to attach takes ownership so tor will promptly
# terminate if the tests do. As such we need to ensure that first
# connection is our runner's.
self._owner_controller = None
def start(self, config_target, attribute_targets, tor_cmd):
"""
Makes temporary testing resources and starts tor, blocking until it
completes.
:param str config_target: **Target** for this test run's torrc settings
:param list attribute_targets: **Targets** for our non-configuration attributes
:param str tor_cmd: command to start tor with
:raises: OSError if unable to run test preparations or start tor
"""
with self._runner_lock:
self.attribute_targets = attribute_targets
# if we're holding on to a tor process (running or not) then clean up after
# it so we can start a fresh instance
if self._tor_process:
self.stop()
println('Setting up a test instance...', STATUS)
# if 'test_directory' is unset then we make a new data directory in /tmp
# and clean it up when we're done
config_test_dir = CONFIG['integ.test_directory']
if config_test_dir:
self._test_dir = stem.util.system.expand_path(config_test_dir, test.STEM_BASE)
else:
self._test_dir = tempfile.mktemp('-stem-integ')
original_cwd, data_dir_path = os.getcwd(), self._test_dir
self._tor_cmd = stem.util.system.expand_path(tor_cmd) if os.path.sep in tor_cmd else tor_cmd
if test.Target.RELATIVE in self.attribute_targets:
tor_cwd = os.path.dirname(self._test_dir)
if not os.path.exists(tor_cwd):
os.makedirs(tor_cwd)
os.chdir(tor_cwd)
data_dir_path = './%s' % os.path.basename(self._test_dir)
config_csv = CONFIG['target.torrc'].get(config_target)
extra_torrc_opts = []
if config_csv:
for opt in config_csv.split(','):
opt = opt.strip()
if opt in Torrc.keys():
extra_torrc_opts.append(Torrc[opt])
else:
raise ValueError("'%s' isn't a test.runner.Torrc enumeration" % opt)
self._custom_opts = extra_torrc_opts
self._torrc_contents = BASE_TORRC % (data_dir_path, data_dir_path)
if extra_torrc_opts:
self._torrc_contents += '\n'.join(extra_torrc_opts) + '\n'
try:
self._tor_cwd = os.getcwd()
self._run_setup()
self._start_tor(self._tor_cmd)
# strip the testing directory from recv_message responses if we're
# simulating a chroot setup
if test.Target.CHROOT in self.attribute_targets and not self._original_recv_message:
# TODO: when we have a function for telling stem the chroot we'll
# need to set that too
self._original_recv_message = stem.socket.recv_message
self._chroot_path = data_dir_path
def _chroot_recv_message(control_file):
return self._original_recv_message(_MockChrootFile(control_file, data_dir_path))
stem.socket.recv_message = _chroot_recv_message
if self.is_accessible():
self._owner_controller = self.get_tor_controller(True)
if test.Target.RELATIVE in self.attribute_targets:
os.chdir(original_cwd) # revert our cwd back to normal
except OSError as exc:
raise exc
def stop(self):
"""
Stops our tor test instance and cleans up any temporary resources.
"""
with self._runner_lock:
println('Shutting down tor... ', STATUS, NO_NL)
if self._owner_controller:
self._owner_controller.close()
self._owner_controller = None
if self._tor_process:
# if the tor process has stopped on its own then the following raises
# an OSError ([Errno 3] No such process)
try:
self._tor_process.kill()
except OSError:
pass
self._tor_process.wait() # blocks until the process is done
# if we've made a temporary data directory then clean it up
if self._test_dir and CONFIG['integ.test_directory'] == '':
shutil.rmtree(self._test_dir, ignore_errors = True)
# reverts any mocking of stem.socket.recv_message
if self._original_recv_message:
stem.socket.recv_message = self._original_recv_message
self._original_recv_message = None
# clean up our socket directory if we made one
socket_dir = os.path.dirname(CONTROL_SOCKET_PATH)
if os.path.exists(socket_dir):
shutil.rmtree(socket_dir, ignore_errors = True)
self._test_dir = ''
self._tor_cmd = None
self._tor_cwd = ''
self._torrc_contents = ''
self._custom_opts = None
self._tor_process = None
println('done', STATUS)
def is_running(self):
"""
Checks if we're running a tor test instance and that it's alive.
:returns: True if we have a running tor test instance, False otherwise
"""
with self._runner_lock:
# Check for an unexpected shutdown by calling subprocess.Popen.poll(),
# which returns the exit code or None if we're still running.
if self._tor_process and self._tor_process.poll() is not None:
# clean up the temporary resources and note the unexpected shutdown
self.stop()
println('tor shut down unexpectedly', ERROR)
return bool(self._tor_process)
def is_accessible(self):
"""
Checks if our tor instance has a method of being connected to or not.
:returns: True if tor has a control socket or port, False otherwise
"""
return Torrc.PORT in self._custom_opts or Torrc.SOCKET in self._custom_opts
def get_options(self):
"""
Provides the custom torrc options our tor instance is running with.
:returns: list of Torrc enumerations being used by our test instance
"""
return self._custom_opts
def get_test_dir(self, resource = None):
"""
Provides the absolute path for our testing directory or a file within it.
:param str resource: file within our test directory to provide the path for
:returns: str with our test directory's absolute path or that of a file within it
:raises: :class:`test.runner.RunnerStopped` if we aren't running
"""
if resource:
return os.path.join(self._get('_test_dir'), resource)
else:
return self._get('_test_dir')
def get_torrc_path(self, ignore_chroot = False):
"""
Provides the absolute path for where our testing torrc resides.
:param bool ignore_chroot: provides the real path, rather than the one that tor expects if True
:returns: str with our torrc path
:raises: RunnerStopped if we aren't running
"""
test_dir = self._get('_test_dir')
torrc_path = os.path.join(test_dir, 'torrc')
if not ignore_chroot and self._chroot_path and torrc_path.startswith(self._chroot_path):
torrc_path = torrc_path[len(self._chroot_path):]
return torrc_path
def get_torrc_contents(self):
"""
Provides the contents of our torrc.
:returns: str with the contents of our torrc, lines are newline separated
:raises: :class:`test.runner.RunnerStopped` if we aren't running
"""
return self._get('_torrc_contents')
def get_auth_cookie_path(self):
"""
Provides the absolute path for our authentication cookie if we have one.
If running with an emulated chroot this is uneffected, still providing the
real path.
:returns: str with our auth cookie path
:raises: :class:`test.runner.RunnerStopped` if we aren't running
"""
test_dir = self._get('_test_dir')
return os.path.join(test_dir, 'control_auth_cookie')
def get_tor_cwd(self):
"""
Provides the current working directory of our tor process.
"""
return self._get('_tor_cwd')
def get_chroot(self):
"""
Provides the path we're using to emulate a chroot environment. This is None
if we aren't emulating a chroot setup.
:returns: str with the path of our emulated chroot
"""
return self._chroot_path
def get_pid(self):
"""
Provides the process id of the tor process.
:returns: int pid for the tor process
:raises: :class:`test.runner.RunnerStopped` if we aren't running
"""
tor_process = self._get('_tor_process')
return tor_process.pid
def get_tor_socket(self, authenticate = True):
"""
Provides a socket connected to our tor test instance.
:param bool authenticate: if True then the socket is authenticated
:returns: :class:`stem.socket.ControlSocket` connected with our testing instance
:raises: :class:`test.runner.TorInaccessable` if tor can't be connected to
"""
if Torrc.PORT in self._custom_opts:
control_socket = stem.socket.ControlPort(port = CONTROL_PORT)
elif Torrc.SOCKET in self._custom_opts:
control_socket = stem.socket.ControlSocketFile(CONTROL_SOCKET_PATH)
else:
raise TorInaccessable('Unable to connect to tor')
if authenticate:
stem.connection.authenticate(control_socket, CONTROL_PASSWORD, self.get_chroot())
return control_socket
def get_tor_controller(self, authenticate = True):
"""
Provides a controller connected to our tor test instance.
:param bool authenticate: if True then the socket is authenticated
:returns: :class:`stem.socket.Controller` connected with our testing instance
:raises: :class: `test.runner.TorInaccessable` if tor can't be connected to
"""
control_socket = self.get_tor_socket(False)
controller = stem.control.Controller(control_socket)
if authenticate:
controller.authenticate(password = CONTROL_PASSWORD, chroot_path = self.get_chroot())
return controller
def get_tor_command(self, base_cmd = False):
"""
Provides the command used to run our tor instance.
:param bool base_cmd: provides just the command name if true rather than
the full '--tor path' argument
"""
return os.path.basename(self._get('_tor_cmd')) if base_cmd else self._get('_tor_cmd')
def _get(self, attr):
"""
Fetches one of our attributes in a thread safe manner, raising if we aren't
running.
:param str attr: class variable that we want to fetch
:returns: value of the fetched variable
:returns: :class:`test.runner.RunnerStopped` if we aren't running
"""
with self._runner_lock:
if self.is_running():
return self.__dict__[attr]
else:
raise RunnerStopped()
def _run_setup(self):
"""
Makes a temporary runtime resources of our integration test instance.
:raises: OSError if unsuccessful
"""
# makes a temporary data directory if needed
try:
println(' making test directory (%s)... ' % self._test_dir, STATUS, NO_NL)
if os.path.exists(self._test_dir):
println('skipped', STATUS)
else:
os.makedirs(self._test_dir)
println('done', STATUS)
except OSError as exc:
println('failed (%s)' % exc, ERROR)
raise exc
# Tor checks during startup that the directory a control socket resides in
# is only accessible by the tor user (and refuses to finish starting if it
# isn't).
if Torrc.SOCKET in self._custom_opts:
try:
socket_dir = os.path.dirname(CONTROL_SOCKET_PATH)
println(' making control socket directory (%s)... ' % socket_dir, STATUS, NO_NL)
if os.path.exists(socket_dir) and stat.S_IMODE(os.stat(socket_dir).st_mode) == 0o700:
println('skipped', STATUS)
else:
if not os.path.exists(socket_dir):
os.makedirs(socket_dir)
os.chmod(socket_dir, 0o700)
println('done', STATUS)
except OSError as exc:
println('failed (%s)' % exc, ERROR)
raise exc
# configures logging
logging_path = CONFIG['integ.log']
if logging_path:
logging_path = stem.util.system.expand_path(logging_path, test.STEM_BASE)
println(' configuring logger (%s)... ' % logging_path, STATUS, NO_NL)
# delete the old log
if os.path.exists(logging_path):
os.remove(logging_path)
logging.basicConfig(
filename = logging_path,
level = logging.DEBUG,
format = '%(asctime)s [%(levelname)s] %(message)s',
datefmt = '%D %H:%M:%S',
)
println('done', STATUS)
else:
println(' configuring logger... skipped', STATUS)
# writes our testing torrc
torrc_dst = os.path.join(self._test_dir, 'torrc')
try:
println(' writing torrc (%s)... ' % torrc_dst, STATUS, NO_NL)
torrc_file = open(torrc_dst, 'w')
torrc_file.write(self._torrc_contents)
torrc_file.close()
println('done', STATUS)
for line in self._torrc_contents.strip().splitlines():
println(' %s' % line.strip(), SUBSTATUS)
println()
except Exception as exc:
println('failed (%s)\n' % exc, ERROR)
raise OSError(exc)
def _start_tor(self, tor_cmd):
"""
Initializes a tor process. This blocks until initialization completes or we
error out.
:param str tor_cmd: command to start tor with
:raises: OSError if we either fail to create the tor process or reached a timeout without success
"""
println('Starting %s...\n' % tor_cmd, STATUS)
start_time = time.time()
try:
self._tor_process = stem.process.launch_tor(
tor_cmd = tor_cmd,
torrc_path = os.path.join(self._test_dir, 'torrc'),
completion_percent = 100 if test.Target.ONLINE in self.attribute_targets else 5,
init_msg_handler = lambda line: println(' %s' % line, SUBSTATUS),
take_ownership = True,
)
runtime = time.time() - start_time
println(' done (%i seconds)\n' % runtime, STATUS)
except OSError as exc:
println(' failed to start tor: %s\n' % exc, ERROR)
raise exc
stem-1.6.0/test/output.py 0000664 0001750 0001750 00000016423 13146362451 016114 0 ustar atagar atagar 0000000 0000000 # Copyright 2011-2017, Damian Johnson and The Tor Project
# See LICENSE for licensing information
"""
Variety of filters for the python unit testing output, which can be chained
together for improved readability.
"""
import re
import sys
import stem.util.enum
import stem.util.test_tools
from stem.util import system, term
COLOR_SUPPORT = sys.stdout.isatty() and not system.is_windows()
DIVIDER = '=' * 70
HEADER_ATTR = (term.Color.CYAN, term.Attr.BOLD)
CATEGORY_ATTR = (term.Color.GREEN, term.Attr.BOLD)
NO_NL = 'no newline'
STDERR = 'stderr'
# formatting for various categories of messages
STATUS = (term.Color.BLUE, term.Attr.BOLD)
SUBSTATUS = (term.Color.BLUE, )
SUCCESS = (term.Color.GREEN, term.Attr.BOLD)
ERROR = (term.Color.RED, term.Attr.BOLD)
LineType = stem.util.enum.Enum('OK', 'FAIL', 'ERROR', 'SKIPPED', 'CONTENT')
LINE_ENDINGS = {
' ... ok': LineType.OK,
' ... FAIL': LineType.FAIL,
' ... ERROR': LineType.ERROR,
' ... skipped': LineType.SKIPPED,
}
LINE_ATTR = {
LineType.OK: (term.Color.GREEN,),
LineType.FAIL: (term.Color.RED, term.Attr.BOLD),
LineType.ERROR: (term.Color.RED, term.Attr.BOLD),
LineType.SKIPPED: (term.Color.BLUE,),
LineType.CONTENT: (term.Color.CYAN,),
}
SUPPRESS_STDOUT = False # prevent anything from being printed to stdout
def println(msg = '', *attr):
if SUPPRESS_STDOUT and STDERR not in attr:
return
attr = _flatten(attr)
no_newline = False
stream = sys.stderr if STDERR in attr else sys.stdout
if NO_NL in attr:
no_newline = True
attr.remove(NO_NL)
if STDERR in attr:
attr.remove(STDERR)
if COLOR_SUPPORT and attr:
msg = term.format(msg, *attr)
if not no_newline:
msg += '\n'
stream.write(msg)
stream.flush()
def print_divider(msg, is_header = False):
attr = HEADER_ATTR if is_header else CATEGORY_ATTR
println('%s\n%s\n%s\n' % (DIVIDER, msg.center(70), DIVIDER), *attr)
def print_logging(logging_buffer):
if SUPPRESS_STDOUT:
return
if not logging_buffer.is_empty():
for entry in logging_buffer:
println(entry.replace('\n', '\n '), term.Color.MAGENTA)
print('')
def apply_filters(testing_output, *filters):
"""
Gets the tests results, possibly processed through a series of filters. The
filters are applied in order, each getting the output of the previous.
A filter's input arguments should be the line's (type, content) and the
output is either a string with the new content or None if the line should be
omitted.
:param str testing_output: output from the unit testing
:param list filters: functors to be applied to each line of the results
:returns: str with the processed test results
"""
results = []
for line in testing_output.splitlines():
# determine the type of the line
line_type = LineType.CONTENT
for ending in LINE_ENDINGS:
if ending in line:
line_type = LINE_ENDINGS[ending]
break
for result_filter in filters:
line = result_filter(line_type, line)
if line is None:
break
if line is not None:
results.append(line)
return '\n'.join(results) + '\n'
def colorize(line_type, line_content):
"""
Applies escape sequences so each line is colored according to its type.
"""
if COLOR_SUPPORT:
line_content = term.format(line_content, *LINE_ATTR[line_type])
return line_content
def strip_module(line_type, line_content):
"""
Removes the module name from testing output. This information tends to be
repetitive, and redundant with the headers.
"""
m = re.match('.*( \(test\..*?\)).*', line_content)
if m:
line_content = line_content.replace(m.groups()[0], '', 1)
return line_content
def runtimes(line_type, line_content):
"""
Provides test runtimes if showing verbose results.
"""
m = re.search('(test\.[^)]*)', line_content)
if m and line_type == LineType.OK:
test = '%s.%s' % (m.group(0), line_content.split()[0])
runtime = stem.util.test_tools.test_runtimes().get(test)
if runtime is None:
pass
if runtime >= 1.0:
line_content = '%s (%0.2fs)' % (line_content, runtime)
else:
line_content = '%s (%i ms)' % (line_content, runtime * 1000)
return line_content
def align_results(line_type, line_content):
"""
Strips the normal test results, and adds a right aligned variant instead with
a bold attribute.
"""
if line_type == LineType.CONTENT:
return line_content
# strip our current ending
for ending in LINE_ENDINGS:
if LINE_ENDINGS[ending] == line_type:
line_content = line_content.replace(ending, '', 1)
break
# right align runtimes
if line_content.endswith('s)'):
div = line_content.rfind(' (')
line_content = '%-53s%6s ' % (line_content[:div], line_content[div + 2:-1])
# skipped tests have extra single quotes around the reason
if line_type == LineType.SKIPPED:
line_content = line_content.replace("'(", "(", 1).replace(")'", ")", 1)
if line_type == LineType.OK:
new_ending = 'SUCCESS'
elif line_type in (LineType.FAIL, LineType.ERROR):
new_ending = 'FAILURE'
elif line_type == LineType.SKIPPED:
new_ending = 'SKIPPED'
else:
assert False, 'Unexpected line type: %s' % line_type
return line_content
if COLOR_SUPPORT:
return '%-61s[%s]' % (line_content, term.format(new_ending, term.Attr.BOLD))
else:
return '%-61s[%s]' % (line_content, term.format(new_ending))
class ErrorTracker(object):
"""
Stores any failure or error results we've encountered.
"""
def __init__(self):
self._errors = []
self._error_modules = set()
self._category = None
self._error_noted = False
def register_error(self):
"""
If called then has_errors_occured() will report that an error has occured,
even if we haven't encountered an error message in the tests.
"""
self._error_noted = True
def set_category(self, category):
"""
Optional label that will be presented with testing failures until another
category is specified. If set to None then no category labels are included.
For tests with a lot of output this is intended to help narrow the haystack
in which the user needs to look for failures. In practice this is mostly
used to specify the integ target we're running under.
:param str category: category to label errors as being under
"""
self._category = category
def has_errors_occured(self):
return self._error_noted or bool(self._errors)
def get_filter(self):
def _error_tracker(line_type, line_content):
if line_type in (LineType.FAIL, LineType.ERROR):
if self._category:
self._errors.append('[%s] %s' % (self._category, line_content))
else:
self._errors.append(line_content)
module_match = re.match('.*\((test\.\S+)\.\S+\).*', line_content)
if module_match:
self._error_modules.add(module_match.group(1))
return line_content
return _error_tracker
def get_modules(self):
return self._error_modules
def __iter__(self):
for error_line in self._errors:
yield error_line
def _flatten(seq):
# Flattens nested collections into a single list. For instance...
#
# >>> _flatten([1, [2, 3], 4])
# [1, 2, 3, 4]
result = []
for item in seq:
if (isinstance(item, (tuple, list))):
result.extend(_flatten(item))
else:
result.append(item)
return result
stem-1.6.0/test/unit/ 0000775 0001750 0001750 00000000000 13177674754 015173 5 ustar atagar atagar 0000000 0000000 stem-1.6.0/test/unit/tor_man_with_unknown 0000664 0001750 0001750 00000004577 13115423200 021346 0 ustar atagar atagar 0000000 0000000 '\" t
.\" Title: tor
.\" Author: [see the "AUTHORS" section]
.\" Generator: DocBook XSL Stylesheets v1.76.1
.\" Date: 10/03/2015
.\" Manual: Tor Manual
.\" Source: Tor
.\" Language: English
.\"
.TH "TOR" "1" "10/03/2015" "Tor" "Tor Manual"
.\" -----------------------------------------------------------------
.\" * Define some portability stuff
.\" -----------------------------------------------------------------
.\" ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
.\" http://bugs.debian.org/507673
.\" http://lists.gnu.org/archive/html/groff/2009-02/msg00013.html
.\" ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
.ie \n(.g .ds Aq \(aq
.el .ds Aq '
.\" -----------------------------------------------------------------
.\" * set default formatting
.\" -----------------------------------------------------------------
.\" disable hyphenation
.nh
.\" disable justification (adjust text to left margin only)
.ad l
.\" -----------------------------------------------------------------
.\" * MAIN CONTENT STARTS HERE *
.\" -----------------------------------------------------------------
.SH "NAME"
tor \- The second\-generation onion router
.SH "GENERAL OPTIONS"
.PP
\fBBandwidthRate\fR \fIN\fR \fBbytes\fR|\fBKBytes\fR|\fBMBytes\fR|\fBGBytes\fR|\fBKBits\fR|\fBMBits\fR|\fBGBits\fR
.RS 4
A token bucket limits the average incoming bandwidth usage on this node to the specified number of bytes per second, and the average outgoing bandwidth usage to that same value\&. If you want to run a relay in the public network, this needs to be
\fIat the very least\fR
30 KBytes (that is, 30720 bytes)\&. (Default: 1 GByte)
With this option, and in other options that take arguments in bytes, KBytes, and so on, other formats are also supported\&. Notably, "KBytes" can also be written as "kilobytes" or "kb"; "MBytes" can be written as "megabytes" or "MB"; "kbits" can be written as "kilobits"; and so forth\&. Tor also accepts "byte" and "bit" in the singular\&. The prefixes "tera" and "T" are also recognized\&. If no units are given, we default to bytes\&. To avoid confusion, we recommend writing "bytes" or "bits" explicitly, since it\(cqs easy to forget that "B" means bytes, not bits\&.
.RE
.PP
.SH "NEW OPTIONS"
.PP
\fBSpiffyNewOption\fR \fItransport\fR exec \fIpath\-to\-binary\fR [options]
.RS 4
Description of this new option.
.RE
.PP
stem-1.6.0/test/unit/manual.py 0000664 0001750 0001750 00000042072 13165210554 017004 0 ustar atagar atagar 0000000 0000000 """
Unit testing for the stem.manual module.
"""
import io
import os
import re
import sqlite3
import tempfile
import unittest
import stem.prereq
import stem.manual
import stem.util.system
import test.require
try:
# account for urllib's change between python 2.x and 3.x
import urllib.request as urllib
except ImportError:
import urllib2 as urllib
try:
# added in python 3.3
from unittest.mock import Mock, patch
except ImportError:
from mock import Mock, patch
try:
# added in python 2.7
from collections import OrderedDict
except ImportError:
from stem.util.ordereddict import OrderedDict
URL_OPEN = 'urllib.request.urlopen' if stem.prereq.is_python_3() else 'urllib2.urlopen'
EXAMPLE_MAN_PATH = os.path.join(os.path.dirname(__file__), 'tor_man_example')
UNKNOWN_OPTIONS_MAN_PATH = os.path.join(os.path.dirname(__file__), 'tor_man_with_unknown')
EXPECTED_DESCRIPTION = 'Tor is a connection-oriented anonymizing communication service. Users choose a source-routed path through a set of nodes, and negotiate a "virtual circuit" through the network, in which each node knows its predecessor and successor, but no others. Traffic flowing down the circuit is unwrapped by a symmetric key at each node, which reveals the downstream node.'
EXPECTED_CLI_OPTIONS = {
'-f FILE': 'Specify a new configuration file to contain further Tor configuration options OR pass - to make Tor read its configuration from standard input. (Default: @CONFDIR@/torrc, or $HOME/.torrc if that file is not found)',
'-h, -help': 'Display a short help message and exit.',
'--allow-missing-torrc': 'Do not require that configuration file specified by -f exist if default torrc can be accessed.',
}
EXPECTED_SIGNALS = {
'SIGHUP': 'The signal instructs Tor to reload its configuration (including closing and reopening logs), and kill and restart its helper processes if applicable.',
'SIGTERM': 'Tor will catch this, clean up and sync to disk if necessary, and exit.',
'SIGINT': 'Tor clients behave as with SIGTERM; but Tor servers will do a controlled slow shutdown, closing listeners and waiting 30 seconds before exiting. (The delay can be configured with the ShutdownWaitLength config option.)',
}
EXPECTED_FILES = {
'@LOCALSTATEDIR@/lib/tor/': 'The tor process stores keys and other data here.',
'DataDirectory/cached-status/': 'The most recently downloaded network status document for each authority. Each file holds one such document; the filenames are the hexadecimal identity key fingerprints of the directory authorities. Mostly obsolete.',
'DataDirectory/cached-certs': 'This file holds downloaded directory key certificates that are used to verify authenticity of documents generated by Tor directory authorities.',
'DataDirectory/state': 'A set of persistent key-value mappings. These are documented in the file. These include: o The current entry guards and their status. o The current bandwidth accounting values (unused so far; see below). o When the file was last written o What version of Tor generated the state file o A short history of bandwidth usage, as produced in the server descriptors.',
'@CONFDIR@/torrc': 'The configuration file, which contains "option value" pairs.',
'DataDirectory/bw_accounting': "Used to track bandwidth accounting values (when the current period starts and ends; how much has been read and written so far this period). This file is obsolete, and the data is now stored in the 'state' file as well. Only used when bandwidth accounting is enabled.",
'$HOME/.torrc': 'Fallback location for torrc, if @CONFDIR@/torrc is not found.',
}
EXPECTED_CONFIG_OPTIONS = OrderedDict()
EXPECTED_CONFIG_OPTIONS['BandwidthRate'] = stem.manual.ConfigOption(
name = 'BandwidthRate',
category = 'General',
usage = 'N bytes|KBytes|MBytes|GBytes|KBits|MBits|GBits',
summary = 'Average bandwidth usage limit',
description = 'A token bucket limits the average incoming bandwidth usage on this node to the specified number of bytes per second, and the average outgoing bandwidth usage to that same value. If you want to run a relay in the public network, this needs to be at the very least 75 KBytes for a relay (that is, 600 kbits) or 50 KBytes for a bridge (400 kbits) -- but of course, more is better; we recommend at least 250 KBytes (2 mbits) if possible. (Default: 1 GByte)\n\nWith this option, and in other options that take arguments in bytes, KBytes, and so on, other formats are also supported. Notably, "KBytes" can also be written as "kilobytes" or "kb"; "MBytes" can be written as "megabytes" or "MB"; "kbits" can be written as "kilobits"; and so forth. Tor also accepts "byte" and "bit" in the singular. The prefixes "tera" and "T" are also recognized. If no units are given, we default to bytes. To avoid confusion, we recommend writing "bytes" or "bits" explicitly, since it\'s easy to forget that "B" means bytes, not bits.')
EXPECTED_CONFIG_OPTIONS['BandwidthBurst'] = stem.manual.ConfigOption(
name = 'BandwidthBurst',
category = 'General',
usage = 'N bytes|KBytes|MBytes|GBytes|KBits|MBits|GBits',
summary = 'Maximum bandwidth usage limit',
description = 'Limit the maximum token bucket size (also known as the burst) to the given number of bytes in each direction. (Default: 1 GByte)')
EXPECTED_CONFIG_OPTIONS['MaxAdvertisedBandwidth'] = stem.manual.ConfigOption(
name = 'MaxAdvertisedBandwidth',
category = 'General',
usage = 'N bytes|KBytes|MBytes|GBytes|KBits|MBits|GBits',
summary = 'Limit for the bandwidth we advertise as being available for relaying',
description = 'If set, we will not advertise more than this amount of bandwidth for our BandwidthRate. Server operators who want to reduce the number of clients who ask to build circuits through them (since this is proportional to advertised bandwidth rate) can thus reduce the CPU demands on their server without impacting network performance.')
EXPECTED_CONFIG_OPTIONS['Bridge'] = stem.manual.ConfigOption(
name = 'Bridge',
category = 'Client',
usage = '[transport] IP:ORPort [fingerprint]',
summary = 'Available bridges',
description = 'When set along with UseBridges, instructs Tor to use the relay at "IP:ORPort" as a "bridge" relaying into the Tor network. If "fingerprint" is provided (using the same format as for DirAuthority), we will verify that the relay running at that location has the right fingerprint. We also use fingerprint to look up the bridge descriptor at the bridge authority, if it\'s provided and if UpdateBridgesFromAuthority is set too.\n\nIf "transport" is provided, and matches to a ClientTransportPlugin line, we use that pluggable transports proxy to transfer data to the bridge.')
CACHED_MANUAL = None
def _cached_manual():
global CACHED_MANUAL
if CACHED_MANUAL is None:
CACHED_MANUAL = stem.manual.Manual.from_cache()
return CACHED_MANUAL
class TestManual(unittest.TestCase):
def test_query(self):
self.assertEqual("If set, this option overrides the default location and file name for Tor's cookie file. (See CookieAuthentication above.)", stem.manual.query('SELECT description FROM torrc WHERE name="CookieAuthFile"').fetchone()[0])
self.assertEqual("If set, this option overrides the default location and file name for Tor's cookie file. (See CookieAuthentication above.)", stem.manual.query('SELECT description FROM torrc WHERE name=?', 'CookieAuthFile').fetchone()[0])
def test_query_on_failure(self):
self.assertRaisesRegexp(sqlite3.OperationalError, 'near "hello": syntax error', stem.manual.query, 'hello world')
def test_has_all_summaries(self):
"""
Check that we have brief, human readable summaries for all of tor's
configuration options. If you add a new config entry then please take a sec
to write a little summary. They're located in 'stem/settings.cfg'.
"""
manual = _cached_manual()
present = set(manual.config_options.keys())
expected = set([key[15:] for key in stem.manual._config(lowercase = False) if key.startswith('manual.summary.')])
missing_options = present.difference(expected)
extra_options = expected.difference(present)
if missing_options:
self.fail("Ran cache_manual.py? Please update Stem's settings.cfg with summaries of the following config options: %s" % ', '.join(missing_options))
elif extra_options:
self.fail("Ran cache_manual.py? Please remove the following summaries from Stem's settings.cfg: %s" % ', '.join(extra_options))
def test_is_important(self):
self.assertTrue(stem.manual.is_important('ExitPolicy'))
self.assertTrue(stem.manual.is_important('exitpolicy'))
self.assertTrue(stem.manual.is_important('EXITPOLICY'))
self.assertFalse(stem.manual.is_important('ConstrainedSockSize'))
def test_minimal_config_option(self):
blank = stem.manual.ConfigOption('UnknownOption')
self.assertEqual(stem.manual.Category.UNKNOWN, blank.category)
self.assertEqual('UnknownOption', blank.name)
self.assertEqual('', blank.usage)
self.assertEqual('', blank.summary)
self.assertEqual('', blank.description)
@test.require.command('man')
def test_parsing_with_example(self):
"""
Read a trimmed copy of tor's man page. This gives a good exercise of our
parser with static content. As new oddball man oddities appear feel free to
expand our example (or add another).
"""
if not stem.manual.HAS_ENCODING_ARG:
self.skipTest('(man lacks --encoding arg on OSX, BSD, and Slackware #18660)')
return
manual = stem.manual.Manual.from_man(EXAMPLE_MAN_PATH)
self.assertEqual('tor - The second-generation onion router', manual.name)
self.assertEqual('tor [OPTION value]...', manual.synopsis)
self.assertEqual(EXPECTED_DESCRIPTION, manual.description)
self.assertEqual(EXPECTED_CLI_OPTIONS, manual.commandline_options)
self.assertEqual(EXPECTED_SIGNALS, manual.signals)
self.assertEqual(EXPECTED_FILES, manual.files)
self.assertEqual(EXPECTED_CONFIG_OPTIONS, manual.config_options)
@test.require.command('man')
def test_parsing_with_unknown_options(self):
"""
Check that we can read a local mock man page that contains unrecognized
options. Unlike most other tests this doesn't require network access.
"""
if not stem.manual.HAS_ENCODING_ARG:
self.skipTest('(man lacks --encoding arg on OSX and BSD and Slackware, #18660)')
return
manual = stem.manual.Manual.from_man(UNKNOWN_OPTIONS_MAN_PATH)
self.assertEqual('tor - The second-generation onion router', manual.name)
self.assertEqual('', manual.synopsis)
self.assertEqual('', manual.description)
self.assertEqual({}, manual.commandline_options)
self.assertEqual({}, manual.signals)
self.assertEqual({}, manual.files)
self.assertEqual(2, len(manual.config_options))
option = [entry for entry in manual.config_options.values() if entry.category == stem.manual.Category.UNKNOWN][0]
self.assertEqual(stem.manual.Category.UNKNOWN, option.category)
self.assertEqual('SpiffyNewOption', option.name)
self.assertEqual('transport exec path-to-binary [options]', option.usage)
self.assertEqual('', option.summary)
self.assertEqual('Description of this new option.', option.description)
@test.require.command('man')
def test_saving_manual_as_config(self):
"""
Check that we can save and reload manuals as a config.
"""
if not stem.manual.HAS_ENCODING_ARG:
self.skipTest('(man lacks --encoding arg on OSX, BSD and Slackware, #18660)')
return
manual = stem.manual.Manual.from_man(EXAMPLE_MAN_PATH)
with tempfile.NamedTemporaryFile(prefix = 'saved_test_manual.') as tmp:
manual.save(tmp.name)
loaded_manual = stem.manual.Manual.from_cache(tmp.name)
self.assertEqual(manual, loaded_manual)
@test.require.command('man')
def test_saving_manual_as_sqlite(self):
"""
Check that we can save and reload manuals as sqlite.
"""
if not stem.manual.HAS_ENCODING_ARG:
self.skipTest('(man lacks --encoding arg on OSX, BSD, and Slackware #18660)')
return
manual = stem.manual.Manual.from_man(EXAMPLE_MAN_PATH)
with tempfile.NamedTemporaryFile(prefix = 'saved_test_manual.', suffix = '.sqlite') as tmp:
manual.save(tmp.name)
loaded_manual = stem.manual.Manual.from_cache(tmp.name)
self.assertEqual(manual, loaded_manual)
def test_cached_manual(self):
manual = _cached_manual()
self.assertEqual('tor - The second-generation onion router', manual.name)
self.assertEqual('tor [OPTION value]...', manual.synopsis)
self.assertTrue(manual.description.startswith(EXPECTED_DESCRIPTION))
self.assertTrue(len(manual.commandline_options) > 10)
self.assertTrue(len(manual.signals) > 5)
self.assertTrue(len(manual.files) > 20)
self.assertTrue(len(manual.config_options) > 200)
def test_download_man_page_without_arguments(self):
exc_msg = "Either the path or file_handle we're saving to must be provided"
self.assertRaisesRegexp(ValueError, exc_msg, stem.manual.download_man_page)
@patch('stem.util.system.is_available', Mock(return_value = False))
def test_download_man_page_requires_a2x(self):
exc_msg = 'We require a2x from asciidoc to provide a man page'
self.assertRaisesRegexp(IOError, exc_msg, stem.manual.download_man_page, '/tmp/no_such_file')
@patch('tempfile.mkdtemp', Mock(return_value = '/no/such/path'))
@patch('shutil.rmtree', Mock())
@patch('stem.manual.open', Mock(side_effect = IOError('unable to write to file')), create = True)
@patch('stem.util.system.is_available', Mock(return_value = True))
def test_download_man_page_when_unable_to_write(self):
exc_msg = "Unable to download tor's manual from https://gitweb.torproject.org/tor.git/plain/doc/tor.1.txt to /no/such/path/tor.1.txt: unable to write to file"
self.assertRaisesRegexp(IOError, re.escape(exc_msg), stem.manual.download_man_page, '/tmp/no_such_file')
@patch('tempfile.mkdtemp', Mock(return_value = '/no/such/path'))
@patch('shutil.rmtree', Mock())
@patch('stem.manual.open', Mock(return_value = io.BytesIO()), create = True)
@patch('stem.util.system.is_available', Mock(return_value = True))
@patch(URL_OPEN, Mock(side_effect = urllib.URLError('')))
def test_download_man_page_when_download_fails(self):
exc_msg = "Unable to download tor's manual from https://www.atagar.com/foo/bar to /no/such/path/tor.1.txt: >"
self.assertRaisesRegexp(IOError, re.escape(exc_msg), stem.manual.download_man_page, '/tmp/no_such_file', url = 'https://www.atagar.com/foo/bar')
@patch('tempfile.mkdtemp', Mock(return_value = '/no/such/path'))
@patch('shutil.rmtree', Mock())
@patch('stem.manual.open', Mock(return_value = io.BytesIO()), create = True)
@patch('stem.util.system.call', Mock(side_effect = stem.util.system.CallError('call failed', 'a2x -f manpage /no/such/path/tor.1.txt', 1, None, None, 'call failed')))
@patch('stem.util.system.is_available', Mock(return_value = True))
@patch(URL_OPEN, Mock(return_value = io.BytesIO(b'test content')))
def test_download_man_page_when_a2x_fails(self):
exc_msg = "Unable to run 'a2x -f manpage /no/such/path/tor.1.txt': call failed"
self.assertRaisesRegexp(IOError, exc_msg, stem.manual.download_man_page, '/tmp/no_such_file', url = 'https://www.atagar.com/foo/bar')
@patch('tempfile.mkdtemp', Mock(return_value = '/no/such/path'))
@patch('shutil.rmtree', Mock())
@patch('stem.manual.open', create = True)
@patch('stem.util.system.call')
@patch('stem.util.system.is_available', Mock(return_value = True))
@patch('os.path.exists', Mock(return_value = True))
@patch(URL_OPEN, Mock(return_value = io.BytesIO(b'test content')))
def test_download_man_page_when_successful(self, call_mock, open_mock):
open_mock.side_effect = lambda path, *args: {
'/no/such/path/tor.1.txt': io.BytesIO(),
'/no/such/path/tor.1': io.BytesIO(b'a2x output'),
}[path]
call_mock.return_value = Mock()
output = io.BytesIO()
stem.manual.download_man_page(file_handle = output)
self.assertEqual(b'a2x output', output.getvalue())
call_mock.assert_called_once_with('a2x -f manpage /no/such/path/tor.1.txt')
@patch('stem.manual.HAS_ENCODING_ARG', Mock(return_value = True))
@patch('stem.util.system.is_mac', Mock(return_value = False))
@patch('stem.util.system.is_bsd', Mock(return_value = False))
@patch('stem.util.system.is_slackware', Mock(return_value = False))
@patch('stem.util.system.call', Mock(side_effect = OSError('man --encoding=ascii -P cat tor returned exit status 16')))
def test_from_man_when_manual_is_unavailable(self):
exc_msg = "Unable to run 'man --encoding=ascii -P cat tor': man --encoding=ascii -P cat tor returned exit status 16"
self.assertRaisesRegexp(IOError, exc_msg, stem.manual.Manual.from_man)
@patch('stem.util.system.call', Mock(return_value = []))
def test_when_man_is_empty(self):
manual = stem.manual.Manual.from_man()
self.assertEqual('', manual.name)
self.assertEqual('', manual.synopsis)
self.assertEqual('', manual.description)
self.assertEqual({}, manual.commandline_options)
self.assertEqual({}, manual.signals)
self.assertEqual({}, manual.files)
self.assertEqual(OrderedDict(), manual.config_options)
stem-1.6.0/test/unit/__init__.py 0000664 0001750 0001750 00000000575 13124757510 017273 0 ustar atagar atagar 0000000 0000000 """
Unit tests for the stem library.
"""
import os
import test
__all__ = [
'connection',
'control',
'descriptor',
'exit_policy',
'socket',
'util',
'version',
]
def exec_documentation_example(filename):
path = os.path.join(test.STEM_BASE, 'docs', '_static', 'example', filename)
with open(path) as f:
code = compile(f.read(), path, 'exec')
exec(code)
stem-1.6.0/test/unit/version.py 0000664 0001750 0001750 00000022320 13165210535 017205 0 ustar atagar atagar 0000000 0000000 """
Unit tests for the stem.version.Version parsing and class.
"""
import unittest
import stem.util.system
import stem.version
from stem.version import Version
try:
# added in python 3.3
from unittest.mock import patch
except ImportError:
from mock import patch
TOR_VERSION_OUTPUT = """Mar 22 23:09:37.088 [notice] Tor v0.2.2.35 \
(git-73ff13ab3cc9570d). This is experimental software. Do not rely on it for \
strong anonymity. (Running on Linux i686)
Tor version 0.2.2.35 (git-73ff13ab3cc9570d)."""
class TestVersion(unittest.TestCase):
@patch('stem.util.system.call')
@patch.dict(stem.version.VERSION_CACHE)
def test_get_system_tor_version(self, call_mock):
call_mock.return_value = TOR_VERSION_OUTPUT.splitlines()
version = stem.version.get_system_tor_version('tor_unit')
self.assert_versions_match(version, 0, 2, 2, 35, None, 'git-73ff13ab3cc9570d')
self.assertEqual('73ff13ab3cc9570d', version.git_commit)
call_mock.assert_called_once_with('tor_unit --version')
self.assertEqual(stem.version.VERSION_CACHE['tor_unit'], version)
def test_parsing(self):
"""
Tests parsing by the Version class constructor.
"""
# valid versions with various number of compontents to the version
version = Version('0.1.2.3-tag')
self.assert_versions_match(version, 0, 1, 2, 3, 'tag', None)
version = Version('0.1.2.3')
self.assert_versions_match(version, 0, 1, 2, 3, None, None)
version = Version('0.1.2-tag')
self.assert_versions_match(version, 0, 1, 2, None, 'tag', None)
version = Version('0.1.2')
self.assert_versions_match(version, 0, 1, 2, None, None, None)
# checks an empty tag
version = Version('0.1.2.3-')
self.assert_versions_match(version, 0, 1, 2, 3, '', None)
version = Version('0.1.2-')
self.assert_versions_match(version, 0, 1, 2, None, '', None)
# check with extra informaton
version = Version('0.1.2.3-tag (git-73ff13ab3cc9570d)')
self.assert_versions_match(version, 0, 1, 2, 3, 'tag', 'git-73ff13ab3cc9570d')
self.assertEqual('73ff13ab3cc9570d', version.git_commit)
version = Version('0.1.2.3-tag ()')
self.assert_versions_match(version, 0, 1, 2, 3, 'tag', '')
version = Version('0.1.2 (git-73ff13ab3cc9570d)')
self.assert_versions_match(version, 0, 1, 2, None, None, 'git-73ff13ab3cc9570d')
# checks invalid version strings
self.assertRaises(ValueError, stem.version.Version, '')
self.assertRaises(ValueError, stem.version.Version, '1.2.3.4nodash')
self.assertRaises(ValueError, stem.version.Version, '1.2.3.a')
self.assertRaises(ValueError, stem.version.Version, '1.2.a.4')
self.assertRaises(ValueError, stem.version.Version, '1x2x3x4')
self.assertRaises(ValueError, stem.version.Version, '12.3')
self.assertRaises(ValueError, stem.version.Version, '1.-2.3')
def test_with_multiple_extra(self):
"""
Parse a version with multiple 'extra' fields.
"""
version = Version('0.1.2 (release) (git-73ff13ab3cc9570d)')
self.assert_versions_match(version, 0, 1, 2, None, None, 'release')
self.assertEqual(['release', 'git-73ff13ab3cc9570d'], version.all_extra)
self.assertEqual('73ff13ab3cc9570d', version.git_commit)
def test_comparison(self):
"""
Tests comparision between Version instances.
"""
# check for basic incrementing in each portion
self.assert_version_is_greater('1.1.2.3-tag', '0.1.2.3-tag')
self.assert_version_is_greater('0.2.2.3-tag', '0.1.2.3-tag')
self.assert_version_is_greater('0.1.3.3-tag', '0.1.2.3-tag')
self.assert_version_is_greater('0.1.2.4-tag', '0.1.2.3-tag')
self.assert_version_is_greater('0.1.2.3-ugg', '0.1.2.3-tag')
self.assert_version_is_equal('0.1.2.3-tag', '0.1.2.3-tag')
# check with common tags
self.assert_version_is_greater('0.1.2.3-beta', '0.1.2.3-alpha')
self.assert_version_is_greater('0.1.2.3-rc', '0.1.2.3-beta')
# checks that a missing patch level equals zero
self.assert_version_is_equal('0.1.2', '0.1.2.0')
self.assert_version_is_equal('0.1.2-tag', '0.1.2.0-tag')
# checks for missing patch or status
self.assert_version_is_greater('0.1.2.3-tag', '0.1.2.3')
self.assert_version_is_greater('0.1.2.3-tag', '0.1.2-tag')
self.assert_version_is_greater('0.1.2.3-tag', '0.1.2')
self.assert_version_is_equal('0.1.2.3', '0.1.2.3')
self.assert_version_is_equal('0.1.2', '0.1.2')
def test_nonversion_comparison(self):
"""
Checks that we can be compared with other types.
In python 3 on only equality comparisons work, greater than and less than
comparisons result in a TypeError.
"""
test_version = Version('0.1.2.3')
self.assertNotEqual(test_version, None)
self.assertNotEqual(test_version, 5)
def test_string(self):
"""
Tests the Version -> string conversion.
"""
# checks conversion with various numbers of arguments
self.assert_string_matches('0.1.2.3-tag')
self.assert_string_matches('0.1.2.3')
self.assert_string_matches('0.1.2')
def test_requirements_greater_than(self):
"""
Checks a VersionRequirements with a single greater_than rule.
"""
requirements = stem.version._VersionRequirements()
requirements.greater_than(Version('0.2.2.36'))
self.assertTrue(Version('0.2.2.36') >= requirements)
self.assertTrue(Version('0.2.2.37') >= requirements)
self.assertTrue(Version('0.2.3.36') >= requirements)
self.assertFalse(Version('0.2.2.35') >= requirements)
self.assertFalse(Version('0.2.1.38') >= requirements)
requirements = stem.version._VersionRequirements()
requirements.greater_than(Version('0.2.2.36'), False)
self.assertFalse(Version('0.2.2.35') >= requirements)
self.assertFalse(Version('0.2.2.36') >= requirements)
self.assertTrue(Version('0.2.2.37') >= requirements)
def test_requirements_less_than(self):
"""
Checks a VersionRequirements with a single less_than rule.
"""
requirements = stem.version._VersionRequirements()
requirements.less_than(Version('0.2.2.36'))
self.assertTrue(Version('0.2.2.36') >= requirements)
self.assertTrue(Version('0.2.2.35') >= requirements)
self.assertTrue(Version('0.2.1.38') >= requirements)
self.assertFalse(Version('0.2.2.37') >= requirements)
self.assertFalse(Version('0.2.3.36') >= requirements)
requirements = stem.version._VersionRequirements()
requirements.less_than(Version('0.2.2.36'), False)
self.assertFalse(Version('0.2.2.37') >= requirements)
self.assertFalse(Version('0.2.2.36') >= requirements)
self.assertTrue(Version('0.2.2.35') >= requirements)
def test_requirements_in_range(self):
"""
Checks a VersionRequirements with a single in_range rule.
"""
requirements = stem.version._VersionRequirements()
requirements.in_range(Version('0.2.2.36'), Version('0.2.2.38'))
self.assertFalse(Version('0.2.2.35') >= requirements)
self.assertTrue(Version('0.2.2.36') >= requirements)
self.assertTrue(Version('0.2.2.37') >= requirements)
self.assertFalse(Version('0.2.2.38') >= requirements)
# rule for 'anything in the 0.2.2.x series'
requirements = stem.version._VersionRequirements()
requirements.in_range(Version('0.2.2.0'), Version('0.2.3.0'))
for index in range(0, 100):
self.assertTrue(Version('0.2.2.%i' % index) >= requirements)
def test_requirements_multiple_rules(self):
"""
Checks a VersionRequirements is the logical 'or' when it has multiple rules.
"""
# rule to say 'anything but the 0.2.2.x series'
requirements = stem.version._VersionRequirements()
requirements.greater_than(Version('0.2.3.0'))
requirements.less_than(Version('0.2.2.0'), False)
self.assertTrue(Version('0.2.3.0') >= requirements)
self.assertFalse(Version('0.2.2.0') >= requirements)
for index in range(0, 100):
self.assertFalse(Version('0.2.2.%i' % index) >= requirements)
def assert_versions_match(self, version, major, minor, micro, patch, status, extra):
"""
Asserts that the values for a types.Version instance match the given
values.
"""
self.assertEqual(major, version.major)
self.assertEqual(minor, version.minor)
self.assertEqual(micro, version.micro)
self.assertEqual(patch, version.patch)
self.assertEqual(status, version.status)
self.assertEqual(extra, version.extra)
if extra is None:
self.assertEqual([], version.all_extra)
self.assertEqual(None, version.git_commit)
def assert_version_is_greater(self, first_version, second_version):
"""
Asserts that the parsed version of the first version is greate than the
second (also checking the inverse).
"""
version1 = Version(first_version)
version2 = Version(second_version)
self.assertEqual(version1 > version2, True)
self.assertEqual(version1 < version2, False)
def assert_version_is_equal(self, first_version, second_version):
"""
Asserts that the parsed version of the first version equals the second.
"""
version1 = Version(first_version)
version2 = Version(second_version)
self.assertEqual(version1, version2)
def assert_string_matches(self, version):
"""
Parses the given version string then checks that its string representation
matches the input.
"""
self.assertEqual(version, str(Version(version)))
stem-1.6.0/test/unit/exit_policy/ 0000775 0001750 0001750 00000000000 13177674754 017523 5 ustar atagar atagar 0000000 0000000 stem-1.6.0/test/unit/exit_policy/rule.py 0000664 0001750 0001750 00000034036 13124757510 021032 0 ustar atagar atagar 0000000 0000000 """
Unit tests for the stem.exit_policy.ExitPolicyRule class.
"""
import re
import unittest
from stem.exit_policy import AddressType, ExitPolicyRule, MicroExitPolicy
class TestExitPolicyRule(unittest.TestCase):
def test_accept_or_reject(self):
self.assertTrue(ExitPolicyRule('accept *:*').is_accept)
self.assertFalse(ExitPolicyRule('reject *:*').is_accept)
invalid_inputs = (
'accept',
'reject',
'accept\t*:*',
'accept\n*:*',
'acceptt *:*',
'rejectt *:*',
'blarg *:*',
' *:*',
'*:*',
'',
)
for rule_arg in invalid_inputs:
self.assertRaises(ValueError, ExitPolicyRule, rule_arg)
def test_with_multiple_spaces(self):
rule = ExitPolicyRule('accept *:80')
self.assertEqual('accept *:80', str(rule))
policy = MicroExitPolicy('accept 80,443')
self.assertTrue(policy.can_exit_to('75.119.206.243', 80))
def test_str_unchanged(self):
# provides a series of test inputs where the str() representation should
# match the input rule
test_inputs = (
'accept *:*',
'reject *:*',
'accept *:80',
'accept *:80-443',
'accept 127.0.0.1:80',
'accept 87.0.0.1/24:80',
'accept 156.5.38.3/255.255.0.255:80',
'accept [FFFF:FFFF:FFFF:FFFF:FFFF:FFFF:FFFF:FFFF]:80',
'accept [FFFF:FFFF:FFFF:FFFF:FFFF:FFFF:FFFF:FFFF]/32:80',
)
for rule_arg in test_inputs:
rule = ExitPolicyRule(rule_arg)
self.assertEqual(rule_arg, str(rule))
def test_str_changed(self):
# some instances where our rule is valid but won't match our str() representation
test_inputs = {
'accept 10.0.0.1/32:80': 'accept 10.0.0.1:80',
'accept 192.168.0.1/255.255.255.0:80': 'accept 192.168.0.1/24:80',
'accept [::]/32:*': 'accept [0000:0000:0000:0000:0000:0000:0000:0000]/32:*',
'accept [::]/128:*': 'accept [0000:0000:0000:0000:0000:0000:0000:0000]:*',
'accept6 *:*': 'accept [0000:0000:0000:0000:0000:0000:0000:0000]/0:*',
'reject6 *:*': 'reject [0000:0000:0000:0000:0000:0000:0000:0000]/0:*',
'accept6 [FFFF:FFFF:FFFF:FFFF:FFFF:FFFF:FFFF:FFFF]:*': 'accept [FFFF:FFFF:FFFF:FFFF:FFFF:FFFF:FFFF:FFFF]:*',
'reject6 [FFFF:FFFF:FFFF:FFFF:FFFF:FFFF:FFFF:FFFF]:*': 'reject [FFFF:FFFF:FFFF:FFFF:FFFF:FFFF:FFFF:FFFF]:*',
'accept *4:*': 'accept 0.0.0.0/0:*',
'accept *6:*': 'accept [0000:0000:0000:0000:0000:0000:0000:0000]/0:*',
'accept6 *4:*': 'accept 0.0.0.0/0:*',
'accept6 *6:*': 'accept [0000:0000:0000:0000:0000:0000:0000:0000]/0:*',
}
for rule_arg, expected_str in test_inputs.items():
rule = ExitPolicyRule(rule_arg)
self.assertEqual(expected_str, str(rule))
def test_valid_wildcard(self):
test_inputs = {
'reject *:*': (True, True),
'reject *:80': (True, False),
'accept 192.168.0.1:*': (False, True),
'accept 192.168.0.1:80': (False, False),
'reject *4:*': (False, True),
'reject *6:*': (False, True),
'reject6 *4:*': (False, True),
'reject6 *6:*': (False, True),
'reject 127.0.0.1/0:*': (False, True),
'reject 127.0.0.1/0.0.0.0:*': (False, True),
'reject 127.0.0.1/16:*': (False, True),
'reject 127.0.0.1/32:*': (False, True),
'reject [0000:0000:0000:0000:0000:0000:0000:0000]/0:80': (False, False),
'reject [0000:0000:0000:0000:0000:0000:0000:0000]/64:80': (False, False),
'reject [0000:0000:0000:0000:0000:0000:0000:0000]/128:80': (False, False),
'reject6 *:*': (False, True),
'reject6 *:80': (False, False),
'reject6 [0000:0000:0000:0000:0000:0000:0000:0000]/128:80': (False, False),
'accept 192.168.0.1:0-65535': (False, True),
'accept 192.168.0.1:1-65535': (False, True),
'accept 192.168.0.1:2-65535': (False, False),
'accept 192.168.0.1:1-65534': (False, False),
}
for rule_arg, attr in test_inputs.items():
is_address_wildcard, is_port_wildcard = attr
rule = ExitPolicyRule(rule_arg)
self.assertEqual(is_address_wildcard, rule.is_address_wildcard(), '%s (wildcard expected %s and actually %s)' % (rule_arg, is_address_wildcard, rule.is_address_wildcard()))
self.assertEqual(is_port_wildcard, rule.is_port_wildcard())
# check that when appropriate a /0 is reported as *not* being a wildcard
rule = ExitPolicyRule('reject 127.0.0.1/0:*')
rule._submask_wildcard = False
self.assertEqual(False, rule.is_address_wildcard())
rule = ExitPolicyRule('reject [0000:0000:0000:0000:0000:0000:0000:0000]/0:80')
rule._submask_wildcard = False
self.assertEqual(False, rule.is_address_wildcard())
def test_invalid_wildcard(self):
test_inputs = (
'reject */16:*',
'reject 127.0.0.1/*:*',
'reject *:0-*',
'reject *:*-15',
)
for rule_arg in test_inputs:
self.assertRaises(ValueError, ExitPolicyRule, rule_arg)
def test_wildcard_attributes(self):
rule = ExitPolicyRule('reject *:*')
self.assertEqual(AddressType.WILDCARD, rule.get_address_type())
self.assertEqual(None, rule.address)
self.assertEqual(None, rule.get_mask())
self.assertEqual(None, rule.get_masked_bits())
self.assertEqual(1, rule.min_port)
self.assertEqual(65535, rule.max_port)
def test_valid_ipv4_addresses(self):
test_inputs = {
'0.0.0.0': ('0.0.0.0', '255.255.255.255', 32),
'127.0.0.1/32': ('127.0.0.1', '255.255.255.255', 32),
'192.168.0.50/24': ('192.168.0.50', '255.255.255.0', 24),
'255.255.255.255/0': ('255.255.255.255', '0.0.0.0', 0),
}
for rule_addr, attr in test_inputs.items():
address, mask, masked_bits = attr
rule = ExitPolicyRule('accept %s:*' % rule_addr)
self.assertEqual(AddressType.IPv4, rule.get_address_type())
self.assertEqual(address, rule.address)
self.assertEqual(mask, rule.get_mask())
self.assertEqual(masked_bits, rule.get_masked_bits())
def test_invalid_ipv4_addresses(self):
test_inputs = (
'256.0.0.0',
'-1.0.0.0',
'0.0.0',
'0.0.0.',
'0.0.0.a',
'127.0.0.1/-1',
'127.0.0.1/33',
)
for rule_addr in test_inputs:
self.assertRaises(ValueError, ExitPolicyRule, 'accept %s:*' % rule_addr)
def test_valid_ipv6_addresses(self):
test_inputs = {
'[fe80:0000:0000:0000:0202:b3ff:fe1e:8329]':
('FE80:0000:0000:0000:0202:B3FF:FE1E:8329',
'FFFF:FFFF:FFFF:FFFF:FFFF:FFFF:FFFF:FFFF', 128),
'[FE80::0202:b3ff:fe1e:8329]':
('FE80:0000:0000:0000:0202:B3FF:FE1E:8329',
'FFFF:FFFF:FFFF:FFFF:FFFF:FFFF:FFFF:FFFF', 128),
'[0000:0000:0000:0000:0000:0000:0000:0000]/0':
('0000:0000:0000:0000:0000:0000:0000:0000',
'0000:0000:0000:0000:0000:0000:0000:0000', 0),
'[::]':
('0000:0000:0000:0000:0000:0000:0000:0000',
'FFFF:FFFF:FFFF:FFFF:FFFF:FFFF:FFFF:FFFF', 128),
}
for rule_addr, attr in test_inputs.items():
address, mask, masked_bits = attr
rule = ExitPolicyRule('accept %s:*' % rule_addr)
self.assertEqual(AddressType.IPv6, rule.get_address_type())
self.assertEqual(address, rule.address)
self.assertEqual(mask, rule.get_mask())
self.assertEqual(masked_bits, rule.get_masked_bits())
def test_invalid_ipv6_addresses(self):
test_inputs = (
'fe80::0202:b3ff:fe1e:8329',
'[fe80::0202:b3ff:fe1e:8329',
'fe80::0202:b3ff:fe1e:8329]',
'[fe80::0202:b3ff:fe1e:832g]',
'[fe80:::b3ff:fe1e:8329]',
'[fe80::b3ff::fe1e:8329]',
'[fe80::0202:b3ff:fe1e:8329]/-1',
'[fe80::0202:b3ff:fe1e:8329]/129',
)
for rule_addr in test_inputs:
self.assertRaises(ValueError, ExitPolicyRule, 'accept %s:*' % rule_addr)
def test_valid_ports(self):
test_inputs = {
'0': (0, 0),
'1': (1, 1),
'80': (80, 80),
'80-443': (80, 443),
}
for rule_port, attr in test_inputs.items():
min_port, max_port = attr
rule = ExitPolicyRule('accept 127.0.0.1:%s' % rule_port)
self.assertEqual(min_port, rule.min_port)
self.assertEqual(max_port, rule.max_port)
def test_invalid_ports(self):
test_inputs = (
'65536',
'a',
'5-3',
'5-',
'-3',
)
for rule_port in test_inputs:
self.assertRaises(ValueError, ExitPolicyRule, 'accept 127.0.0.1:%s' % rule_port)
def test_is_match_wildcard(self):
test_inputs = {
'reject *:*': {
('192.168.0.1', 80): True,
('0.0.0.0', 80): True,
('255.255.255.255', 80): True,
('FE80:0000:0000:0000:0202:B3FF:FE1E:8329', 80): True,
('[FE80:0000:0000:0000:0202:B3FF:FE1E:8329]', 80): True,
('192.168.0.1', None): True,
(None, 80, False): True,
(None, 80, True): True,
(None, None, False): True,
(None, None, True): True,
},
'reject 255.255.255.255/0:*': {
('192.168.0.1', 80): True,
('0.0.0.0', 80): True,
('255.255.255.255', 80): True,
('FE80:0000:0000:0000:0202:B3FF:FE1E:8329', 80): False,
('[FE80:0000:0000:0000:0202:B3FF:FE1E:8329]', 80): False,
('192.168.0.1', None): True,
(None, 80, False): False,
(None, 80, True): True,
(None, None, False): False,
(None, None, True): True,
},
'reject *4:*': {
('192.168.0.1', 80): True,
('FE80:0000:0000:0000:0202:B3FF:FE1E:8329', 80): False,
},
'reject *6:*': {
('192.168.0.1', 80): False,
('FE80:0000:0000:0000:0202:B3FF:FE1E:8329', 80): True,
},
}
for rule_arg, matches in test_inputs.items():
rule = ExitPolicyRule(rule_arg)
rule._submask_wildcard = False
for match_args, expected_result in matches.items():
self.assertEqual(expected_result, rule.is_match(*match_args))
# port zero is special in that exit policies can include it, but it's not
# something that we can match against
rule = ExitPolicyRule('reject *:*')
self.assertRaises(ValueError, rule.is_match, '127.0.0.1', 0)
def test_is_match_ipv4(self):
test_inputs = {
'reject 192.168.0.50:*': {
('192.168.0.50', 80): True,
('192.168.0.51', 80): False,
('192.168.0.49', 80): False,
(None, 80, False): False,
(None, 80, True): True,
('192.168.0.50', None): True,
},
'reject 0.0.0.0/24:*': {
('0.0.0.0', 80): True,
('0.0.0.1', 80): True,
('0.0.0.255', 80): True,
('0.0.1.0', 80): False,
('0.1.0.0', 80): False,
('1.0.0.0', 80): False,
(None, 80, False): False,
(None, 80, True): True,
('0.0.0.0', None): True,
},
}
for rule_arg, matches in test_inputs.items():
rule = ExitPolicyRule(rule_arg)
for match_args, expected_result in matches.items():
self.assertEqual(expected_result, rule.is_match(*match_args))
def test_is_match_ipv6(self):
test_inputs = {
'reject [FE80:0000:0000:0000:0202:B3FF:FE1E:8329]:*': {
('FE80:0000:0000:0000:0202:B3FF:FE1E:8329', 80): True,
('fe80:0000:0000:0000:0202:b3ff:fe1e:8329', 80): True,
('[FE80:0000:0000:0000:0202:B3FF:FE1E:8329]', 80): True,
('FE80:0000:0000:0000:0202:B3FF:FE1E:8330', 80): False,
('FE80:0000:0000:0000:0202:B3FF:FE1E:8328', 80): False,
(None, 80, False): False,
(None, 80, True): True,
('FE80:0000:0000:0000:0202:B3FF:FE1E:8329', None): True,
},
'reject [FE80:0000:0000:0000:0202:B3FF:FE1E:8329]/112:*': {
('FE80:0000:0000:0000:0202:B3FF:FE1E:8329', 80): True,
('FE80:0000:0000:0000:0202:B3FF:FE1E:0000', 80): True,
('FE80:0000:0000:0000:0202:B3FF:FE1E:FFFF', 80): True,
('FE80:0000:0000:0000:0202:B3FF:FE1F:8329', 80): False,
('FE81:0000:0000:0000:0202:B3FF:FE1E:8329', 80): False,
(None, 80, False): False,
(None, 80, True): True,
('FE80:0000:0000:0000:0202:B3FF:FE1E:8329', None, False): True,
('FE80:0000:0000:0000:0202:B3FF:FE1E:8329', None, True): True,
},
}
for rule_arg, matches in test_inputs.items():
rule = ExitPolicyRule(rule_arg)
for match_args, expected_result in matches.items():
self.assertEqual(expected_result, rule.is_match(*match_args))
def test_is_match_port(self):
test_inputs = {
'reject *:80': {
('192.168.0.50', 80): True,
('192.168.0.50', 81): False,
('192.168.0.50', 79): False,
(None, 80): True,
('192.168.0.50', None, False): False,
('192.168.0.50', None, True): True,
},
'reject *:80-85': {
('192.168.0.50', 79): False,
('192.168.0.50', 80): True,
('192.168.0.50', 83): True,
('192.168.0.50', 85): True,
('192.168.0.50', 86): False,
(None, 83): True,
('192.168.0.50', None, False): False,
('192.168.0.50', None, True): True,
},
}
for rule_arg, matches in test_inputs.items():
rule = ExitPolicyRule(rule_arg)
for match_args, expected_result in matches.items():
self.assertEqual(expected_result, rule.is_match(*match_args))
def test_missing_port(self):
exc_msg = "An exitpattern must be of the form 'addrspec:portspec': accept6 192.168.0.1/0"
self.assertRaisesRegexp(ValueError, re.escape(exc_msg), ExitPolicyRule, 'accept6 192.168.0.1/0')
exc_msg = "An exitpattern must be of the form 'addrspec:portspec': reject6 [2a00:1450:4001:081e:0000:0000:0000:200e]"
self.assertRaisesRegexp(ValueError, re.escape(exc_msg), ExitPolicyRule, 'reject6 [2a00:1450:4001:081e:0000:0000:0000:200e]')
def test_ipv6_only_entries(self):
# accept6/reject6 shouldn't match anything when given an ipv4 addresses
rule = ExitPolicyRule('accept6 192.168.0.1/0:*')
self.assertTrue(rule._skip_rule)
self.assertFalse(rule.is_match('192.168.0.1'))
self.assertFalse(rule.is_match('FE80:0000:0000:0000:0202:B3FF:FE1E:8329'))
self.assertFalse(rule.is_match())
rule = ExitPolicyRule('accept6 *4:*')
self.assertTrue(rule._skip_rule)
# wildcards match all ipv6 but *not* ipv4
rule = ExitPolicyRule('accept6 *:*')
self.assertTrue(rule.is_match('FE80:0000:0000:0000:0202:B3FF:FE1E:8329', 443))
self.assertFalse(rule.is_match('192.168.0.1', 443))
stem-1.6.0/test/unit/exit_policy/__init__.py 0000664 0001750 0001750 00000000123 13115423200 021572 0 ustar atagar atagar 0000000 0000000 """
Unit tests for stem.exit_policy.py contents.
"""
__all__ = ['policy', 'rule']
stem-1.6.0/test/unit/exit_policy/policy.py 0000664 0001750 0001750 00000026534 13124757510 021366 0 ustar atagar atagar 0000000 0000000 """
Unit tests for the stem.exit_policy.ExitPolicy class.
"""
import pickle
import unittest
try:
# added in python 3.3
from unittest.mock import Mock, patch
except ImportError:
from mock import Mock, patch
from stem.exit_policy import (
DEFAULT_POLICY_RULES,
get_config_policy,
ExitPolicy,
MicroExitPolicy,
ExitPolicyRule,
)
class TestExitPolicy(unittest.TestCase):
def test_example(self):
# tests the ExitPolicy and MicroExitPolicy pydoc examples
policy = ExitPolicy('accept *:80', 'accept *:443', 'reject *:*')
self.assertEqual('accept *:80, accept *:443, reject *:*', str(policy))
self.assertEqual('accept 80, 443', policy.summary())
self.assertTrue(policy.can_exit_to('75.119.206.243', 80))
policy = MicroExitPolicy('accept 80,443')
self.assertTrue(policy.can_exit_to('75.119.206.243', 80))
def test_constructor(self):
# The ExitPolicy constructor takes a series of string or ExitPolicyRule
# entries. Extra whitespace is ignored to make csvs easier to handle.
expected_policy = ExitPolicy(
ExitPolicyRule('accept *:80'),
ExitPolicyRule('accept *:443'),
ExitPolicyRule('reject *:*'),
)
policy = ExitPolicy('accept *:80', 'accept *:443', 'reject *:*')
self.assertEqual(expected_policy, policy)
policy = ExitPolicy(*'accept *:80, accept *:443, reject *:*'.split(','))
self.assertEqual(expected_policy, policy)
# checks that we truncate after getting a catch-all policy
policy = ExitPolicy(*'accept *:80, accept *:443, reject *:*, accept *:20-50'.split(','))
self.assertEqual(expected_policy, policy)
# checks that we compress redundant policies
policy = ExitPolicy(*'reject *:80, reject *:443, reject *:*'.split(','))
self.assertEqual(ExitPolicy('reject *:*'), policy)
def test_can_exit_to(self):
# Basic sanity test for our can_exit_to() method. Most of the interesting
# use cases (ip masks, wildcards, etc) are covered by the ExitPolicyRule
# tests.
policy = ExitPolicy('accept *:80', 'accept *:443', 'reject *:*')
for index in range(1, 100):
ip_addr = '%i.%i.%i.%i' % (index / 2, index / 2, index / 2, index / 2)
expected_result = index in (80, 443)
self.assertEqual(expected_result, policy.can_exit_to(ip_addr, index))
self.assertEqual(expected_result, policy.can_exit_to(port = index))
def test_can_exit_to_strictness(self):
# Check our 'strict' argument.
policy = ExitPolicy('reject 1.0.0.0/8:80', 'accept *:*')
self.assertEqual(False, policy.can_exit_to(None, 80, strict = True)) # can't exit to *all* instances of port 80
self.assertEqual(True, policy.can_exit_to(None, 80, strict = False)) # can exit to *an* instance of port 80
policy = ExitPolicy('accept 1.0.0.0/8:80', 'reject *:*')
self.assertEqual(False, policy.can_exit_to(None, 80, strict = True)) # can't exit to *all* instances of port 80
self.assertEqual(True, policy.can_exit_to(None, 80, strict = False)) # can exit to *an* instance of port 80
def test_is_exiting_allowed(self):
test_inputs = {
(): True,
('accept *:*', ): True,
('reject *:*', ): False,
('accept *:80', 'reject *:*'): True,
('reject *:80', 'accept *:80', 'reject *:*'): False,
('reject *:50-90', 'accept *:80', 'reject *:*'): False,
('reject *:2-65535', 'accept *:80-65535', 'reject *:*'): False,
('reject *:2-65535', 'accept 127.0.0.0:1', 'reject *:*'): True,
('reject 127.0.0.1:*', 'accept *:80', 'reject *:*'): True,
}
for rules, expected_result in test_inputs.items():
policy = ExitPolicy(*rules)
self.assertEqual(expected_result, policy.is_exiting_allowed())
def test_summary_examples(self):
# checks the summary() method's pydoc examples
policy = ExitPolicy('accept *:80', 'accept *:443', 'reject *:*')
self.assertEqual('accept 80, 443', policy.summary())
policy = ExitPolicy('accept *:443', 'reject *:1-1024', 'accept *:*')
self.assertEqual('reject 1-442, 444-1024', policy.summary())
def test_summary_large_ranges(self):
# checks the summary() method when the policy includes very large port ranges
policy = ExitPolicy('reject *:80-65535', 'accept *:1-65533', 'reject *:*')
self.assertEqual('accept 1-79', policy.summary())
def test_without_port(self):
policy = get_config_policy('accept 216.58.193.78, reject *')
self.assertEqual([ExitPolicyRule('accept 216.58.193.78:*'), ExitPolicyRule('reject *:*')], list(policy))
policy = get_config_policy('reject6 [2a00:1450:4001:081e:0000:0000:0000:200e]')
self.assertEqual([ExitPolicyRule('reject [2a00:1450:4001:081e:0000:0000:0000:200e]:*')], list(policy))
def test_non_private_non_default_policy(self):
policy = get_config_policy('reject *:80-65535, accept *:1-65533, reject *:*')
for rule in policy:
self.assertFalse(rule.is_private())
self.assertFalse(rule.is_default())
self.assertFalse(policy.has_private())
self.assertFalse(policy.has_default())
self.assertEqual(policy, policy.strip_private())
self.assertEqual(policy, policy.strip_default())
def test_all_private_policy(self):
for port in ('*', '80', '1-1024'):
private_policy = get_config_policy('reject private:%s' % port, '12.34.56.78')
for rule in private_policy:
self.assertTrue(rule.is_private())
self.assertEqual(ExitPolicy(), private_policy.strip_private())
# though not commonly done, technically private policies can be accept rules too
private_policy = get_config_policy('accept private:*')
self.assertEqual(ExitPolicy(), private_policy.strip_private())
@patch('socket.gethostname', Mock(side_effect = IOError('no address')))
def test_all_private_policy_without_network(self):
for rule in get_config_policy('reject private:80, accept *:80'):
# all rules except the ending accept are part of the private policy
self.assertEqual(str(rule) != 'accept *:80', rule.is_private())
def test_all_default_policy(self):
policy = ExitPolicy(*DEFAULT_POLICY_RULES)
for rule in policy:
self.assertTrue(rule.is_default())
self.assertTrue(policy.has_default())
self.assertEqual(ExitPolicy(), policy.strip_default())
def test_mixed_private_policy(self):
policy = get_config_policy('accept *:80, reject private:1-65533, accept *:*')
for rule in policy:
self.assertTrue(rule.is_accept != rule.is_private()) # only reject rules are the private ones
self.assertEqual(get_config_policy('accept *:80, accept *:*'), policy.strip_private())
def test_mixed_default_policy(self):
policy = ExitPolicy('accept *:80', 'accept 127.0.0.1:1-65533', *DEFAULT_POLICY_RULES)
for rule in policy:
# only accept-all and reject rules are the default ones
self.assertTrue(rule.is_accept != rule.is_default() or (rule.is_accept and rule.is_address_wildcard() and rule.is_port_wildcard()))
self.assertEqual(get_config_policy('accept *:80, accept 127.0.0.1:1-65533'), policy.strip_default())
def test_get_config_policy_with_ipv6(self):
# ensure our constructor accepts addresses both with and without brackets
self.assertTrue(get_config_policy('reject private:80', 'fe80:0000:0000:0000:0202:b3ff:fe1e:8329').is_exiting_allowed())
self.assertTrue(get_config_policy('reject private:80', '[fe80:0000:0000:0000:0202:b3ff:fe1e:8329]').is_exiting_allowed())
def test_str(self):
# sanity test for our __str__ method
policy = ExitPolicy(' accept *:80\n', '\taccept *:443')
self.assertEqual('accept *:80, accept *:443', str(policy))
policy = ExitPolicy('reject 0.0.0.0/255.255.255.0:*', 'accept *:*')
self.assertEqual('reject 0.0.0.0/24:*, accept *:*', str(policy))
def test_iter(self):
# sanity test for our __iter__ method
rules = [
ExitPolicyRule('accept *:80'),
ExitPolicyRule('accept *:443'),
ExitPolicyRule('reject *:*'),
]
self.assertEqual(rules, list(ExitPolicy(*rules)))
self.assertEqual(rules, list(ExitPolicy('accept *:80', 'accept *:443', 'reject *:*')))
def test_microdescriptor_parsing(self):
# mapping between inputs and if they should succeed or not
test_inputs = {
'accept 80': True,
'accept 80,443': True,
'': False,
'accept': False,
'accept ': False,
'accept\t80,443': False,
'accept 80, 443': False,
'accept 80,\t443': False,
'80,443': False,
'accept 80,-443': False,
'accept 80,+443': False,
'accept 80,66666': False,
'reject 80,foo': False,
'bar 80,443': False,
}
for policy_arg, expect_success in test_inputs.items():
try:
policy = MicroExitPolicy(policy_arg)
if expect_success:
self.assertEqual(policy_arg, str(policy))
else:
self.fail()
except ValueError:
if expect_success:
self.fail()
def test_microdescriptor_attributes(self):
# checks that its is_accept attribute is properly set
# single port
policy = MicroExitPolicy('accept 443')
self.assertTrue(policy.is_accept)
# multiple ports
policy = MicroExitPolicy('accept 80,443')
self.assertTrue(policy.is_accept)
# port range
policy = MicroExitPolicy('reject 1-1024')
self.assertFalse(policy.is_accept)
def test_microdescriptor_can_exit_to(self):
test_inputs = {
'accept 443': {442: False, 443: True, 444: False},
'reject 443': {442: True, 443: False, 444: True},
'accept 80,443': {80: True, 443: True, 10: False},
'reject 1-1024': {1: False, 1024: False, 1025: True},
}
for policy_arg, attr in test_inputs.items():
policy = MicroExitPolicy(policy_arg)
for port, expected_value in attr.items():
self.assertEqual(expected_value, policy.can_exit_to(port = port))
# address argument should be ignored
policy = MicroExitPolicy('accept 80,443')
self.assertFalse(policy.can_exit_to('127.0.0.1', 79))
self.assertTrue(policy.can_exit_to('127.0.0.1', 80))
def test_get_config_policy(self):
test_inputs = {
'': ExitPolicy(),
'reject *': ExitPolicy('reject *:*'),
'reject *:*': ExitPolicy('reject *:*'),
'reject private': ExitPolicy(
'reject 0.0.0.0/8:*',
'reject 169.254.0.0/16:*',
'reject 127.0.0.0/8:*',
'reject 192.168.0.0/16:*',
'reject 10.0.0.0/8:*',
'reject 172.16.0.0/12:*',
'reject 12.34.56.78:*',
),
'accept *:80, reject *': ExitPolicy(
'accept *:80',
'reject *:*',
),
' accept *:80, reject * ': ExitPolicy(
'accept *:80',
'reject *:*',
),
}
for test_input, expected in test_inputs.items():
self.assertEqual(expected, get_config_policy(test_input, '12.34.56.78'))
test_inputs = (
'blarg',
'accept *:*:*',
'acceptt *:80',
'accept 257.0.0.1:80',
'accept *:999999',
)
for test_input in test_inputs:
self.assertRaises(ValueError, get_config_policy, test_input)
def test_pickleability(self):
"""
Checks that we can unpickle ExitPolicy instances.
"""
policy = ExitPolicy('accept *:80', 'accept *:443', 'reject *:*')
self.assertTrue(policy.can_exit_to('74.125.28.106', 80))
encoded_policy = pickle.dumps(policy)
restored_policy = pickle.loads(encoded_policy)
self.assertEqual(policy, restored_policy)
self.assertTrue(restored_policy.is_exiting_allowed())
self.assertTrue(restored_policy.can_exit_to('74.125.28.106', 80))
stem-1.6.0/test/unit/doctest.py 0000664 0001750 0001750 00000007202 13124757510 017173 0 ustar atagar atagar 0000000 0000000 """
Tests examples from our documentation.
"""
from __future__ import absolute_import
import doctest
import os
import unittest
import stem.descriptor.router_status_entry
import stem.util.connection
import stem.util.str_tools
import stem.util.system
import stem.version
import test
from stem.response import ControlMessage
try:
# added in python 3.3
from unittest.mock import Mock, patch
except ImportError:
from mock import Mock, patch
EXPECTED_CIRCUIT_STATUS = """\
20 EXTENDED $718BCEA286B531757ACAFF93AE04910EA73DE617=KsmoinOK,$649F2D0ACF418F7CFC6539AB2257EB2D5297BAFA=Eskimo BUILD_FLAGS=NEED_CAPACITY PURPOSE=GENERAL TIME_CREATED=2012-12-06T13:51:11.433755
19 BUILT $718BCEA286B531757ACAFF93AE04910EA73DE617=KsmoinOK,$30BAB8EE7606CBD12F3CC269AE976E0153E7A58D=Pascal1,$2765D8A8C4BBA3F89585A9FFE0E8575615880BEB=Anthracite PURPOSE=GENERAL TIME_CREATED=2012-12-06T13:50:56.969938\
"""
ADD_ONION_RESPONSE = """\
250-ServiceID=oekn5sqrvcu4wote
250-ClientAuth=bob:nKwfvVPmTNr2k2pG0pzV4g
250 OK
"""
class TestDocumentation(unittest.TestCase):
def test_examples(self):
stem_dir = os.path.join(test.STEM_BASE, 'stem')
is_failed = False
for path in stem.util.system.files_with_suffix(stem_dir, '.py'):
args = {'module_relative': False}
test_run = None
if path.endswith('/stem/util/conf.py'):
with patch('stem.util.conf.get_config') as get_config_mock:
config = Mock()
config.load.return_value = None
get_config_mock.return_value = config
test_run = doctest.testfile(path, **args)
elif path.endswith('/stem/descriptor/router_status_entry.py'):
args['globs'] = {
'_base64_to_hex': stem.descriptor.router_status_entry._base64_to_hex,
}
test_run = doctest.testfile(path, **args)
elif path.endswith('/stem/util/connection.py'):
args['globs'] = {
'expand_ipv6_address': stem.util.connection.expand_ipv6_address,
}
test_run = doctest.testfile(path, **args)
elif path.endswith('/stem/util/str_tools.py'):
args['globs'] = {
'_to_camel_case': stem.util.str_tools._to_camel_case,
'_split_by_length': stem.util.str_tools._split_by_length,
'crop': stem.util.str_tools.crop,
'size_label': stem.util.str_tools.size_label,
'time_label': stem.util.str_tools.time_label,
'time_labels': stem.util.str_tools.time_labels,
'short_time_label': stem.util.str_tools.short_time_label,
'parse_short_time_label': stem.util.str_tools.parse_short_time_label,
}
test_run = doctest.testfile(path, **args)
elif path.endswith('/stem/response/__init__.py'):
pass # the escaped slashes seem to be confusing doctest
elif path.endswith('/stem/control.py'):
controller = Mock()
controller.extend_circuit.side_effect = [19, 20]
controller.get_info.side_effect = lambda arg: {
'circuit-status': EXPECTED_CIRCUIT_STATUS,
}[arg]
response = ControlMessage.from_str(ADD_ONION_RESPONSE, 'ADD_ONION', normalize = True)
controller.create_ephemeral_hidden_service.return_value = response
args['globs'] = {'controller': controller}
test_run = doctest.testfile(path, **args)
elif path.endswith('/stem/version.py'):
with patch('stem.version.get_system_tor_version', Mock(return_value = stem.version.Version('0.2.1.30'))):
test_run = doctest.testfile(path, **args)
else:
test_run = doctest.testfile(path, **args)
if test_run and test_run.failed > 0:
is_failed = True
if is_failed:
self.fail('doctests encountered errors')
stem-1.6.0/test/unit/response/ 0000775 0001750 0001750 00000000000 13177674754 017031 5 ustar atagar atagar 0000000 0000000 stem-1.6.0/test/unit/response/add_onion.py 0000664 0001750 0001750 00000010143 13124757510 021314 0 ustar atagar atagar 0000000 0000000 """
Unit tests for the stem.response.add_onion.AddOnionResponse class.
"""
import unittest
import stem
import stem.response
import stem.response.add_onion
from stem.response import ControlMessage
WITH_PRIVATE_KEY = """250-ServiceID=gfzprpioee3hoppz
250-PrivateKey=RSA1024:MIICXgIBAAKBgQDZvYVxvKPTWhId/8Ss9fVxjAoFDsrJ3pk6HjHrEFRm3ypkK/vArbG9BrupzzYcyms+lO06O8b/iOSHuZI5mUEGkrYqQ+hpB2SkPUEzW7vcp8SQQivna3+LfkWH4JDqfiwZutU6MMEvU6g1OqK4Hll6uHbLpsfxkS/mGjyu1C9a9wIDAQABAoGBAJxsC3a25xZJqaRFfxwmIiptSTFy+/nj4T4gPQo6k/fHMKP/+P7liT9bm+uUwbITNNIjmPzxvrcKt+pNRR/92fizxr8QXr8l0ciVOLerbvdqvVUaQ/K1IVsblOLbactMvXcHactmqqLFUaZU9PPSDla7YkzikLDIUtHXQBEt4HEhAkEA/c4n+kpwi4odCaF49ESPbZC/Qejh7U9Tq10vAHzfrrGgQjnLw2UGDxJQXc9P12fGTvD2q3Q3VaMI8TKKFqZXsQJBANufh1zfP+xX/UfxJ4QzDUCHCu2gnyTDj3nG9Bc80E5g7NwR2VBXF1R+QQCK9GZcXd2y6vBYgrHOSUiLbVjGrycCQQDpOcs0zbjUEUuTsQUT+fiO50dJSrZpus6ZFxz85sMppeItWSzsVeYWbW7adYnZ2Gu72OPjM/0xPYsXEakhHSRRAkAxlVauNQjthv/72god4pi/VL224GiNmEkwKSa6iFRPHbrcBHuXk9IElWx/ft+mrHvUraw1DwaStgv9gNzzCghJAkEA08RegCRnIzuGvgeejLk4suIeCMD/11AvmSvxbRWS5rq1leSVo7uGLSnqDbwlzE4dGb5kH15NNAp14/l2Fu/yZg==
250 OK"""
WITH_CLIENT_AUTH = """250-ServiceID=oekn5sqrvcu4wote
250-ClientAuth=bob:lhwLVFt0Kd5/0Gy9DkKoyA
250-ClientAuth=alice:T9UADxtrvqx2HnLKWp/fWQ
250 OK
"""
WITHOUT_PRIVATE_KEY = """250-ServiceID=gfzprpioee3hoppz
250 OK"""
WRONG_FIRST_KEY = """250-MyKey=gfzprpioee3hoppz
250-ServiceID=gfzprpioee3hoppz
250 OK"""
MISSING_KEY_TYPE = """250-ServiceID=gfzprpioee3hoppz
250-PrivateKey=MIICXgIBAAKBgQDZvYVxvKPTWhId/8Ss9fVxj
250 OK"""
class TestAddOnionResponse(unittest.TestCase):
def test_convert(self):
"""
Exercises functionality of the convert method both when it works and
there's an error.
"""
# working case
response = ControlMessage.from_str(WITH_PRIVATE_KEY, 'ADD_ONION', normalize = True)
# now this should be a AddOnionResponse (ControlMessage subclass)
self.assertTrue(isinstance(response, stem.response.ControlMessage))
self.assertTrue(isinstance(response, stem.response.add_onion.AddOnionResponse))
# exercise some of the ControlMessage functionality
raw_content = (WITH_PRIVATE_KEY + '\n').replace('\n', '\r\n')
self.assertEqual(raw_content, response.raw_content())
self.assertTrue(str(response).startswith('ServiceID='))
def test_with_private_key(self):
"""
Checks a response when there's a private key.
"""
response = ControlMessage.from_str(WITH_PRIVATE_KEY, 'ADD_ONION', normalize = True)
self.assertEqual('gfzprpioee3hoppz', response.service_id)
self.assertTrue(response.private_key.startswith('MIICXgIBAAKB'))
self.assertEqual('RSA1024', response.private_key_type)
self.assertEqual({}, response.client_auth)
def test_with_client_auth(self):
"""
Checks a response when there's client credentials.
"""
response = ControlMessage.from_str(WITH_CLIENT_AUTH, 'ADD_ONION', normalize = True)
self.assertEqual('oekn5sqrvcu4wote', response.service_id)
self.assertEqual(None, response.private_key)
self.assertEqual(None, response.private_key_type)
self.assertEqual({'bob': 'lhwLVFt0Kd5/0Gy9DkKoyA', 'alice': 'T9UADxtrvqx2HnLKWp/fWQ'}, response.client_auth)
def test_without_private_key(self):
"""
Checks a response without a private key.
"""
response = ControlMessage.from_str(WITHOUT_PRIVATE_KEY, 'ADD_ONION', normalize = True)
self.assertEqual('gfzprpioee3hoppz', response.service_id)
self.assertEqual(None, response.private_key)
self.assertEqual(None, response.private_key_type)
def test_without_service_id(self):
"""
Checks a response that lack an initial service id.
"""
response = ControlMessage.from_str(WRONG_FIRST_KEY, normalize = True)
self.assertRaisesRegexp(stem.ProtocolError, 'ADD_ONION response should start with', stem.response.convert, 'ADD_ONION', response)
def test_no_key_type(self):
"""
Checks a response that's missing the private key type.
"""
response = ControlMessage.from_str(MISSING_KEY_TYPE, normalize = True)
self.assertRaisesRegexp(stem.ProtocolError, 'ADD_ONION PrivateKey lines should be of the form', stem.response.convert, 'ADD_ONION', response)
stem-1.6.0/test/unit/response/authchallenge.py 0000664 0001750 0001750 00000004165 13124757510 022175 0 ustar atagar atagar 0000000 0000000 """
Unit tests for the stem.response.authchallenge.AuthChallengeResponse class.
"""
import unittest
import stem.response
import stem.response.authchallenge
import stem.socket
from stem.response import ControlMessage
VALID_RESPONSE = '250 AUTHCHALLENGE \
SERVERHASH=B16F72DACD4B5ED1531F3FCC04B593D46A1E30267E636EA7C7F8DD7A2B7BAA05 \
SERVERNONCE=653574272ABBB49395BD1060D642D653CFB7A2FCE6A4955BCFED819703A9998C'
VALID_HASH = b'\xb1or\xda\xcdK^\xd1S\x1f?\xcc\x04\xb5\x93\xd4j\x1e0&~cn\xa7\xc7\xf8\xddz+{\xaa\x05'
VALID_NONCE = b"e5t'*\xbb\xb4\x93\x95\xbd\x10`\xd6B\xd6S\xcf\xb7\xa2\xfc\xe6\xa4\x95[\xcf\xed\x81\x97\x03\xa9\x99\x8c"
INVALID_RESPONSE = '250 AUTHCHALLENGE \
SERVERHASH=FOOBARB16F72DACD4B5ED1531F3FCC04B593D46A1E30267E636EA7C7F8DD7A2B7BAA05 \
SERVERNONCE=FOOBAR653574272ABBB49395BD1060D642D653CFB7A2FCE6A4955BCFED819703A9998C'
class TestAuthChallengeResponse(unittest.TestCase):
def test_valid_response(self):
"""
Parses valid AUTHCHALLENGE responses.
"""
control_message = ControlMessage.from_str(VALID_RESPONSE, 'AUTHCHALLENGE', normalize = True)
# now this should be a AuthChallengeResponse (ControlMessage subclass)
self.assertTrue(isinstance(control_message, stem.response.ControlMessage))
self.assertTrue(isinstance(control_message, stem.response.authchallenge.AuthChallengeResponse))
self.assertEqual(VALID_HASH, control_message.server_hash)
self.assertEqual(VALID_NONCE, control_message.server_nonce)
def test_invalid_responses(self):
"""
Tries to parse various malformed responses and checks it they raise
appropriate exceptions.
"""
auth_challenge_comp = VALID_RESPONSE.split()
for index in range(1, len(auth_challenge_comp)):
# Attempts to parse a message without this item. The first item is
# skipped because, without the 250 code, the message won't be
# constructed.
remaining_comp = auth_challenge_comp[:index] + auth_challenge_comp[index + 1:]
control_message = ControlMessage.from_str(' '.join(remaining_comp), normalize = True)
self.assertRaises(stem.ProtocolError, stem.response.convert, 'AUTHCHALLENGE', control_message)
stem-1.6.0/test/unit/response/singleline.py 0000664 0001750 0001750 00000001503 13124757510 021513 0 ustar atagar atagar 0000000 0000000 """
Unit tests for the stem.response.SingleLineResponse class.
"""
import unittest
import stem
from stem.response import ControlMessage
class TestSingleLineResponse(unittest.TestCase):
def test_single_line_response(self):
message = ControlMessage.from_str('552 NOTOK\r\n', 'SINGLELINE')
self.assertEqual(False, message.is_ok())
message = ControlMessage.from_str('250 KK\r\n', 'SINGLELINE')
self.assertEqual(True, message.is_ok())
message = ControlMessage.from_str('250 OK\r\n', 'SINGLELINE')
self.assertEqual(True, message.is_ok(True))
message = ControlMessage.from_str('250 HMM\r\n', 'SINGLELINE')
self.assertEqual(False, message.is_ok(True))
def test_multi_line_response(self):
self.assertRaises(stem.ProtocolError, ControlMessage.from_str, '250-MULTI\r\n250 LINE\r\n', 'SINGLELINE')
stem-1.6.0/test/unit/response/__init__.py 0000664 0001750 0001750 00000000267 13115423200 021111 0 ustar atagar atagar 0000000 0000000 """
Unit tests for stem.response.
"""
__all__ = [
'control_message',
'control_line',
'events',
'getinfo',
'getconf',
'protocolinfo',
'authchallenge',
'singleline',
]
stem-1.6.0/test/unit/response/protocolinfo.py 0000664 0001750 0001750 00000013016 13126502377 022102 0 ustar atagar atagar 0000000 0000000 """
Unit tests for the stem.response.protocolinfo.ProtocolInfoResponse class.
"""
import unittest
import stem.response
import stem.response.protocolinfo
import stem.socket
import stem.util.proc
import stem.util.system
import stem.version
from stem.response import ControlMessage
from stem.response.protocolinfo import AuthMethod
try:
# added in python 3.3
from unittest.mock import Mock, patch
except ImportError:
from mock import Mock, patch
NO_AUTH = """250-PROTOCOLINFO 1
250-AUTH METHODS=NULL
250-VERSION Tor="0.2.1.30"
250 OK"""
PASSWORD_AUTH = """250-PROTOCOLINFO 1
250-AUTH METHODS=HASHEDPASSWORD
250-VERSION Tor="0.2.1.30"
250 OK"""
COOKIE_AUTH = r"""250-PROTOCOLINFO 1
250-AUTH METHODS=COOKIE COOKIEFILE="/tmp/my data\\\"dir//control_auth_cookie"
250-VERSION Tor="0.2.1.30"
250 OK"""
MULTIPLE_AUTH = """250-PROTOCOLINFO 1
250-AUTH METHODS=COOKIE,HASHEDPASSWORD COOKIEFILE="/home/atagar/.tor/control_auth_cookie"
250-VERSION Tor="0.2.1.30"
250 OK"""
UNKNOWN_AUTH = """250-PROTOCOLINFO 1
250-AUTH METHODS=MAGIC,HASHEDPASSWORD,PIXIE_DUST
250-VERSION Tor="0.2.1.30"
250 OK"""
MINIMUM_RESPONSE = """250-PROTOCOLINFO 5
250 OK"""
UNICODE_COOKIE_PATH = r"""250-PROTOCOLINFO 1
250-AUTH METHODS=COOKIE COOKIEFILE="/home/user/\346\226\207\346\241\243/tor-browser_en-US/Browser/TorBrowser/Data/Tor/control_auth_cookie"
250-VERSION Tor="0.2.1.30"
250 OK"""
RELATIVE_COOKIE_PATH = r"""250-PROTOCOLINFO 1
250-AUTH METHODS=COOKIE COOKIEFILE="./tor-browser_en-US/Data/control_auth_cookie"
250-VERSION Tor="0.2.1.30"
250 OK"""
EXPECTED_UNICODE_PATH = b"/home/user/\346\226\207\346\241\243/tor-browser_en-US/Browser/TorBrowser/Data/Tor/control_auth_cookie".decode('utf-8')
class TestProtocolInfoResponse(unittest.TestCase):
def test_convert(self):
"""
Exercises functionality of the convert method both when it works and
there's an error.
"""
# working case
control_message = ControlMessage.from_str(NO_AUTH, 'PROTOCOLINFO', normalize = True)
# now this should be a ProtocolInfoResponse (ControlMessage subclass)
self.assertTrue(isinstance(control_message, stem.response.ControlMessage))
self.assertTrue(isinstance(control_message, stem.response.protocolinfo.ProtocolInfoResponse))
# exercise some of the ControlMessage functionality
raw_content = (NO_AUTH + '\n').replace('\n', '\r\n')
self.assertEqual(raw_content, control_message.raw_content())
self.assertTrue(str(control_message).startswith('PROTOCOLINFO 1'))
# attempt to convert the wrong type
self.assertRaises(TypeError, stem.response.convert, 'PROTOCOLINFO', 'hello world')
# attempt to convert a different message type
self.assertRaises(stem.ProtocolError, ControlMessage.from_str, '650 BW 32326 2856\r\n', 'PROTOCOLINFO')
def test_no_auth(self):
"""
Checks a response when there's no authentication.
"""
control_message = ControlMessage.from_str(NO_AUTH, 'PROTOCOLINFO', normalize = True)
self.assertEqual(1, control_message.protocol_version)
self.assertEqual(stem.version.Version('0.2.1.30'), control_message.tor_version)
self.assertEqual((AuthMethod.NONE, ), control_message.auth_methods)
self.assertEqual((), control_message.unknown_auth_methods)
self.assertEqual(None, control_message.cookie_path)
def test_password_auth(self):
"""
Checks a response with password authentication.
"""
control_message = ControlMessage.from_str(PASSWORD_AUTH, 'PROTOCOLINFO', normalize = True)
self.assertEqual((AuthMethod.PASSWORD, ), control_message.auth_methods)
def test_cookie_auth(self):
"""
Checks a response with cookie authentication and a path including escape
characters.
"""
control_message = ControlMessage.from_str(COOKIE_AUTH, 'PROTOCOLINFO', normalize = True)
self.assertEqual((AuthMethod.COOKIE, ), control_message.auth_methods)
self.assertEqual('/tmp/my data\\"dir//control_auth_cookie', control_message.cookie_path)
def test_multiple_auth(self):
"""
Checks a response with multiple authentication methods.
"""
control_message = ControlMessage.from_str(MULTIPLE_AUTH, 'PROTOCOLINFO', normalize = True)
self.assertEqual((AuthMethod.COOKIE, AuthMethod.PASSWORD), control_message.auth_methods)
self.assertEqual('/home/atagar/.tor/control_auth_cookie', control_message.cookie_path)
def test_unknown_auth(self):
"""
Checks a response with an unrecognized authtentication method.
"""
control_message = ControlMessage.from_str(UNKNOWN_AUTH, 'PROTOCOLINFO', normalize = True)
self.assertEqual((AuthMethod.UNKNOWN, AuthMethod.PASSWORD), control_message.auth_methods)
self.assertEqual(('MAGIC', 'PIXIE_DUST'), control_message.unknown_auth_methods)
def test_minimum_response(self):
"""
Checks a PROTOCOLINFO response that only contains the minimum amount of
information to be a valid response.
"""
control_message = ControlMessage.from_str(MINIMUM_RESPONSE, 'PROTOCOLINFO', normalize = True)
self.assertEqual(5, control_message.protocol_version)
self.assertEqual(None, control_message.tor_version)
self.assertEqual((), control_message.auth_methods)
self.assertEqual((), control_message.unknown_auth_methods)
self.assertEqual(None, control_message.cookie_path)
@patch('sys.getfilesystemencoding', Mock(return_value = 'UTF-8'))
def test_unicode_cookie(self):
"""
Checks an authentication cookie with a unicode path.
"""
control_message = ControlMessage.from_str(UNICODE_COOKIE_PATH, 'PROTOCOLINFO', normalize = True)
self.assertEqual(EXPECTED_UNICODE_PATH, control_message.cookie_path)
stem-1.6.0/test/unit/response/getconf.py 0000664 0001750 0001750 00000006301 13124757510 021010 0 ustar atagar atagar 0000000 0000000 """
Unit tests for the stem.response.getconf.GetConfResponse class.
"""
import unittest
import stem.response
import stem.response.getconf
import stem.socket
from stem.response import ControlMessage
SINGLE_RESPONSE = """\
250 DataDirectory=/home/neena/.tor"""
BATCH_RESPONSE = """\
250-CookieAuthentication=0
250-ControlPort=9100
250-DataDirectory=/tmp/fake dir
250 DirPort"""
MULTIVALUE_RESPONSE = """\
250-ControlPort=9100
250-ExitPolicy=accept 34.3.4.5
250-ExitPolicy=accept 3.4.53.3
250-ExitPolicy=accept 3.4.53.3
250 ExitPolicy=reject 23.245.54.3"""
UNRECOGNIZED_KEY_RESPONSE = '''552-Unrecognized configuration key "brickroad"
552 Unrecognized configuration key "submarine"'''
INVALID_RESPONSE = """\
123-FOO
232 BAR"""
class TestGetConfResponse(unittest.TestCase):
def test_empty_response(self):
"""
Parses a GETCONF reply without options (just calling "GETCONF").
"""
control_message = ControlMessage.from_str('250 OK\r\n', 'GETCONF')
# now this should be a GetConfResponse (ControlMessage subclass)
self.assertTrue(isinstance(control_message, stem.response.ControlMessage))
self.assertTrue(isinstance(control_message, stem.response.getconf.GetConfResponse))
self.assertEqual({}, control_message.entries)
def test_single_response(self):
"""
Parses a GETCONF reply response for a single parameter.
"""
control_message = ControlMessage.from_str(SINGLE_RESPONSE, 'GETCONF', normalize = True)
self.assertEqual({'DataDirectory': ['/home/neena/.tor']}, control_message.entries)
def test_batch_response(self):
"""
Parses a GETCONF reply for muiltiple parameters.
"""
expected = {
'CookieAuthentication': ['0'],
'ControlPort': ['9100'],
'DataDirectory': ['/tmp/fake dir'],
'DirPort': [],
}
control_message = ControlMessage.from_str(BATCH_RESPONSE, 'GETCONF', normalize = True)
self.assertEqual(expected, control_message.entries)
def test_multivalue_response(self):
"""
Parses a GETCONF reply containing a single key with multiple parameters.
"""
expected = {
'ControlPort': ['9100'],
'ExitPolicy': ['accept 34.3.4.5', 'accept 3.4.53.3', 'accept 3.4.53.3', 'reject 23.245.54.3']
}
control_message = ControlMessage.from_str(MULTIVALUE_RESPONSE, 'GETCONF', normalize = True)
self.assertEqual(expected, control_message.entries)
def test_unrecognized_key_response(self):
"""
Parses a GETCONF reply that contains an error code with an unrecognized key.
"""
try:
control_message = ControlMessage.from_str(UNRECOGNIZED_KEY_RESPONSE, normalize = True)
stem.response.convert('GETCONF', control_message)
self.fail('expected a stem.InvalidArguments to be raised')
except stem.InvalidArguments as exc:
self.assertEqual(exc.arguments, ['brickroad', 'submarine'])
def test_invalid_content(self):
"""
Parses a malformed GETCONF reply that contains an invalid response code.
This is a proper controller message, but malformed according to the
GETCONF's spec.
"""
control_message = ControlMessage.from_str(INVALID_RESPONSE, normalize = True)
self.assertRaises(stem.ProtocolError, stem.response.convert, 'GETCONF', control_message)
stem-1.6.0/test/unit/response/events.py 0000664 0001750 0001750 00000201421 13165210535 020663 0 ustar atagar atagar 0000000 0000000 """
Unit tests for the stem.response.events classes.
"""
import datetime
import threading
import unittest
import stem.response
import stem.response.events
import stem.util.log
from stem import * # enums and exceptions
from stem.response import ControlMessage
from stem.descriptor.router_status_entry import RouterStatusEntryV3
try:
# added in python 3.3
from unittest.mock import Mock
except ImportError:
from mock import Mock
# ADDRMAP event
ADDRMAP = '650 ADDRMAP www.atagar.com 75.119.206.243 "2012-11-19 00:50:13" \
EXPIRES="2012-11-19 08:50:13"'
ADDRMAP_NO_EXPIRATION = '650 ADDRMAP www.atagar.com 75.119.206.243 NEVER'
ADDRMAP_ERROR_EVENT = '650 ADDRMAP www.atagar.com "2012-11-19 00:50:13" \
error=yes EXPIRES="2012-11-19 08:50:13"'
ADDRMAP_BAD_1 = '650 ADDRMAP www.atagar.com 75.119.206.243 2012-11-19 00:50:13" \
EXPIRES="2012-11-19 08:50:13"'
ADDRMAP_BAD_2 = '650 ADDRMAP www.atagar.com 75.119.206.243 "2012-11-19 00:50:13 \
EXPIRES="2012-11-19 08:50:13"'
ADDRMAP_CACHED = '650 ADDRMAP example.com 192.0.43.10 "2013-04-03 22:31:22" \
EXPIRES="2013-04-03 20:31:22" \
CACHED="YES"'
ADDRMAP_NOT_CACHED = '650 ADDRMAP example.com 192.0.43.10 "2013-04-03 22:29:11" \
EXPIRES="2013-04-03 20:29:11" \
CACHED="NO"'
ADDRMAP_CACHED_MALFORMED = '650 ADDRMAP example.com 192.0.43.10 "2013-04-03 22:29:11" \
CACHED="KINDA"'
AUTHDIR_NEWDESC = """\
650+AUTHDIR_NEWDESCS
DROPPED
Not replacing router descriptor; no information has changed since the last one with this identity.
@uploaded-at 2017-05-25 04:46:21
@source "127.0.0.1"
router test002r 127.0.0.1 5002 0 7002
identity-ed25519
-----BEGIN ED25519 CERT-----
AQQABlm9AXVOPVG4KHqFmShWRFPU2oXO15yaS+J8c6SrLBMpnB1vAQAgBABBic8D
+GIdBzNCezf1Lfw8NSpbDL7S4ExBuMXvi6WvEoN1gIGwEwddLvUF91l6BXL5yoXf
xg7fDhYZ7CDwtVBHSfvmsIKR/QnQyylbDpVllsV9Wz6JLz52JgFGQaNjAgA=
-----END ED25519 CERT-----
master-key-ed25519 QYnPA/hiHQczQns39S38PDUqWwy+0uBMQbjF74ulrxI
platform Tor 0.3.0.7 on Darwin
proto Cons=1-2 Desc=1-2 DirCache=1 HSDir=1-2 HSIntro=3-4 HSRend=1-2 Link=1-4 LinkAuth=1,3 Microdesc=1-2 Relay=1-2
published 2017-05-25 04:46:20
fingerprint 3482 25F8 3C85 4796 B2DD 6364 E65C B189 B33B D696
uptime 9
bandwidth 1073741824 1073741824 0
extra-info-digest 114E4F433D6E08D9E73621BB418EBF02336EB578 i6+wKCBaNqUbNZIM9DFacEM74R5m0lkh8//h6R/nbGc
onion-key
-----BEGIN RSA PUBLIC KEY-----
MIGJAoGBAMMpf3fLSUEme0aQfN2RUfAPhZJMXVSqMpFRdBoKA4AYlz78VA9zxfj3
Nyir2G2HFaTzeS82p74obc8RufJQcGoDUwDnPlHtjb2ezmr018j8i3fTEvPwj5xC
5001FRwUVcOaLnxZKSDzpTyKRWGnSQBSbGcyXwMRtySKf0P5yjHDAgMBAAE=
-----END RSA PUBLIC KEY-----
signing-key
-----BEGIN RSA PUBLIC KEY-----
MIGJAoGBAM7Rn1kQffaJE8rbtgTiMxNY67i27hCBzzr0gE558jARizOJo8lf7get
rxz92mzYPYskM1V/j16QhoRlrruMn319/l6o97+/ta6qIwlSPXZ1jd/BGs3yqS4X
2N+N9qW8zC6km88K/YZuIsqYyXL7oHoIGqbERYLmp/JqLlAR52JJAgMBAAE=
-----END RSA PUBLIC KEY-----
onion-key-crosscert
-----BEGIN CROSSCERT-----
t4BE0PcPra9o5HBJHr9+h1MgP76XY3UGLQX8FGfEPHfNBMtVxRKkhOZ7Ki01+dkK
IpfkdQn3bOXTIa+FYGvzpyADYx4RDpbHG9/Tna/xR+6LhAQfvcLrlBxsjyntXjkX
FwE+AemijIU4DM4F1FHIkFz6OgT9B1/G0mr5QggzXS8=
-----END CROSSCERT-----
ntor-onion-key-crosscert 0
-----BEGIN ED25519 CERT-----
AQoABleVAUGJzwP4Yh0HM0J7N/Ut/Dw1KlsMvtLgTEG4xe+Lpa8SAKgaOVGouOKa
N64AOq7FdJJM/qgI1r2+jqTj1Mk/a19kfTIQ8hhWxoaJhg1xo8BasnjNQ+4Cm7ds
vMW0fhwJjQ4=
-----END ED25519 CERT-----
hidden-service-dir
ntor-onion-key tic6dEvMWt3kaUtDhwULgb3qBnc2wd5GkJ5cv0TelhA=
accept *:*
ipv6-policy accept 1-65535
tunnelled-dir-server
router-sig-ed25519 t7XJfoMOKbk1167f4p5+z5nlXxr+8us3qaLdNeQ1nGpUyQtM4G8Ie9P/oeqwhV4lCx5pQN1vIy3lUaN811WqAA
router-signature
-----BEGIN SIGNATURE-----
j/mMC1JuChvJH/ZP/Ayy0ZAV2P6VoxpRhHJfZMC07rr2ctmxfDTwLQhbYrqJ2adW
FYy5QTzxYzSFoTA7FvsadJuyvsGlaRfgFs+AxYjBUUoK7Dcd2ri+Y11NmwCBLFqF
4cYG3pqPHb38gXLj89QXfMJUDbOwrxvkVxIFbdwDCsE=
-----END SIGNATURE-----
.
650 OK
"""
# BUILDTIMEOUT_SET event from tor 0.2.3.16.
BUILD_TIMEOUT_EVENT = '650 BUILDTIMEOUT_SET COMPUTED \
TOTAL_TIMES=124 \
TIMEOUT_MS=9019 \
XM=1375 \
ALPHA=0.855662 \
CUTOFF_QUANTILE=0.800000 \
TIMEOUT_RATE=0.137097 \
CLOSE_MS=21850 \
CLOSE_RATE=0.072581'
BUILD_TIMEOUT_EVENT_BAD_1 = '650 BUILDTIMEOUT_SET COMPUTED \
TOTAL_TIMES=one_twenty_four \
TIMEOUT_MS=9019 \
XM=1375 \
ALPHA=0.855662 \
CUTOFF_QUANTILE=0.800000 \
TIMEOUT_RATE=0.137097 \
CLOSE_MS=21850 \
CLOSE_RATE=0.072581'
BUILD_TIMEOUT_EVENT_BAD_2 = '650 BUILDTIMEOUT_SET COMPUTED \
TOTAL_TIMES=124 \
TIMEOUT_MS=9019 \
XM=1375 \
ALPHA=0.855662 \
CUTOFF_QUANTILE=zero_point_eight \
TIMEOUT_RATE=0.137097 \
CLOSE_MS=21850 \
CLOSE_RATE=0.072581'
# CIRC events from tor v0.2.3.16
CIRC_LAUNCHED = '650 CIRC 7 LAUNCHED \
BUILD_FLAGS=NEED_CAPACITY \
PURPOSE=GENERAL \
TIME_CREATED=2012-11-08T16:48:38.417238'
CIRC_LAUNCHED_BAD_1 = '650 CIRC 7 LAUNCHED \
BUILD_FLAGS=NEED_CAPACITY \
PURPOSE=GENERAL \
TIME_CREATED=20121108T164838417238'
CIRC_LAUNCHED_BAD_2 = '650 CIRC toolong8901234567 LAUNCHED \
BUILD_FLAGS=NEED_CAPACITY \
PURPOSE=GENERAL \
TIME_CREATED=2012-11-08T16:48:38.417238'
CIRC_EXTENDED = '650 CIRC 7 EXTENDED \
$999A226EBED397F331B612FE1E4CFAE5C1F201BA=piyaz \
BUILD_FLAGS=NEED_CAPACITY \
PURPOSE=GENERAL \
TIME_CREATED=2012-11-08T16:48:38.417238'
CIRC_FAILED = '650 CIRC 5 FAILED \
$E57A476CD4DFBD99B4EE52A100A58610AD6E80B9=ergebnisoffen \
BUILD_FLAGS=NEED_CAPACITY \
PURPOSE=GENERAL \
TIME_CREATED=2012-11-08T16:48:36.400959 \
REASON=DESTROYED \
REMOTE_REASON=OR_CONN_CLOSED'
CIRC_WITH_CREDENTIALS = '650 CIRC 7 LAUNCHED \
SOCKS_USERNAME="It\'s a me, Mario!" \
SOCKS_PASSWORD="your princess is in another castle"'
# CIRC events from tor v0.2.1.30 without the VERBOSE_NAMES feature
CIRC_LAUNCHED_OLD = '650 CIRC 4 LAUNCHED'
CIRC_EXTENDED_OLD = '650 CIRC 1 EXTENDED \
$E57A476CD4DFBD99B4EE52A100A58610AD6E80B9,hamburgerphone'
CIRC_BUILT_OLD = '650 CIRC 1 BUILT \
$E57A476CD4DFBD99B4EE52A100A58610AD6E80B9,hamburgerphone,PrivacyRepublic14'
# CIRC_MINOR event from tor 0.2.3.16.
CIRC_MINOR_EVENT = '650 CIRC_MINOR 7 PURPOSE_CHANGED \
$67B2BDA4264D8A189D9270E28B1D30A262838243~europa1 \
BUILD_FLAGS=IS_INTERNAL,NEED_CAPACITY \
PURPOSE=MEASURE_TIMEOUT \
TIME_CREATED=2012-12-03T16:45:33.409602 \
OLD_PURPOSE=TESTING'
CIRC_MINOR_EVENT_BAD_1 = '650 CIRC_MINOR 7 PURPOSE_CHANGED \
$67B2BDA4264D8A189D9270E28B1D30A262838243~europa1 \
BUILD_FLAGS=IS_INTERNAL,NEED_CAPACITY \
PURPOSE=MEASURE_TIMEOUT \
TIME_CREATED=20121203T164533409602 \
OLD_PURPOSE=TESTING'
CIRC_MINOR_EVENT_BAD_2 = '650 CIRC_MINOR toolong8901234567 PURPOSE_CHANGED \
$67B2BDA4264D8A189D9270E28B1D30A262838243~europa1 \
BUILD_FLAGS=IS_INTERNAL,NEED_CAPACITY \
PURPOSE=MEASURE_TIMEOUT \
TIME_CREATED=2012-12-03T16:45:33.409602 \
OLD_PURPOSE=TESTING'
# CLIENTS_SEEN example from the spec
CLIENTS_SEEN_EVENT = '650 CLIENTS_SEEN \
TimeStarted="2008-12-25 23:50:43" \
CountrySummary=us=16,de=8,uk=8 \
IPVersions=v4=16,v6=40'
CLIENTS_SEEN_EVENT_BAD_1 = '650 CLIENTS_SEEN \
TimeStarted="2008-12-25 23:50:43" \
CountrySummary=us:16,de:8,uk:8 \
IPVersions=v4=16,v6=40'
CLIENTS_SEEN_EVENT_BAD_2 = '650 CLIENTS_SEEN \
TimeStarted="2008-12-25 23:50:43" \
CountrySummary=usa=16,unitedkingdom=8 \
IPVersions=v4=16,v6=40'
CLIENTS_SEEN_EVENT_BAD_3 = '650 CLIENTS_SEEN \
TimeStarted="2008-12-25 23:50:43" \
CountrySummary=us=16,de=8,uk=eight \
IPVersions=v4=16,v6=40'
CLIENTS_SEEN_EVENT_BAD_4 = '650 CLIENTS_SEEN \
TimeStarted="2008-12-25 23:50:43" \
CountrySummary=au=16,au=8,au=8 \
IPVersions=v4=16,v6=40'
CLIENTS_SEEN_EVENT_BAD_5 = '650 CLIENTS_SEEN \
TimeStarted="2008-12-25 23:50:43" \
CountrySummary=us=16,de=8,uk=8 \
IPVersions=v4:16,v6:40'
CLIENTS_SEEN_EVENT_BAD_6 = '650 CLIENTS_SEEN \
TimeStarted="2008-12-25 23:50:43" \
CountrySummary=us=16,de=8,uk=8 \
IPVersions=v4=sixteen,v6=40'
# CONF_CHANGED event from tor 0.2.3.16.
CONF_CHANGED_EVENT = """650-CONF_CHANGED
650-ExitNodes=caerSidi
650-ExitPolicy
650-MaxCircuitDirtiness=20
650 OK
"""
# GUARD events from tor v0.2.1.30.
GUARD_NEW = '650 GUARD ENTRY $36B5DBA788246E8369DBAF58577C6BC044A9A374 NEW'
GUARD_GOOD = '650 GUARD ENTRY $5D0034A368E0ABAF663D21847E1C9B6CFA09752A GOOD'
GUARD_BAD = '650 GUARD ENTRY $5D0034A368E0ABAF663D21847E1C9B6CFA09752A=caerSidi BAD'
HS_DESC_EVENT = '650 HS_DESC REQUESTED ajhb7kljbiru65qo NO_AUTH \
$67B2BDA4264D8A189D9270E28B1D30A262838243=europa1 b3oeducbhjmbqmgw2i3jtz4fekkrinwj'
HS_DESC_NO_DESC_ID = '650 HS_DESC REQUESTED ajhb7kljbiru65qo NO_AUTH \
$67B2BDA4264D8A189D9270E28B1D30A262838243'
HS_DESC_NOT_FOUND = '650 HS_DESC REQUESTED ajhb7kljbiru65qo NO_AUTH UNKNOWN'
HS_DESC_FAILED = '650 HS_DESC FAILED ajhb7kljbiru65qo NO_AUTH \
$67B2BDA4264D8A189D9270E28B1D30A262838243 \
b3oeducbhjmbqmgw2i3jtz4fekkrinwj REASON=NOT_FOUND'
# HS_DESC_CONTENT from 0.2.7.1
HS_DESC_CONTENT_EVENT = """\
650+HS_DESC_CONTENT facebookcorewwwi riwvyw6njgvs4koel4heqs7w4bssnmlw $8A30C9E8F5954EE286D29BD65CADEA6991200804~YorkshireTOR
rendezvous-service-descriptor riwvyw6njgvs4koel4heqs7w4bssnmlw
version 2
permanent-key
-----BEGIN RSA PUBLIC KEY-----
MIGJAoGBALfng/krEfrBcvblDiM3PAkowkiAKxLoTsXt3nPEzyTP6Cw+Gdr0ODje
hmxTngN1pKiH7szk4Q1p2RabOrUHWwXmGXeDDNs00fcyU6HupgqsCoKOqCsmPac6
/58apC64A7xHeS02wtfWJp6qiZ8i6GGu6xWXRWux+ShPgcHvkajRAgMahU8=
-----END RSA PUBLIC KEY-----
secret-id-part vnb2j6ftvkvghypd4yyypsl3qmpjyq3j
publication-time 2015-03-13 19:00:00
protocol-versions 2,3
introduction-points
-----BEGIN MESSAGE-----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-----END MESSAGE-----
signature
-----BEGIN SIGNATURE-----
s9Z0zWHsoPuqLw3GOwA6cv68vCFybnitIK4vD0MbNKF5qrOfKydZzGWfN09PuShy
H8Gr6aBYoz7HmlD7KyeGz9xdwRdouP+LW5YREOCORuwYnu5chWtB4iVJ0N1tIzSp
nHIs1lSrV7Ux2WQ3qSVj505fTGSCmaQRBX726ZlTPW0=
-----END SIGNATURE-----
.
650 OK
"""
HS_DESC_CONTENT_EMPTY_EVENT = """\
650+HS_DESC_CONTENT 3g2upl4pq6kufc4n 255tjwttk3wi7r2df57nuprs72j2daa3 $D7A0C3262724F2BC9646F6836E967A2777A3AF83~tsunaminitor
.
650 OK
"""
# NEWCONSENSUS event from v0.2.1.30.
NEWCONSENSUS_EVENT = """650+NEWCONSENSUS
r Beaver /96bKo4soysolMgKn5Hex2nyFSY pAJH9dSBp/CG6sPhhVY/5bLaVPM 2012-12-02 22:02:45 77.223.43.54 9001 0
s Fast Named Running Stable Valid
r Unnamed /+fJRWjmIGNAL2C5rRZHq3R91tA 7AnpZjfdBpYzXnMNm+w1bTsFF6Y 2012-12-02 17:51:10 91.121.184.87 9001 0
s Fast Guard Running Stable Valid
.
650 OK
"""
# NEWDESC events. I've never actually seen multiple descriptors in an event,
# but the spec allows for it.
NEWDESC_SINGLE = '650 NEWDESC $B3FA3110CC6F42443F039220C134CBD2FC4F0493=Sakura'
NEWDESC_MULTIPLE = '650 NEWDESC $BE938957B2CA5F804B3AFC2C1EE6673170CDBBF8=Moonshine \
$B4BE08B22D4D2923EDC3970FD1B93D0448C6D8FF~Unnamed'
# NS event from tor v0.2.1.30.
NS_EVENT = """650+NS
r whnetz dbBxYcJriTTrcxsuy4PUZcMRwCA VStM7KAIH/mXXoGDUpoGB1OXufg 2012-12-02 21:03:56 141.70.120.13 9001 9030
s Fast HSDir Named Stable V2Dir Valid
.
650 OK
"""
# ORCONN events from starting tor 0.2.2.39 via TBB
ORCONN_CLOSED = '650 ORCONN $A1130635A0CDA6F60C276FBF6994EFBD4ECADAB1~tama CLOSED REASON=DONE'
ORCONN_CONNECTED = '650 ORCONN 127.0.0.1:9000 CONNECTED NCIRCS=20 ID=18'
ORCONN_LAUNCHED = '650 ORCONN $7ED90E2833EE38A75795BA9237B0A4560E51E1A0=GreenDragon LAUNCHED'
ORCONN_BAD_1 = '650 ORCONN $7ED90E2833EE38A75795BA9237B0A4560E5=GreenD LAUNCHED'
ORCONN_BAD_2 = '650 ORCONN 127.0.0.1:001 CONNECTED'
ORCONN_BAD_3 = '650 ORCONN 127.0.0.1:9000 CONNECTED NCIRCS=too_many'
ORCONN_BAD_4 = '650 ORCONN 127.0.0.1:9000 CONNECTED NCIRCS=20 ID=30635A0CDA6F60C276FBF6994EFBD4ECADA'
# STATUS_* events that I was able to easily trigger. Most came from starting
# TBB, then listening while it bootstrapped.
STATUS_GENERAL_CONSENSUS_ARRIVED = '650 STATUS_GENERAL NOTICE CONSENSUS_ARRIVED'
STATUS_CLIENT_ENOUGH_DIR_INFO = '650 STATUS_CLIENT NOTICE ENOUGH_DIR_INFO'
STATUS_CLIENT_CIRC_ESTABLISHED = '650 STATUS_CLIENT NOTICE CIRCUIT_ESTABLISHED'
STATUS_CLIENT_BOOTSTRAP_DESCRIPTORS = '650 STATUS_CLIENT NOTICE BOOTSTRAP \
PROGRESS=53 \
TAG=loading_descriptors \
SUMMARY="Loading relay descriptors"'
STATUS_CLIENT_BOOTSTRAP_STUCK = '650 STATUS_CLIENT WARN BOOTSTRAP \
PROGRESS=80 \
TAG=conn_or \
SUMMARY="Connecting to the Tor network" \
WARNING="Network is unreachable" \
REASON=NOROUTE \
COUNT=5 \
RECOMMENDATION=warn'
STATUS_CLIENT_BOOTSTRAP_CONNECTING = '650 STATUS_CLIENT NOTICE BOOTSTRAP \
PROGRESS=80 \
TAG=conn_or \
SUMMARY="Connecting to the Tor network"'
STATUS_CLIENT_BOOTSTRAP_FIRST_HANDSHAKE = '650 STATUS_CLIENT NOTICE BOOTSTRAP \
PROGRESS=85 \
TAG=handshake_or \
SUMMARY="Finishing handshake with first hop"'
STATUS_CLIENT_BOOTSTRAP_ESTABLISHED = '650 STATUS_CLIENT NOTICE BOOTSTRAP \
PROGRESS=90 \
TAG=circuit_create \
SUMMARY="Establishing a Tor circuit"'
STATUS_CLIENT_BOOTSTRAP_DONE = '650 STATUS_CLIENT NOTICE BOOTSTRAP \
PROGRESS=100 \
TAG=done \
SUMMARY="Done"'
STATUS_SERVER_CHECK_REACHABILITY = '650 STATUS_SERVER NOTICE CHECKING_REACHABILITY \
ORADDRESS=71.35.143.230:9050'
STATUS_SERVER_DNS_TIMEOUT = '650 STATUS_SERVER NOTICE NAMESERVER_STATUS \
NS=205.171.3.25 \
STATUS=DOWN \
ERR="request timed out."'
STATUS_SERVER_DNS_DOWN = '650 STATUS_SERVER WARN NAMESERVER_ALL_DOWN'
STATUS_SERVER_DNS_UP = '650 STATUS_SERVER NOTICE NAMESERVER_STATUS \
NS=205.171.3.25 \
STATUS=UP'
# unknown STATUS_* event type
STATUS_SPECIFIC_CONSENSUS_ARRIVED = '650 STATUS_SPECIFIC NOTICE CONSENSUS_ARRIVED'
# STREAM events from tor 0.2.3.16 for visiting the google front page
STREAM_NEW = '650 STREAM 18 NEW 0 \
encrypted.google.com:443 \
SOURCE_ADDR=127.0.0.1:47849 \
PURPOSE=USER'
STREAM_SENTCONNECT = '650 STREAM 18 SENTCONNECT 26 encrypted.google.com:443'
STREAM_REMAP = '650 STREAM 18 REMAP 26 74.125.227.129:443 SOURCE=EXIT'
STREAM_SUCCEEDED = '650 STREAM 18 SUCCEEDED 26 74.125.227.129:443'
STREAM_CLOSED_RESET = '650 STREAM 21 CLOSED 26 74.125.227.129:443 REASON=CONNRESET'
STREAM_CLOSED_DONE = '650 STREAM 25 CLOSED 26 199.7.52.72:80 REASON=DONE'
STREAM_DIR_FETCH = '650 STREAM 14 NEW 0 \
176.28.51.238.$649F2D0ACF418F7CFC6539AB2257EB2D5297BAFA.exit:443 \
SOURCE_ADDR=(Tor_internal):0 PURPOSE=DIR_FETCH'
STREAM_DNS_REQUEST = '650 STREAM 1113 NEW 0 www.google.com:0 \
SOURCE_ADDR=127.0.0.1:15297 \
PURPOSE=DNS_REQUEST'
STREAM_SENTCONNECT_BAD_1 = '650 STREAM 18 SENTCONNECT 26'
STREAM_SENTCONNECT_BAD_2 = '650 STREAM 18 SENTCONNECT 26 encrypted.google.com'
STREAM_SENTCONNECT_BAD_3 = '650 STREAM 18 SENTCONNECT 26 encrypted.google.com:https'
STREAM_DNS_REQUEST_BAD_1 = '650 STREAM 1113 NEW 0 www.google.com:0 \
SOURCE_ADDR=127.0.0.1 \
PURPOSE=DNS_REQUEST'
STREAM_DNS_REQUEST_BAD_2 = '650 STREAM 1113 NEW 0 www.google.com:0 \
SOURCE_ADDR=127.0.0.1:dns \
PURPOSE=DNS_REQUEST'
STREAM_NEWRESOLVE_IP6 = '650 STREAM 23 NEWRESOLVE 0 2001:db8::1:0 PURPOSE=DNS_REQUEST'
TRANSPORT_LAUNCHED = '650 TRANSPORT_LAUNCHED server obfs1 127.0.0.1 1111'
TRANSPORT_LAUNCHED_BAD_TYPE = '650 TRANSPORT_LAUNCHED unicorn obfs1 127.0.0.1 1111'
TRANSPORT_LAUNCHED_BAD_ADDRESS = '650 TRANSPORT_LAUNCHED server obfs1 127.0.x.y 1111'
TRANSPORT_LAUNCHED_BAD_PORT = '650 TRANSPORT_LAUNCHED server obfs1 127.0.0.1 my_port'
CONN_BW = '650 CONN_BW ID=11 TYPE=DIR READ=272 WRITTEN=817'
CONN_BW_BAD_WRITTEN_VALUE = '650 CONN_BW ID=11 TYPE=DIR READ=272 WRITTEN=817.7'
CONN_BW_BAD_MISSING_ID = '650 CONN_BW TYPE=DIR READ=272 WRITTEN=817'
CIRC_BW = '650 CIRC_BW ID=11 READ=272 WRITTEN=817'
CIRC_BW_WITH_TIMESTAMP = '650 CIRC_BW ID=11 READ=272 WRITTEN=817 TIME=2012-12-06T13:51:11.433755'
CIRC_BW_BAD_WRITTEN_VALUE = '650 CIRC_BW ID=11 READ=272 WRITTEN=817.7'
CIRC_BW_BAD_MISSING_ID = '650 CIRC_BW READ=272 WRITTEN=817'
CIRC_BW_MALFORMED_TIMESTAMP = '650 CIRC_BW ID=11 READ=272 WRITTEN=817 TIME=boom'
CELL_STATS_1 = '650 CELL_STATS ID=14 \
OutboundQueue=19403 OutboundConn=15 \
OutboundAdded=create_fast:1,relay_early:2 \
OutboundRemoved=create_fast:1,relay_early:2 \
OutboundTime=create_fast:0,relay_early:0'
CELL_STATS_2 = '650 CELL_STATS \
InboundQueue=19403 InboundConn=32 \
InboundAdded=relay:1,created_fast:1 \
InboundRemoved=relay:1,created_fast:1 \
InboundTime=relay:0,created_fast:0 \
OutboundQueue=6710 OutboundConn=18 \
OutboundAdded=create:1,relay_early:1 \
OutboundRemoved=create:1,relay_early:1 \
OutboundTime=create:0,relay_early:0'
CELL_STATS_BAD_1 = '650 CELL_STATS OutboundAdded=create_fast:-1,relay_early:2'
CELL_STATS_BAD_2 = '650 CELL_STATS OutboundAdded=create_fast:arg,relay_early:-2'
CELL_STATS_BAD_3 = '650 CELL_STATS OutboundAdded=create_fast!:1,relay_early:-2'
TB_EMPTY_1 = '650 TB_EMPTY ORCONN ID=16 READ=0 WRITTEN=0 LAST=100'
TB_EMPTY_2 = '650 TB_EMPTY GLOBAL READ=93 WRITTEN=93 LAST=100'
TB_EMPTY_3 = '650 TB_EMPTY RELAY READ=93 WRITTEN=93 LAST=100'
TB_EMPTY_BAD_1 = '650 TB_EMPTY GLOBAL READ=93 WRITTEN=blarg LAST=100'
TB_EMPTY_BAD_2 = '650 TB_EMPTY GLOBAL READ=93 WRITTEN=93 LAST=-100'
def _get_event(content):
return ControlMessage.from_str(content, 'EVENT', normalize = True)
class TestEvents(unittest.TestCase):
def test_example(self):
"""
Exercises the add_event_listener() pydoc example, but without the sleep().
"""
import time
from stem.control import Controller, EventType
def print_bw(event):
msg = 'sent: %i, received: %i' % (event.written, event.read)
self.assertEqual('sent: 25, received: 15', msg)
def event_sender():
for index in range(3):
print_bw(_get_event('650 BW 15 25'))
time.sleep(0.0005)
controller = Mock(spec = Controller)
controller.authenticate()
controller.add_event_listener(print_bw, EventType.BW)
events_thread = threading.Thread(target = event_sender)
events_thread.start()
time.sleep(0.002)
events_thread.join()
def test_event(self):
# synthetic, contrived message construction to reach the blank event check
self.assertRaises(ProtocolError, stem.response.convert, 'EVENT', stem.response.ControlMessage([('', '', '')], ''))
# Event._parse_message() on an unknown event type
event = _get_event('650 NONE SOLID "NON SENSE" condition=MEH quoted="1 2 3"')
self.assertEqual('NONE', event.type)
self.assertEqual(['SOLID', '"NON', 'SENSE"'], event.positional_args)
self.assertEqual({'condition': 'MEH', 'quoted': '1 2 3'}, event.keyword_args)
def test_log_events(self):
event = _get_event('650 DEBUG connection_edge_process_relay_cell(): Got an extended cell! Yay.')
self.assertTrue(isinstance(event, stem.response.events.LogEvent))
self.assertEqual('DEBUG', event.runlevel)
self.assertEqual('connection_edge_process_relay_cell(): Got an extended cell! Yay.', event.message)
event = _get_event('650 INFO circuit_finish_handshake(): Finished building circuit hop:')
self.assertTrue(isinstance(event, stem.response.events.LogEvent))
self.assertEqual('INFO', event.runlevel)
self.assertEqual('circuit_finish_handshake(): Finished building circuit hop:', event.message)
event = _get_event('650+WARN\na multi-line\nwarning message\n.\n650 OK\n')
self.assertTrue(isinstance(event, stem.response.events.LogEvent))
self.assertEqual('WARN', event.runlevel)
self.assertEqual('a multi-line\nwarning message', event.message)
def test_addrmap_event(self):
event = _get_event(ADDRMAP)
self.assertTrue(isinstance(event, stem.response.events.AddrMapEvent))
self.assertEqual(ADDRMAP.lstrip('650 '), str(event))
self.assertEqual('www.atagar.com', event.hostname)
self.assertEqual('75.119.206.243', event.destination)
self.assertEqual(datetime.datetime(2012, 11, 19, 0, 50, 13), event.expiry)
self.assertEqual(None, event.error)
self.assertEqual(datetime.datetime(2012, 11, 19, 8, 50, 13), event.utc_expiry)
event = _get_event(ADDRMAP_NO_EXPIRATION)
self.assertTrue(isinstance(event, stem.response.events.AddrMapEvent))
self.assertEqual(ADDRMAP_NO_EXPIRATION.lstrip('650 '), str(event))
self.assertEqual('www.atagar.com', event.hostname)
self.assertEqual('75.119.206.243', event.destination)
self.assertEqual(None, event.expiry)
self.assertEqual(None, event.error)
self.assertEqual(None, event.utc_expiry)
event = _get_event(ADDRMAP_ERROR_EVENT)
self.assertTrue(isinstance(event, stem.response.events.AddrMapEvent))
self.assertEqual(ADDRMAP_ERROR_EVENT.lstrip('650 '), str(event))
self.assertEqual('www.atagar.com', event.hostname)
self.assertEqual(None, event.destination)
self.assertEqual(datetime.datetime(2012, 11, 19, 0, 50, 13), event.expiry)
self.assertEqual('yes', event.error)
self.assertEqual(datetime.datetime(2012, 11, 19, 8, 50, 13), event.utc_expiry)
self.assertEqual(None, event.cached)
# malformed content where quotes are missing
self.assertRaises(ProtocolError, _get_event, ADDRMAP_BAD_1)
self.assertRaises(ProtocolError, _get_event, ADDRMAP_BAD_2)
# check the CACHED flag
event = _get_event(ADDRMAP_CACHED)
self.assertTrue(isinstance(event, stem.response.events.AddrMapEvent))
self.assertEqual('example.com', event.hostname)
self.assertEqual(True, event.cached)
event = _get_event(ADDRMAP_NOT_CACHED)
self.assertTrue(isinstance(event, stem.response.events.AddrMapEvent))
self.assertEqual('example.com', event.hostname)
self.assertEqual(False, event.cached)
# the CACHED argument should only allow YES or NO
self.assertRaises(ProtocolError, _get_event, ADDRMAP_CACHED_MALFORMED)
def test_authdir_newdesc_event(self):
minimal_event = _get_event('650+AUTHDIR_NEWDESCS\nAction\nMessage\nDescriptor\n.\n650 OK\n')
self.assertTrue(isinstance(minimal_event, stem.response.events.AuthDirNewDescEvent))
self.assertEqual('Action', minimal_event.action)
self.assertEqual('Message', minimal_event.message)
self.assertEqual('Descriptor', minimal_event.descriptor)
event = _get_event(AUTHDIR_NEWDESC)
self.assertTrue(isinstance(event, stem.response.events.AuthDirNewDescEvent))
self.assertEqual('DROPPED', event.action)
self.assertEqual('Not replacing router descriptor; no information has changed since the last one with this identity.', event.message)
self.assertTrue('Descripto', event.descriptor.startswith('@uploaded-at 2017-05-25 04:46:21'))
def test_build_timeout_set_event(self):
event = _get_event(BUILD_TIMEOUT_EVENT)
self.assertTrue(isinstance(event, stem.response.events.BuildTimeoutSetEvent))
self.assertEqual(BUILD_TIMEOUT_EVENT.lstrip('650 '), str(event))
self.assertEqual(TimeoutSetType.COMPUTED, event.set_type)
self.assertEqual(124, event.total_times)
self.assertEqual(9019, event.timeout)
self.assertEqual(1375, event.xm)
self.assertEqual(0.855662, event.alpha)
self.assertEqual(0.8, event.quantile)
self.assertEqual(0.137097, event.timeout_rate)
self.assertEqual(21850, event.close_timeout)
self.assertEqual(0.072581, event.close_rate)
# malformed content where we get non-numeric values
self.assertRaises(ProtocolError, _get_event, BUILD_TIMEOUT_EVENT_BAD_1)
self.assertRaises(ProtocolError, _get_event, BUILD_TIMEOUT_EVENT_BAD_2)
def test_bw_event(self):
event = _get_event('650 BW 15 25')
self.assertTrue(isinstance(event, stem.response.events.BandwidthEvent))
self.assertEqual(15, event.read)
self.assertEqual(25, event.written)
event = _get_event('650 BW 0 0')
self.assertEqual(0, event.read)
self.assertEqual(0, event.written)
# BW events are documented as possibly having various keywords including
# DIR, OR, EXIT, and APP in the future. This is kinda a pointless note
# since tor doesn't actually do it yet (and likely never will), but might
# as well sanity test that it'll be ok.
event = _get_event('650 BW 10 20 OR=5 EXIT=500')
self.assertEqual(10, event.read)
self.assertEqual(20, event.written)
self.assertEqual({'OR': '5', 'EXIT': '500'}, event.keyword_args)
self.assertRaises(ProtocolError, _get_event, '650 BW')
self.assertRaises(ProtocolError, _get_event, '650 BW 15')
self.assertRaises(ProtocolError, _get_event, '650 BW -15 25')
self.assertRaises(ProtocolError, _get_event, '650 BW 15 -25')
self.assertRaises(ProtocolError, _get_event, '650 BW x 25')
def test_circ_event(self):
event = _get_event(CIRC_LAUNCHED)
self.assertTrue(isinstance(event, stem.response.events.CircuitEvent))
self.assertEqual(CIRC_LAUNCHED.lstrip('650 '), str(event))
self.assertEqual('7', event.id)
self.assertEqual(CircStatus.LAUNCHED, event.status)
self.assertEqual((), event.path)
self.assertEqual((CircBuildFlag.NEED_CAPACITY,), event.build_flags)
self.assertEqual(CircPurpose.GENERAL, event.purpose)
self.assertEqual(None, event.hs_state)
self.assertEqual(None, event.rend_query)
self.assertEqual(datetime.datetime(2012, 11, 8, 16, 48, 38, 417238), event.created)
self.assertEqual(None, event.reason)
self.assertEqual(None, event.remote_reason)
self.assertEqual(None, event.socks_username)
self.assertEqual(None, event.socks_password)
event = _get_event(CIRC_EXTENDED)
self.assertTrue(isinstance(event, stem.response.events.CircuitEvent))
self.assertEqual(CIRC_EXTENDED.lstrip('650 '), str(event))
self.assertEqual('7', event.id)
self.assertEqual(CircStatus.EXTENDED, event.status)
self.assertEqual((('999A226EBED397F331B612FE1E4CFAE5C1F201BA', 'piyaz'),), event.path)
self.assertEqual((CircBuildFlag.NEED_CAPACITY,), event.build_flags)
self.assertEqual(CircPurpose.GENERAL, event.purpose)
self.assertEqual(None, event.hs_state)
self.assertEqual(None, event.rend_query)
self.assertEqual(datetime.datetime(2012, 11, 8, 16, 48, 38, 417238), event.created)
self.assertEqual(None, event.reason)
self.assertEqual(None, event.remote_reason)
event = _get_event(CIRC_FAILED)
self.assertTrue(isinstance(event, stem.response.events.CircuitEvent))
self.assertEqual(CIRC_FAILED.lstrip('650 '), str(event))
self.assertEqual('5', event.id)
self.assertEqual(CircStatus.FAILED, event.status)
self.assertEqual((('E57A476CD4DFBD99B4EE52A100A58610AD6E80B9', 'ergebnisoffen'),), event.path)
self.assertEqual((CircBuildFlag.NEED_CAPACITY,), event.build_flags)
self.assertEqual(CircPurpose.GENERAL, event.purpose)
self.assertEqual(None, event.hs_state)
self.assertEqual(None, event.rend_query)
self.assertEqual(datetime.datetime(2012, 11, 8, 16, 48, 36, 400959), event.created)
self.assertEqual(CircClosureReason.DESTROYED, event.reason)
self.assertEqual(CircClosureReason.OR_CONN_CLOSED, event.remote_reason)
event = _get_event(CIRC_WITH_CREDENTIALS)
self.assertTrue(isinstance(event, stem.response.events.CircuitEvent))
self.assertEqual(CIRC_WITH_CREDENTIALS.lstrip('650 '), str(event))
self.assertEqual('7', event.id)
self.assertEqual(CircStatus.LAUNCHED, event.status)
self.assertEqual((), event.path)
self.assertEqual(None, event.build_flags)
self.assertEqual(None, event.purpose)
self.assertEqual(None, event.hs_state)
self.assertEqual(None, event.rend_query)
self.assertEqual(None, event.created)
self.assertEqual(None, event.reason)
self.assertEqual(None, event.remote_reason)
self.assertEqual("It's a me, Mario!", event.socks_username)
self.assertEqual('your princess is in another castle', event.socks_password)
event = _get_event(CIRC_LAUNCHED_OLD)
self.assertTrue(isinstance(event, stem.response.events.CircuitEvent))
self.assertEqual(CIRC_LAUNCHED_OLD.lstrip('650 '), str(event))
self.assertEqual('4', event.id)
self.assertEqual(CircStatus.LAUNCHED, event.status)
self.assertEqual((), event.path)
self.assertEqual(None, event.build_flags)
self.assertEqual(None, event.purpose)
self.assertEqual(None, event.hs_state)
self.assertEqual(None, event.rend_query)
self.assertEqual(None, event.created)
self.assertEqual(None, event.reason)
self.assertEqual(None, event.remote_reason)
event = _get_event(CIRC_EXTENDED_OLD)
self.assertTrue(isinstance(event, stem.response.events.CircuitEvent))
self.assertEqual(CIRC_EXTENDED_OLD.lstrip('650 '), str(event))
self.assertEqual('1', event.id)
self.assertEqual(CircStatus.EXTENDED, event.status)
self.assertEqual((('E57A476CD4DFBD99B4EE52A100A58610AD6E80B9', None), (None, 'hamburgerphone')), event.path)
self.assertEqual(None, event.build_flags)
self.assertEqual(None, event.purpose)
self.assertEqual(None, event.hs_state)
self.assertEqual(None, event.rend_query)
self.assertEqual(None, event.created)
self.assertEqual(None, event.reason)
self.assertEqual(None, event.remote_reason)
event = _get_event(CIRC_BUILT_OLD)
self.assertTrue(isinstance(event, stem.response.events.CircuitEvent))
self.assertEqual(CIRC_BUILT_OLD.lstrip('650 '), str(event))
self.assertEqual('1', event.id)
self.assertEqual(CircStatus.BUILT, event.status)
self.assertEqual((('E57A476CD4DFBD99B4EE52A100A58610AD6E80B9', None), (None, 'hamburgerphone'), (None, 'PrivacyRepublic14')), event.path)
self.assertEqual(None, event.build_flags)
self.assertEqual(None, event.purpose)
self.assertEqual(None, event.hs_state)
self.assertEqual(None, event.rend_query)
self.assertEqual(None, event.created)
self.assertEqual(None, event.reason)
self.assertEqual(None, event.remote_reason)
# malformed TIME_CREATED timestamp
self.assertRaises(ProtocolError, _get_event, CIRC_LAUNCHED_BAD_1)
# invalid circuit id
self.assertRaises(ProtocolError, _get_event, CIRC_LAUNCHED_BAD_2)
def test_circ_minor_event(self):
event = _get_event(CIRC_MINOR_EVENT)
self.assertTrue(isinstance(event, stem.response.events.CircMinorEvent))
self.assertEqual(CIRC_MINOR_EVENT.lstrip('650 '), str(event))
self.assertEqual('7', event.id)
self.assertEqual(CircEvent.PURPOSE_CHANGED, event.event)
self.assertEqual((('67B2BDA4264D8A189D9270E28B1D30A262838243', 'europa1'),), event.path)
self.assertEqual((CircBuildFlag.IS_INTERNAL, CircBuildFlag.NEED_CAPACITY), event.build_flags)
self.assertEqual(CircPurpose.MEASURE_TIMEOUT, event.purpose)
self.assertEqual(None, event.hs_state)
self.assertEqual(None, event.rend_query)
self.assertEqual(datetime.datetime(2012, 12, 3, 16, 45, 33, 409602), event.created)
self.assertEqual(CircPurpose.TESTING, event.old_purpose)
self.assertEqual(None, event.old_hs_state)
# malformed TIME_CREATED timestamp
self.assertRaises(ProtocolError, _get_event, CIRC_MINOR_EVENT_BAD_1)
# invalid circuit id
self.assertRaises(ProtocolError, _get_event, CIRC_MINOR_EVENT_BAD_2)
def test_clients_seen_event(self):
event = _get_event(CLIENTS_SEEN_EVENT)
self.assertTrue(isinstance(event, stem.response.events.ClientsSeenEvent))
self.assertEqual(CLIENTS_SEEN_EVENT.lstrip('650 '), str(event))
self.assertEqual(datetime.datetime(2008, 12, 25, 23, 50, 43), event.start_time)
self.assertEqual({'us': 16, 'de': 8, 'uk': 8}, event.locales)
self.assertEqual({'v4': 16, 'v6': 40}, event.ip_versions)
# CountrySummary's 'key=value' mappings are replaced with 'key:value'
self.assertRaises(ProtocolError, _get_event, CLIENTS_SEEN_EVENT_BAD_1)
# CountrySummary's country codes aren't two letters
self.assertRaises(ProtocolError, _get_event, CLIENTS_SEEN_EVENT_BAD_2)
# CountrySummary's mapping contains a non-numeric value
self.assertRaises(ProtocolError, _get_event, CLIENTS_SEEN_EVENT_BAD_3)
# CountrySummary has duplicate country codes (multiple 'au=' mappings)
self.assertRaises(ProtocolError, _get_event, CLIENTS_SEEN_EVENT_BAD_4)
# IPVersions's 'key=value' mappings are replaced with 'key:value'
self.assertRaises(ProtocolError, _get_event, CLIENTS_SEEN_EVENT_BAD_5)
# IPVersions's mapping contains a non-numeric value
self.assertRaises(ProtocolError, _get_event, CLIENTS_SEEN_EVENT_BAD_6)
def test_conf_changed(self):
event = _get_event(CONF_CHANGED_EVENT)
expected_config = {
'ExitNodes': 'caerSidi',
'MaxCircuitDirtiness': '20',
'ExitPolicy': None,
}
self.assertTrue(isinstance(event, stem.response.events.ConfChangedEvent))
self.assertEqual(expected_config, event.config)
def test_descchanged_event(self):
# all we can check for is that the event is properly parsed as a
# DescChangedEvent instance
event = _get_event('650 DESCCHANGED')
self.assertTrue(isinstance(event, stem.response.events.DescChangedEvent))
self.assertEqual('DESCCHANGED', str(event))
self.assertEqual([], event.positional_args)
self.assertEqual({}, event.keyword_args)
def test_guard_event(self):
event = _get_event(GUARD_NEW)
self.assertTrue(isinstance(event, stem.response.events.GuardEvent))
self.assertEqual(GUARD_NEW.lstrip('650 '), str(event))
self.assertEqual(GuardType.ENTRY, event.guard_type)
self.assertEqual('$36B5DBA788246E8369DBAF58577C6BC044A9A374', event.endpoint)
self.assertEqual('36B5DBA788246E8369DBAF58577C6BC044A9A374', event.endpoint_fingerprint)
self.assertEqual(None, event.endpoint_nickname)
self.assertEqual(GuardStatus.NEW, event.status)
event = _get_event(GUARD_GOOD)
self.assertEqual(GuardType.ENTRY, event.guard_type)
self.assertEqual('$5D0034A368E0ABAF663D21847E1C9B6CFA09752A', event.endpoint)
self.assertEqual('5D0034A368E0ABAF663D21847E1C9B6CFA09752A', event.endpoint_fingerprint)
self.assertEqual(None, event.endpoint_nickname)
self.assertEqual(GuardStatus.GOOD, event.status)
event = _get_event(GUARD_BAD)
self.assertEqual(GuardType.ENTRY, event.guard_type)
self.assertEqual('$5D0034A368E0ABAF663D21847E1C9B6CFA09752A=caerSidi', event.endpoint)
self.assertEqual('5D0034A368E0ABAF663D21847E1C9B6CFA09752A', event.endpoint_fingerprint)
self.assertEqual('caerSidi', event.endpoint_nickname)
self.assertEqual(GuardStatus.BAD, event.status)
def test_hs_desc_event(self):
event = _get_event(HS_DESC_EVENT)
self.assertTrue(isinstance(event, stem.response.events.HSDescEvent))
self.assertEqual(HS_DESC_EVENT.lstrip('650 '), str(event))
self.assertEqual(HSDescAction.REQUESTED, event.action)
self.assertEqual('ajhb7kljbiru65qo', event.address)
self.assertEqual(HSAuth.NO_AUTH, event.authentication)
self.assertEqual('$67B2BDA4264D8A189D9270E28B1D30A262838243=europa1', event.directory)
self.assertEqual('67B2BDA4264D8A189D9270E28B1D30A262838243', event.directory_fingerprint)
self.assertEqual('europa1', event.directory_nickname)
self.assertEqual('b3oeducbhjmbqmgw2i3jtz4fekkrinwj', event.descriptor_id)
self.assertEqual(None, event.reason)
event = _get_event(HS_DESC_NO_DESC_ID)
self.assertEqual('$67B2BDA4264D8A189D9270E28B1D30A262838243', event.directory)
self.assertEqual('67B2BDA4264D8A189D9270E28B1D30A262838243', event.directory_fingerprint)
self.assertEqual(None, event.directory_nickname)
self.assertEqual(None, event.descriptor_id)
self.assertEqual(None, event.reason)
event = _get_event(HS_DESC_NOT_FOUND)
self.assertEqual('UNKNOWN', event.directory)
self.assertEqual(None, event.directory_fingerprint)
self.assertEqual(None, event.directory_nickname)
self.assertEqual(None, event.descriptor_id)
self.assertEqual(None, event.reason)
event = _get_event(HS_DESC_FAILED)
self.assertTrue(isinstance(event, stem.response.events.HSDescEvent))
self.assertEqual(HS_DESC_FAILED.lstrip('650 '), str(event))
self.assertEqual(HSDescAction.FAILED, event.action)
self.assertEqual('ajhb7kljbiru65qo', event.address)
self.assertEqual(HSAuth.NO_AUTH, event.authentication)
self.assertEqual('$67B2BDA4264D8A189D9270E28B1D30A262838243', event.directory)
self.assertEqual('67B2BDA4264D8A189D9270E28B1D30A262838243', event.directory_fingerprint)
self.assertEqual(None, event.directory_nickname)
self.assertEqual('b3oeducbhjmbqmgw2i3jtz4fekkrinwj', event.descriptor_id)
self.assertEqual(HSDescReason.NOT_FOUND, event.reason)
def test_hs_desc_content_event(self):
event = _get_event(HS_DESC_CONTENT_EVENT)
self.assertTrue(isinstance(event, stem.response.events.HSDescContentEvent))
self.assertEqual('facebookcorewwwi', event.address)
self.assertEqual('riwvyw6njgvs4koel4heqs7w4bssnmlw', event.descriptor_id)
self.assertEqual('$8A30C9E8F5954EE286D29BD65CADEA6991200804~YorkshireTOR', event.directory)
self.assertEqual('8A30C9E8F5954EE286D29BD65CADEA6991200804', event.directory_fingerprint)
self.assertEqual('YorkshireTOR', event.directory_nickname)
desc = event.descriptor
self.assertEqual('riwvyw6njgvs4koel4heqs7w4bssnmlw', desc.descriptor_id)
self.assertEqual(2, desc.version)
self.assertTrue('MIGJAoGBALf' in desc.permanent_key)
self.assertEqual('vnb2j6ftvkvghypd4yyypsl3qmpjyq3j', desc.secret_id_part)
self.assertEqual(datetime.datetime(2015, 3, 13, 19, 0, 0), desc.published)
self.assertEqual([2, 3], desc.protocol_versions)
self.assertEqual(3, len(desc.introduction_points()))
self.assertTrue('s9Z0zWHsoPu' in desc.signature)
event = _get_event(HS_DESC_CONTENT_EMPTY_EVENT)
self.assertTrue(isinstance(event, stem.response.events.HSDescContentEvent))
self.assertEqual('3g2upl4pq6kufc4n', event.address)
self.assertEqual('255tjwttk3wi7r2df57nuprs72j2daa3', event.descriptor_id)
self.assertEqual('$D7A0C3262724F2BC9646F6836E967A2777A3AF83~tsunaminitor', event.directory)
self.assertEqual('D7A0C3262724F2BC9646F6836E967A2777A3AF83', event.directory_fingerprint)
self.assertEqual('tsunaminitor', event.directory_nickname)
self.assertEqual(None, event.descriptor)
def test_newdesc_event(self):
event = _get_event(NEWDESC_SINGLE)
expected_relays = (('B3FA3110CC6F42443F039220C134CBD2FC4F0493', 'Sakura'),)
self.assertTrue(isinstance(event, stem.response.events.NewDescEvent))
self.assertEqual(NEWDESC_SINGLE.lstrip('650 '), str(event))
self.assertEqual(expected_relays, event.relays)
event = _get_event(NEWDESC_MULTIPLE)
expected_relays = (('BE938957B2CA5F804B3AFC2C1EE6673170CDBBF8', 'Moonshine'),
('B4BE08B22D4D2923EDC3970FD1B93D0448C6D8FF', 'Unnamed'))
self.assertTrue(isinstance(event, stem.response.events.NewDescEvent))
self.assertEqual(NEWDESC_MULTIPLE.lstrip('650 '), str(event))
self.assertEqual(expected_relays, event.relays)
def test_network_liveness_event(self):
event = _get_event('650 NETWORK_LIVENESS UP')
self.assertTrue(isinstance(event, stem.response.events.NetworkLivenessEvent))
self.assertEqual('NETWORK_LIVENESS UP', str(event))
self.assertEqual('UP', event.status)
event = _get_event('650 NETWORK_LIVENESS DOWN')
self.assertEqual('DOWN', event.status)
event = _get_event('650 NETWORK_LIVENESS OTHER_STATUS key=value')
self.assertEqual('OTHER_STATUS', event.status)
def test_new_consensus_event(self):
expected_desc = []
expected_desc.append(RouterStatusEntryV3.create({
'r': 'Beaver /96bKo4soysolMgKn5Hex2nyFSY pAJH9dSBp/CG6sPhhVY/5bLaVPM 2012-12-02 22:02:45 77.223.43.54 9001 0',
's': 'Fast Named Running Stable Valid',
}))
expected_desc.append(RouterStatusEntryV3.create({
'r': 'Unnamed /+fJRWjmIGNAL2C5rRZHq3R91tA 7AnpZjfdBpYzXnMNm+w1bTsFF6Y 2012-12-02 17:51:10 91.121.184.87 9001 0',
's': 'Fast Guard Running Stable Valid',
}))
event = _get_event(NEWCONSENSUS_EVENT)
self.assertTrue(isinstance(event, stem.response.events.NewConsensusEvent))
self.assertEqual(expected_desc, event.desc)
def test_ns_event(self):
expected_desc = RouterStatusEntryV3.create({
'r': 'whnetz dbBxYcJriTTrcxsuy4PUZcMRwCA VStM7KAIH/mXXoGDUpoGB1OXufg 2012-12-02 21:03:56 141.70.120.13 9001 9030',
's': 'Fast HSDir Named Stable V2Dir Valid',
})
event = _get_event(NS_EVENT)
self.assertTrue(isinstance(event, stem.response.events.NetworkStatusEvent))
self.assertEqual([expected_desc], event.desc)
def test_orconn_event(self):
event = _get_event(ORCONN_CLOSED)
self.assertTrue(isinstance(event, stem.response.events.ORConnEvent))
self.assertEqual(ORCONN_CLOSED.lstrip('650 '), str(event))
self.assertEqual('$A1130635A0CDA6F60C276FBF6994EFBD4ECADAB1~tama', event.endpoint)
self.assertEqual('A1130635A0CDA6F60C276FBF6994EFBD4ECADAB1', event.endpoint_fingerprint)
self.assertEqual('tama', event.endpoint_nickname)
self.assertEqual(None, event.endpoint_address)
self.assertEqual(None, event.endpoint_port)
self.assertEqual(ORStatus.CLOSED, event.status)
self.assertEqual(ORClosureReason.DONE, event.reason)
self.assertEqual(None, event.circ_count)
self.assertEqual(None, event.id)
event = _get_event(ORCONN_CONNECTED)
self.assertTrue(isinstance(event, stem.response.events.ORConnEvent))
self.assertEqual(ORCONN_CONNECTED.lstrip('650 '), str(event))
self.assertEqual('127.0.0.1:9000', event.endpoint)
self.assertEqual(None, event.endpoint_fingerprint)
self.assertEqual(None, event.endpoint_nickname)
self.assertEqual('127.0.0.1', event.endpoint_address)
self.assertEqual(9000, event.endpoint_port)
self.assertEqual(ORStatus.CONNECTED, event.status)
self.assertEqual(None, event.reason)
self.assertEqual(20, event.circ_count)
self.assertEqual('18', event.id)
event = _get_event(ORCONN_LAUNCHED)
self.assertTrue(isinstance(event, stem.response.events.ORConnEvent))
self.assertEqual(ORCONN_LAUNCHED.lstrip('650 '), str(event))
self.assertEqual('$7ED90E2833EE38A75795BA9237B0A4560E51E1A0=GreenDragon', event.endpoint)
self.assertEqual('7ED90E2833EE38A75795BA9237B0A4560E51E1A0', event.endpoint_fingerprint)
self.assertEqual('GreenDragon', event.endpoint_nickname)
self.assertEqual(None, event.endpoint_address)
self.assertEqual(None, event.endpoint_port)
self.assertEqual(ORStatus.LAUNCHED, event.status)
self.assertEqual(None, event.reason)
self.assertEqual(None, event.circ_count)
# malformed fingerprint
self.assertRaises(ProtocolError, _get_event, ORCONN_BAD_1)
# invalid port number ('001')
self.assertRaises(ProtocolError, _get_event, ORCONN_BAD_2)
# non-numeric NCIRCS
self.assertRaises(ProtocolError, _get_event, ORCONN_BAD_3)
# invalid connection id
self.assertRaises(ProtocolError, _get_event, ORCONN_BAD_4)
def test_signal_event(self):
event = _get_event('650 SIGNAL DEBUG')
self.assertTrue(isinstance(event, stem.response.events.SignalEvent))
self.assertEqual('SIGNAL DEBUG', str(event))
self.assertEqual(Signal.DEBUG, event.signal)
event = _get_event('650 SIGNAL DUMP')
self.assertEqual(Signal.DUMP, event.signal)
def test_status_event_consensus_arrived(self):
event = _get_event(STATUS_GENERAL_CONSENSUS_ARRIVED)
self.assertTrue(isinstance(event, stem.response.events.StatusEvent))
self.assertEqual(STATUS_GENERAL_CONSENSUS_ARRIVED.lstrip('650 '), str(event))
self.assertEqual(StatusType.GENERAL, event.status_type)
self.assertEqual(Runlevel.NOTICE, event.runlevel)
self.assertEqual('CONSENSUS_ARRIVED', event.action)
def test_status_event_enough_dir_info(self):
event = _get_event(STATUS_CLIENT_ENOUGH_DIR_INFO)
self.assertEqual(StatusType.CLIENT, event.status_type)
self.assertEqual(Runlevel.NOTICE, event.runlevel)
self.assertEqual('ENOUGH_DIR_INFO', event.action)
def test_status_event_circuit_established(self):
event = _get_event(STATUS_CLIENT_CIRC_ESTABLISHED)
self.assertEqual(StatusType.CLIENT, event.status_type)
self.assertEqual(Runlevel.NOTICE, event.runlevel)
self.assertEqual('CIRCUIT_ESTABLISHED', event.action)
def test_status_event_bootstrap_descriptors(self):
event = _get_event(STATUS_CLIENT_BOOTSTRAP_DESCRIPTORS)
self.assertEqual(StatusType.CLIENT, event.status_type)
self.assertEqual(Runlevel.NOTICE, event.runlevel)
self.assertEqual('BOOTSTRAP', event.action)
expected_attr = {
'PROGRESS': '53',
'TAG': 'loading_descriptors',
'SUMMARY': 'Loading relay descriptors',
}
self.assertEqual(expected_attr, event.arguments)
def test_status_event_bootstrap_stuck(self):
event = _get_event(STATUS_CLIENT_BOOTSTRAP_STUCK)
self.assertEqual(StatusType.CLIENT, event.status_type)
self.assertEqual(Runlevel.WARN, event.runlevel)
self.assertEqual('BOOTSTRAP', event.action)
expected_attr = {
'PROGRESS': '80',
'TAG': 'conn_or',
'SUMMARY': 'Connecting to the Tor network',
'WARNING': 'Network is unreachable',
'REASON': 'NOROUTE',
'COUNT': '5',
'RECOMMENDATION': 'warn',
}
self.assertEqual(expected_attr, event.keyword_args)
def test_status_event_bootstrap_connecting(self):
event = _get_event(STATUS_CLIENT_BOOTSTRAP_CONNECTING)
self.assertEqual(StatusType.CLIENT, event.status_type)
self.assertEqual(Runlevel.NOTICE, event.runlevel)
self.assertEqual('BOOTSTRAP', event.action)
expected_attr = {
'PROGRESS': '80',
'TAG': 'conn_or',
'SUMMARY': 'Connecting to the Tor network',
}
self.assertEqual(expected_attr, event.keyword_args)
def test_status_event_bootstrap_first_handshake(self):
event = _get_event(STATUS_CLIENT_BOOTSTRAP_FIRST_HANDSHAKE)
self.assertEqual(StatusType.CLIENT, event.status_type)
self.assertEqual(Runlevel.NOTICE, event.runlevel)
self.assertEqual('BOOTSTRAP', event.action)
expected_attr = {
'PROGRESS': '85',
'TAG': 'handshake_or',
'SUMMARY': 'Finishing handshake with first hop',
}
self.assertEqual(expected_attr, event.keyword_args)
def test_status_event_bootstrap_established(self):
event = _get_event(STATUS_CLIENT_BOOTSTRAP_ESTABLISHED)
self.assertEqual(StatusType.CLIENT, event.status_type)
self.assertEqual(Runlevel.NOTICE, event.runlevel)
self.assertEqual('BOOTSTRAP', event.action)
expected_attr = {
'PROGRESS': '90',
'TAG': 'circuit_create',
'SUMMARY': 'Establishing a Tor circuit',
}
self.assertEqual(expected_attr, event.keyword_args)
def test_status_event_bootstrap_done(self):
event = _get_event(STATUS_CLIENT_BOOTSTRAP_DONE)
self.assertEqual(StatusType.CLIENT, event.status_type)
self.assertEqual(Runlevel.NOTICE, event.runlevel)
self.assertEqual('BOOTSTRAP', event.action)
expected_attr = {
'PROGRESS': '100',
'TAG': 'done',
'SUMMARY': 'Done',
}
self.assertEqual(expected_attr, event.keyword_args)
def test_status_event_bootstrap_check_reachability(self):
event = _get_event(STATUS_SERVER_CHECK_REACHABILITY)
self.assertEqual(StatusType.SERVER, event.status_type)
self.assertEqual(Runlevel.NOTICE, event.runlevel)
self.assertEqual('CHECKING_REACHABILITY', event.action)
expected_attr = {
'ORADDRESS': '71.35.143.230:9050',
}
self.assertEqual(expected_attr, event.keyword_args)
def test_status_event_dns_timeout(self):
event = _get_event(STATUS_SERVER_DNS_TIMEOUT)
self.assertEqual(StatusType.SERVER, event.status_type)
self.assertEqual(Runlevel.NOTICE, event.runlevel)
self.assertEqual('NAMESERVER_STATUS', event.action)
expected_attr = {
'NS': '205.171.3.25',
'STATUS': 'DOWN',
'ERR': 'request timed out.',
}
self.assertEqual(expected_attr, event.keyword_args)
def test_status_event_dns_down(self):
event = _get_event(STATUS_SERVER_DNS_DOWN)
self.assertEqual(StatusType.SERVER, event.status_type)
self.assertEqual(Runlevel.WARN, event.runlevel)
self.assertEqual('NAMESERVER_ALL_DOWN', event.action)
def test_status_event_dns_up(self):
event = _get_event(STATUS_SERVER_DNS_UP)
self.assertEqual(StatusType.SERVER, event.status_type)
self.assertEqual(Runlevel.NOTICE, event.runlevel)
self.assertEqual('NAMESERVER_STATUS', event.action)
expected_attr = {
'NS': '205.171.3.25',
'STATUS': 'UP',
}
self.assertEqual(expected_attr, event.keyword_args)
def test_status_event_bug(self):
# briefly insert a fake value in EVENT_TYPE_TO_CLASS
stem.response.events.EVENT_TYPE_TO_CLASS['STATUS_SPECIFIC'] = stem.response.events.StatusEvent
self.assertRaises(ValueError, _get_event, STATUS_SPECIFIC_CONSENSUS_ARRIVED)
del stem.response.events.EVENT_TYPE_TO_CLASS['STATUS_SPECIFIC']
def test_stream_event(self):
event = _get_event(STREAM_NEW)
self.assertTrue(isinstance(event, stem.response.events.StreamEvent))
self.assertEqual(STREAM_NEW.lstrip('650 '), str(event))
self.assertEqual('18', event.id)
self.assertEqual(StreamStatus.NEW, event.status)
self.assertEqual(None, event.circ_id)
self.assertEqual('encrypted.google.com:443', event.target)
self.assertEqual('encrypted.google.com', event.target_address)
self.assertEqual(443, event.target_port)
self.assertEqual(None, event.reason)
self.assertEqual(None, event.remote_reason)
self.assertEqual(None, event.source)
self.assertEqual('127.0.0.1:47849', event.source_addr)
self.assertEqual('127.0.0.1', event.source_address)
self.assertEqual(47849, event.source_port)
self.assertEqual(StreamPurpose.USER, event.purpose)
event = _get_event(STREAM_SENTCONNECT)
self.assertTrue(isinstance(event, stem.response.events.StreamEvent))
self.assertEqual(STREAM_SENTCONNECT.lstrip('650 '), str(event))
self.assertEqual('18', event.id)
self.assertEqual(StreamStatus.SENTCONNECT, event.status)
self.assertEqual('26', event.circ_id)
self.assertEqual('encrypted.google.com:443', event.target)
self.assertEqual('encrypted.google.com', event.target_address)
self.assertEqual(443, event.target_port)
self.assertEqual(None, event.reason)
self.assertEqual(None, event.remote_reason)
self.assertEqual(None, event.source)
self.assertEqual(None, event.source_addr)
self.assertEqual(None, event.source_address)
self.assertEqual(None, event.source_port)
self.assertEqual(None, event.purpose)
event = _get_event(STREAM_REMAP)
self.assertTrue(isinstance(event, stem.response.events.StreamEvent))
self.assertEqual(STREAM_REMAP.lstrip('650 '), str(event))
self.assertEqual('18', event.id)
self.assertEqual(StreamStatus.REMAP, event.status)
self.assertEqual('26', event.circ_id)
self.assertEqual('74.125.227.129:443', event.target)
self.assertEqual('74.125.227.129', event.target_address)
self.assertEqual(443, event.target_port)
self.assertEqual(None, event.reason)
self.assertEqual(None, event.remote_reason)
self.assertEqual(StreamSource.EXIT, event.source)
self.assertEqual(None, event.source_addr)
self.assertEqual(None, event.source_address)
self.assertEqual(None, event.source_port)
self.assertEqual(None, event.purpose)
event = _get_event(STREAM_SUCCEEDED)
self.assertTrue(isinstance(event, stem.response.events.StreamEvent))
self.assertEqual(STREAM_SUCCEEDED.lstrip('650 '), str(event))
self.assertEqual('18', event.id)
self.assertEqual(StreamStatus.SUCCEEDED, event.status)
self.assertEqual('26', event.circ_id)
self.assertEqual('74.125.227.129:443', event.target)
self.assertEqual('74.125.227.129', event.target_address)
self.assertEqual(443, event.target_port)
self.assertEqual(None, event.reason)
self.assertEqual(None, event.remote_reason)
self.assertEqual(None, event.source)
self.assertEqual(None, event.source_addr)
self.assertEqual(None, event.source_address)
self.assertEqual(None, event.source_port)
self.assertEqual(None, event.purpose)
event = _get_event(STREAM_CLOSED_RESET)
self.assertTrue(isinstance(event, stem.response.events.StreamEvent))
self.assertEqual(STREAM_CLOSED_RESET.lstrip('650 '), str(event))
self.assertEqual('21', event.id)
self.assertEqual(StreamStatus.CLOSED, event.status)
self.assertEqual('26', event.circ_id)
self.assertEqual('74.125.227.129:443', event.target)
self.assertEqual('74.125.227.129', event.target_address)
self.assertEqual(443, event.target_port)
self.assertEqual(StreamClosureReason.CONNRESET, event.reason)
self.assertEqual(None, event.remote_reason)
self.assertEqual(None, event.source)
self.assertEqual(None, event.source_addr)
self.assertEqual(None, event.source_address)
self.assertEqual(None, event.source_port)
self.assertEqual(None, event.purpose)
event = _get_event(STREAM_CLOSED_DONE)
self.assertTrue(isinstance(event, stem.response.events.StreamEvent))
self.assertEqual(STREAM_CLOSED_DONE.lstrip('650 '), str(event))
self.assertEqual('25', event.id)
self.assertEqual(StreamStatus.CLOSED, event.status)
self.assertEqual('26', event.circ_id)
self.assertEqual('199.7.52.72:80', event.target)
self.assertEqual('199.7.52.72', event.target_address)
self.assertEqual(80, event.target_port)
self.assertEqual(StreamClosureReason.DONE, event.reason)
self.assertEqual(None, event.remote_reason)
self.assertEqual(None, event.source)
self.assertEqual(None, event.source_addr)
self.assertEqual(None, event.source_address)
self.assertEqual(None, event.source_port)
self.assertEqual(None, event.purpose)
event = _get_event(STREAM_DIR_FETCH)
self.assertTrue(isinstance(event, stem.response.events.StreamEvent))
self.assertEqual(STREAM_DIR_FETCH.lstrip('650 '), str(event))
self.assertEqual('14', event.id)
self.assertEqual(StreamStatus.NEW, event.status)
self.assertEqual(None, event.circ_id)
self.assertEqual('176.28.51.238.$649F2D0ACF418F7CFC6539AB2257EB2D5297BAFA.exit:443', event.target)
self.assertEqual('176.28.51.238.$649F2D0ACF418F7CFC6539AB2257EB2D5297BAFA.exit', event.target_address)
self.assertEqual(443, event.target_port)
self.assertEqual(None, event.reason)
self.assertEqual(None, event.remote_reason)
self.assertEqual(None, event.source)
self.assertEqual('(Tor_internal):0', event.source_addr)
self.assertEqual('(Tor_internal)', event.source_address)
self.assertEqual(0, event.source_port)
self.assertEqual(StreamPurpose.DIR_FETCH, event.purpose)
event = _get_event(STREAM_DNS_REQUEST)
self.assertTrue(isinstance(event, stem.response.events.StreamEvent))
self.assertEqual(STREAM_DNS_REQUEST.lstrip('650 '), str(event))
self.assertEqual('1113', event.id)
self.assertEqual(StreamStatus.NEW, event.status)
self.assertEqual(None, event.circ_id)
self.assertEqual('www.google.com:0', event.target)
self.assertEqual('www.google.com', event.target_address)
self.assertEqual(0, event.target_port)
self.assertEqual(None, event.reason)
self.assertEqual(None, event.remote_reason)
self.assertEqual(None, event.source)
self.assertEqual('127.0.0.1:15297', event.source_addr)
self.assertEqual('127.0.0.1', event.source_address)
self.assertEqual(15297, event.source_port)
self.assertEqual(StreamPurpose.DNS_REQUEST, event.purpose)
# missing target
self.assertRaises(ProtocolError, _get_event, STREAM_SENTCONNECT_BAD_1)
# target is missing a port
self.assertRaises(ProtocolError, _get_event, STREAM_SENTCONNECT_BAD_2)
# target's port is malformed
self.assertRaises(ProtocolError, _get_event, STREAM_SENTCONNECT_BAD_3)
# SOURCE_ADDR is missing a port
self.assertRaises(ProtocolError, _get_event, STREAM_DNS_REQUEST_BAD_1)
# SOURCE_ADDR's port is malformed
self.assertRaises(ProtocolError, _get_event, STREAM_DNS_REQUEST_BAD_2)
# IPv6 address
event = _get_event(STREAM_NEWRESOLVE_IP6)
self.assertTrue(isinstance(event, stem.response.events.StreamEvent))
self.assertEqual(STREAM_NEWRESOLVE_IP6.lstrip('650 '), str(event))
self.assertEqual('23', event.id)
self.assertEqual(StreamStatus.NEWRESOLVE, event.status)
self.assertEqual(None, event.circ_id)
self.assertEqual('2001:db8::1:0', event.target)
self.assertEqual('2001:db8::1', event.target_address)
self.assertEqual(0, event.target_port)
self.assertEqual(None, event.reason)
self.assertEqual(None, event.remote_reason)
self.assertEqual(None, event.source)
self.assertEqual(None, event.source_addr)
self.assertEqual(None, event.source_address)
self.assertEqual(None, event.source_port)
self.assertEqual(StreamPurpose.DNS_REQUEST, event.purpose)
def test_stream_bw_event(self):
event = _get_event('650 STREAM_BW 2 15 25')
self.assertTrue(isinstance(event, stem.response.events.StreamBwEvent))
self.assertEqual('2', event.id)
self.assertEqual(15, event.written)
self.assertEqual(25, event.read)
self.assertEqual(None, event.time)
event = _get_event('650 STREAM_BW Stream02 0 0')
self.assertEqual('Stream02', event.id)
self.assertEqual(0, event.written)
self.assertEqual(0, event.read)
self.assertEqual(None, event.time)
event = _get_event('650 STREAM_BW Stream02 0 0 2012-12-06T13:51:11.433755')
self.assertEqual('Stream02', event.id)
self.assertEqual(0, event.written)
self.assertEqual(0, event.read)
self.assertEqual(datetime.datetime(2012, 12, 6, 13, 51, 11, 433755), event.time)
self.assertRaises(ProtocolError, _get_event, '650 STREAM_BW')
self.assertRaises(ProtocolError, _get_event, '650 STREAM_BW 2')
self.assertRaises(ProtocolError, _get_event, '650 STREAM_BW 2 15')
self.assertRaises(ProtocolError, _get_event, '650 STREAM_BW - 15 25')
self.assertRaises(ProtocolError, _get_event, '650 STREAM_BW 12345678901234567 15 25')
self.assertRaises(ProtocolError, _get_event, '650 STREAM_BW 2 -15 25')
self.assertRaises(ProtocolError, _get_event, '650 STREAM_BW 2 15 -25')
self.assertRaises(ProtocolError, _get_event, '650 STREAM_BW 2 x 25')
def test_transport_launched_event(self):
event = _get_event(TRANSPORT_LAUNCHED)
self.assertTrue(isinstance(event, stem.response.events.TransportLaunchedEvent))
self.assertEqual(TRANSPORT_LAUNCHED.lstrip('650 '), str(event))
self.assertEqual('server', event.type)
self.assertEqual('obfs1', event.name)
self.assertEqual('127.0.0.1', event.address)
self.assertEqual(1111, event.port)
self.assertRaises(ProtocolError, _get_event, TRANSPORT_LAUNCHED_BAD_TYPE)
self.assertRaises(ProtocolError, _get_event, TRANSPORT_LAUNCHED_BAD_ADDRESS)
self.assertRaises(ProtocolError, _get_event, TRANSPORT_LAUNCHED_BAD_PORT)
def test_conn_bw_event(self):
event = _get_event(CONN_BW)
self.assertTrue(isinstance(event, stem.response.events.ConnectionBandwidthEvent))
self.assertEqual(CONN_BW.lstrip('650 '), str(event))
self.assertEqual('11', event.id)
self.assertEqual(stem.ConnectionType.DIR, event.conn_type)
self.assertEqual(272, event.read)
self.assertEqual(817, event.written)
self.assertRaises(ProtocolError, _get_event, CONN_BW_BAD_WRITTEN_VALUE)
self.assertRaises(ProtocolError, _get_event, CONN_BW_BAD_MISSING_ID)
def test_circ_bw_event(self):
event = _get_event(CIRC_BW)
self.assertTrue(isinstance(event, stem.response.events.CircuitBandwidthEvent))
self.assertEqual(CIRC_BW.lstrip('650 '), str(event))
self.assertEqual('11', event.id)
self.assertEqual(272, event.read)
self.assertEqual(817, event.written)
self.assertEqual(None, event.time)
event = _get_event(CIRC_BW_WITH_TIMESTAMP)
self.assertEqual('11', event.id)
self.assertEqual(272, event.read)
self.assertEqual(817, event.written)
self.assertEqual(datetime.datetime(2012, 12, 6, 13, 51, 11, 433755), event.time)
self.assertRaises(ProtocolError, _get_event, CIRC_BW_BAD_WRITTEN_VALUE)
self.assertRaises(ProtocolError, _get_event, CIRC_BW_BAD_MISSING_ID)
self.assertRaises(ProtocolError, _get_event, CIRC_BW_MALFORMED_TIMESTAMP)
def test_cell_stats_event(self):
event = _get_event(CELL_STATS_1)
self.assertTrue(isinstance(event, stem.response.events.CellStatsEvent))
self.assertEqual(CELL_STATS_1.lstrip('650 '), str(event))
self.assertEqual('14', event.id)
self.assertEqual(None, event.inbound_queue)
self.assertEqual(None, event.inbound_connection)
self.assertEqual(None, event.inbound_added)
self.assertEqual(None, event.inbound_removed)
self.assertEqual(None, event.inbound_time)
self.assertEqual('19403', event.outbound_queue)
self.assertEqual('15', event.outbound_connection)
self.assertEqual({'create_fast': 1, 'relay_early': 2}, event.outbound_added)
self.assertEqual({'create_fast': 1, 'relay_early': 2}, event.outbound_removed)
self.assertEqual({'create_fast': 0, 'relay_early': 0}, event.outbound_time)
event = _get_event(CELL_STATS_2)
self.assertTrue(isinstance(event, stem.response.events.CellStatsEvent))
self.assertEqual(CELL_STATS_2.lstrip('650 '), str(event))
self.assertEqual(None, event.id)
self.assertEqual('19403', event.inbound_queue)
self.assertEqual('32', event.inbound_connection)
self.assertEqual({'relay': 1, 'created_fast': 1}, event.inbound_added)
self.assertEqual({'relay': 1, 'created_fast': 1}, event.inbound_removed)
self.assertEqual({'relay': 0, 'created_fast': 0}, event.inbound_time)
self.assertEqual('6710', event.outbound_queue)
self.assertEqual('18', event.outbound_connection)
self.assertEqual({'create': 1, 'relay_early': 1}, event.outbound_added)
self.assertEqual({'create': 1, 'relay_early': 1}, event.outbound_removed)
self.assertEqual({'create': 0, 'relay_early': 0}, event.outbound_time)
# check a few invalid mappings (bad key or value)
self.assertRaises(ProtocolError, _get_event, CELL_STATS_BAD_1)
self.assertRaises(ProtocolError, _get_event, CELL_STATS_BAD_2)
self.assertRaises(ProtocolError, _get_event, CELL_STATS_BAD_3)
def test_token_bucket_empty_event(self):
event = _get_event(TB_EMPTY_1)
self.assertTrue(isinstance(event, stem.response.events.TokenBucketEmptyEvent))
self.assertEqual(TB_EMPTY_1.lstrip('650 '), str(event))
self.assertEqual(stem.TokenBucket.ORCONN, event.bucket)
self.assertEqual('16', event.id)
self.assertEqual(0, event.read)
self.assertEqual(0, event.written)
self.assertEqual(100, event.last_refill)
event = _get_event(TB_EMPTY_2)
self.assertTrue(isinstance(event, stem.response.events.TokenBucketEmptyEvent))
self.assertEqual(TB_EMPTY_2.lstrip('650 '), str(event))
self.assertEqual(stem.TokenBucket.GLOBAL, event.bucket)
self.assertEqual(None, event.id)
self.assertEqual(93, event.read)
self.assertEqual(93, event.written)
self.assertEqual(100, event.last_refill)
event = _get_event(TB_EMPTY_3)
self.assertTrue(isinstance(event, stem.response.events.TokenBucketEmptyEvent))
self.assertEqual(TB_EMPTY_3.lstrip('650 '), str(event))
self.assertEqual(stem.TokenBucket.RELAY, event.bucket)
self.assertEqual(None, event.id)
self.assertEqual(93, event.read)
self.assertEqual(93, event.written)
self.assertEqual(100, event.last_refill)
self.assertRaises(ProtocolError, _get_event, TB_EMPTY_BAD_1)
self.assertRaises(ProtocolError, _get_event, TB_EMPTY_BAD_2)
def test_unrecognized_enum_logging(self):
"""
Checks that when event parsing gets a value that isn't recognized by stem's
enumeration of the attribute that we log a message.
"""
stem_logger = stem.util.log.get_logger()
logging_buffer = stem.util.log.LogBuffer(stem.util.log.INFO)
stem_logger.addHandler(logging_buffer)
# Try parsing a valid event. We shouldn't log anything.
_get_event(STATUS_GENERAL_CONSENSUS_ARRIVED)
self.assertTrue(logging_buffer.is_empty())
self.assertEqual([], list(logging_buffer))
# Parse an invalid runlevel.
_get_event(STATUS_GENERAL_CONSENSUS_ARRIVED.replace('NOTICE', 'OMEGA_CRITICAL!!!'))
logged_events = list(logging_buffer)
self.assertEqual(1, len(logged_events))
self.assertTrue('STATUS_GENERAL event had an unrecognized runlevel' in logged_events[0])
stem_logger.removeHandler(logging_buffer)
stem-1.6.0/test/unit/response/getinfo.py 0000664 0001750 0001750 00000007452 13124757510 021026 0 ustar atagar atagar 0000000 0000000 """
Unit tests for the stem.response.getinfo.GetInfoResponse class.
"""
import unittest
import stem.response
import stem.response.getinfo
import stem.socket
import stem.util.str_tools
from stem.response import ControlMessage
SINGLE_RESPONSE = """\
250-version=0.2.3.11-alpha-dev
250 OK"""
BATCH_RESPONSE = """\
250-version=0.2.3.11-alpha-dev
250-address=67.137.76.214
250-fingerprint=5FDE0422045DF0E1879A3738D09099EB4A0C5BA0
250 OK"""
MULTILINE_RESPONSE = """\
250-version=0.2.3.11-alpha-dev (git-ef0bc7f8f26a917c)
250+config-text=
ControlPort 9051
DataDirectory /home/atagar/.tor
ExitPolicy reject *:*
Log notice stdout
Nickname Unnamed
ORPort 9050
.
250 OK"""
NON_KEY_VALUE_ENTRY = """\
250-version=0.2.3.11-alpha-dev
250-address 67.137.76.214
250 OK"""
UNRECOGNIZED_KEY_ENTRY = """\
552 Unrecognized key "blackhole"
"""
MISSING_MULTILINE_NEWLINE = """\
250+config-text=ControlPort 9051
DataDirectory /home/atagar/.tor
.
250 OK"""
class TestGetInfoResponse(unittest.TestCase):
def test_empty_response(self):
"""
Parses a GETINFO reply without options (just calling "GETINFO").
"""
control_message = ControlMessage.from_str('250 OK\r\n', 'GETINFO')
# now this should be a GetInfoResponse (ControlMessage subclass)
self.assertTrue(isinstance(control_message, stem.response.ControlMessage))
self.assertTrue(isinstance(control_message, stem.response.getinfo.GetInfoResponse))
self.assertEqual({}, control_message.entries)
def test_single_response(self):
"""
Parses a GETINFO reply response for a single parameter.
"""
control_message = ControlMessage.from_str(SINGLE_RESPONSE, 'GETINFO', normalize = True)
self.assertEqual({'version': b'0.2.3.11-alpha-dev'}, control_message.entries)
def test_batch_response(self):
"""
Parses a GETINFO reply for muiltiple parameters.
"""
expected = {
'version': b'0.2.3.11-alpha-dev',
'address': b'67.137.76.214',
'fingerprint': b'5FDE0422045DF0E1879A3738D09099EB4A0C5BA0',
}
control_message = ControlMessage.from_str(BATCH_RESPONSE, 'GETINFO', normalize = True)
self.assertEqual(expected, control_message.entries)
def test_multiline_response(self):
"""
Parses a GETINFO reply for multiple parameters including a multi-line
value.
"""
expected = {
'version': b'0.2.3.11-alpha-dev (git-ef0bc7f8f26a917c)',
'config-text': b'\n'.join(stem.util.str_tools._to_bytes(MULTILINE_RESPONSE).splitlines()[2:8]),
}
control_message = ControlMessage.from_str(MULTILINE_RESPONSE, 'GETINFO', normalize = True)
self.assertEqual(expected, control_message.entries)
def test_invalid_non_mapping_content(self):
"""
Parses a malformed GETINFO reply containing a line that isn't a key=value
entry.
"""
control_message = ControlMessage.from_str(NON_KEY_VALUE_ENTRY, normalize = True)
self.assertRaises(stem.ProtocolError, stem.response.convert, 'GETINFO', control_message)
def test_unrecognized_key_response(self):
"""
Parses a GETCONF reply that contains an error code with an unrecognized key.
"""
try:
control_message = ControlMessage.from_str(UNRECOGNIZED_KEY_ENTRY, normalize = True)
stem.response.convert('GETINFO', control_message)
self.fail('expected a stem.InvalidArguments to be raised')
except stem.InvalidArguments as exc:
self.assertEqual(exc.arguments, ['blackhole'])
def test_invalid_multiline_content(self):
"""
Parses a malformed GETINFO reply with a multi-line entry missing a newline
between its key and value. This is a proper controller message, but
malformed according to the GETINFO's spec.
"""
control_message = ControlMessage.from_str(MISSING_MULTILINE_NEWLINE, normalize = True)
self.assertRaises(stem.ProtocolError, stem.response.convert, 'GETINFO', control_message)
stem-1.6.0/test/unit/response/mapaddress.py 0000664 0001750 0001750 00000004665 13124757510 021521 0 ustar atagar atagar 0000000 0000000 """
Unit tests for the stem.response.mapaddress.MapAddressResponse class.
"""
import unittest
import stem.response
import stem.response.mapaddress
import stem.socket
from stem.response import ControlMessage
BATCH_RESPONSE = """\
250-foo=bar
250-baz=quux
250-gzzz=bzz
250 120.23.23.2=torproject.org"""
INVALID_EMPTY_RESPONSE = '250 OK'
INVALID_RESPONSE = '250 foo is bar'
PARTIAL_FAILURE_RESPONSE = """512-syntax error: mapping '2389' is not of expected form 'foo=bar'
512-syntax error: mapping '23' is not of expected form 'foo=bar'.
250 23=324"""
UNRECOGNIZED_KEYS_RESPONSE = "512 syntax error: mapping '2389' is not of expected form 'foo=bar'"
FAILED_RESPONSE = '451 Resource exhausted'
class TestMapAddressResponse(unittest.TestCase):
def test_single_response(self):
"""
Parses a MAPADDRESS reply response with a single address mapping.
"""
control_message = ControlMessage.from_str('250 foo=bar\r\n', 'MAPADDRESS')
self.assertEqual({'foo': 'bar'}, control_message.entries)
def test_batch_response(self):
"""
Parses a MAPADDRESS reply with multiple address mappings
"""
expected = {
'foo': 'bar',
'baz': 'quux',
'gzzz': 'bzz',
'120.23.23.2': 'torproject.org'
}
control_message = ControlMessage.from_str(BATCH_RESPONSE, 'MAPADDRESS', normalize = True)
self.assertEqual(expected, control_message.entries)
def test_invalid_requests(self):
"""
Parses a MAPADDRESS replies that contain an error code due to hostname syntax errors.
"""
control_message = ControlMessage.from_str(UNRECOGNIZED_KEYS_RESPONSE, normalize = True)
self.assertRaises(stem.InvalidRequest, stem.response.convert, 'MAPADDRESS', control_message)
control_message = ControlMessage.from_str(PARTIAL_FAILURE_RESPONSE, 'MAPADDRESS', normalize = True)
self.assertEqual({'23': '324'}, control_message.entries)
def test_invalid_response(self):
"""
Parses a malformed MAPADDRESS reply that contains an invalid response code.
This is a proper controller message, but malformed according to the
MAPADDRESS's spec.
"""
control_message = ControlMessage.from_str(INVALID_EMPTY_RESPONSE, normalize = True)
self.assertRaises(stem.ProtocolError, stem.response.convert, 'MAPADDRESS', control_message)
control_message = ControlMessage.from_str(INVALID_RESPONSE, normalize = True)
self.assertRaises(stem.ProtocolError, stem.response.convert, 'MAPADDRESS', control_message)
stem-1.6.0/test/unit/response/control_line.py 0000664 0001750 0001750 00000015145 13115423200 022042 0 ustar atagar atagar 0000000 0000000 """
Unit tests for the stem.response.ControlLine class.
"""
import unittest
import stem.response
# response made by having 'DataDirectory /tmp/my data\"dir/' in the torrc
PROTOCOLINFO_RESPONSE = (
'PROTOCOLINFO 1',
'AUTH METHODS=COOKIE COOKIEFILE="/tmp/my data\\\\\\"dir//control_auth_cookie"',
'VERSION Tor="0.2.1.30"',
'OK',
)
class TestControlLine(unittest.TestCase):
def test_pop_examples(self):
"""
Checks that the pop method's pydoc examples are correct.
"""
line = stem.response.ControlLine("\"We're all mad here.\" says the grinning cat.")
self.assertEqual(line.pop(True), "We're all mad here.")
self.assertEqual(line.pop(), 'says')
self.assertEqual(line.remainder(), 'the grinning cat.')
line = stem.response.ControlLine('"this has a \\" and \\\\ in it" foo=bar more_data')
self.assertEqual(line.pop(True, True), 'this has a " and \\ in it')
def test_string(self):
"""
Basic checks that we behave as a regular immutable string.
"""
line = stem.response.ControlLine(PROTOCOLINFO_RESPONSE[0])
self.assertEqual(line, 'PROTOCOLINFO 1')
self.assertTrue(line.startswith('PROTOCOLINFO '))
# checks that popping items doesn't effect us
line.pop()
self.assertEqual(line, 'PROTOCOLINFO 1')
self.assertTrue(line.startswith('PROTOCOLINFO '))
def test_general_usage(self):
"""
Checks a basic use case for the popping entries.
"""
# pops a series of basic, space separated entries
line = stem.response.ControlLine(PROTOCOLINFO_RESPONSE[0])
self.assertEqual(line.remainder(), 'PROTOCOLINFO 1')
self.assertFalse(line.is_empty())
self.assertFalse(line.is_next_quoted())
self.assertFalse(line.is_next_mapping())
self.assertEqual(None, line.peek_key())
self.assertRaises(ValueError, line.pop_mapping)
self.assertEqual(line.pop(), 'PROTOCOLINFO')
self.assertEqual(line.remainder(), '1')
self.assertFalse(line.is_empty())
self.assertFalse(line.is_next_quoted())
self.assertFalse(line.is_next_mapping())
self.assertEqual(None, line.peek_key())
self.assertRaises(ValueError, line.pop_mapping)
self.assertEqual(line.pop(), '1')
self.assertEqual(line.remainder(), '')
self.assertTrue(line.is_empty())
self.assertFalse(line.is_next_quoted())
self.assertFalse(line.is_next_mapping())
self.assertEqual(None, line.peek_key())
self.assertRaises(IndexError, line.pop_mapping)
self.assertRaises(IndexError, line.pop)
self.assertEqual(line.remainder(), '')
self.assertTrue(line.is_empty())
self.assertFalse(line.is_next_quoted())
self.assertFalse(line.is_next_mapping())
self.assertEqual(None, line.peek_key())
def test_pop_mapping(self):
"""
Checks use cases when parsing KEY=VALUE mappings.
"""
# version entry with a space
version_entry = 'Tor="0.2.1.30 (0a083b0188cacd2f07838ff0446113bd5211a024)"'
line = stem.response.ControlLine(version_entry)
self.assertEqual(line.remainder(), version_entry)
self.assertFalse(line.is_empty())
self.assertFalse(line.is_next_quoted())
self.assertTrue(line.is_next_mapping())
self.assertTrue(line.is_next_mapping(key = 'Tor'))
self.assertTrue(line.is_next_mapping(key = 'Tor', quoted = True))
self.assertTrue(line.is_next_mapping(quoted = True))
self.assertEqual('Tor', line.peek_key())
# try popping this as a non-quoted mapping
self.assertEqual(line.pop_mapping(), ('Tor', '"0.2.1.30'))
self.assertEqual(line.remainder(), '(0a083b0188cacd2f07838ff0446113bd5211a024)"')
self.assertFalse(line.is_empty())
self.assertFalse(line.is_next_quoted())
self.assertFalse(line.is_next_mapping())
self.assertRaises(ValueError, line.pop_mapping)
self.assertEqual(None, line.peek_key())
# try popping this as a quoted mapping
line = stem.response.ControlLine(version_entry)
self.assertEqual(line.pop_mapping(True), ('Tor', '0.2.1.30 (0a083b0188cacd2f07838ff0446113bd5211a024)'))
self.assertEqual(line.remainder(), '')
self.assertTrue(line.is_empty())
self.assertFalse(line.is_next_quoted())
self.assertFalse(line.is_next_mapping())
self.assertEqual(None, line.peek_key())
def test_escapes(self):
"""
Checks that we can parse quoted values with escaped quotes in it. This
explicitely comes up with the COOKIEFILE attribute of PROTOCOLINFO
responses.
"""
auth_line = PROTOCOLINFO_RESPONSE[1]
line = stem.response.ControlLine(auth_line)
self.assertEqual(line, auth_line)
self.assertEqual(line.remainder(), auth_line)
self.assertEqual(line.pop(), 'AUTH')
self.assertEqual(line.pop_mapping(), ('METHODS', 'COOKIE'))
self.assertEqual(line.remainder(), r'COOKIEFILE="/tmp/my data\\\"dir//control_auth_cookie"')
self.assertTrue(line.is_next_mapping())
self.assertTrue(line.is_next_mapping(key = 'COOKIEFILE'))
self.assertTrue(line.is_next_mapping(quoted = True))
self.assertTrue(line.is_next_mapping(quoted = True, escaped = True))
cookie_file_entry = line.remainder()
# try a general pop
self.assertEqual(line.pop(), 'COOKIEFILE="/tmp/my')
self.assertEqual(line.pop(), r'data\\\"dir//control_auth_cookie"')
self.assertTrue(line.is_empty())
# try a general pop with escapes
line = stem.response.ControlLine(cookie_file_entry)
self.assertEqual(line.pop(escaped = True), 'COOKIEFILE="/tmp/my')
self.assertEqual(line.pop(escaped = True), r'data\"dir//control_auth_cookie"')
self.assertTrue(line.is_empty())
# try a mapping pop
line = stem.response.ControlLine(cookie_file_entry)
self.assertEqual(line.pop_mapping(), ('COOKIEFILE', '"/tmp/my'))
self.assertEqual(line.remainder(), r'data\\\"dir//control_auth_cookie"')
self.assertFalse(line.is_empty())
# try a quoted mapping pop (this should trip up on the escaped quote)
line = stem.response.ControlLine(cookie_file_entry)
self.assertEqual(line.pop_mapping(True), ('COOKIEFILE', '/tmp/my data\\\\\\'))
self.assertEqual(line.remainder(), 'dir//control_auth_cookie"')
self.assertFalse(line.is_empty())
# try an escaped quoted mapping pop
line = stem.response.ControlLine(cookie_file_entry)
self.assertEqual(line.pop_mapping(True, True), ('COOKIEFILE', r'/tmp/my data\"dir//control_auth_cookie'))
self.assertTrue(line.is_empty())
# try an escaped slash followed by a character that could be part of an
# escape sequence
line = stem.response.ControlLine(r'COOKIEFILE="C:\\Users\\Atagar\\AppData\\tor\\control_auth_cookie"')
self.assertEqual(line.pop_mapping(True, True), ('COOKIEFILE', r'C:\Users\Atagar\AppData\tor\control_auth_cookie'))
self.assertTrue(line.is_empty())
stem-1.6.0/test/unit/response/control_message.py 0000664 0001750 0001750 00000016207 13165210535 022551 0 ustar atagar atagar 0000000 0000000 """
Unit tests for the stem.response.ControlMessage parsing and class.
"""
import io
import socket
import unittest
import stem.socket
import stem.response
import stem.response.getinfo
import stem.util.str_tools
OK_REPLY = '250 OK\r\n'
EVENT_BW = '650 BW 32326 2856\r\n'
EVENT_CIRC_TIMEOUT = '650 CIRC 5 FAILED PURPOSE=GENERAL REASON=TIMEOUT\r\n'
EVENT_CIRC_LAUNCHED = '650 CIRC 9 LAUNCHED PURPOSE=GENERAL\r\n'
EVENT_CIRC_EXTENDED = '650 CIRC 5 EXTENDED $A200F527C82C59A25CCA44884B49D3D65B122652=faktor PURPOSE=MEASURE_TIMEOUT\r\n'
GETINFO_VERSION = """250-version=0.2.2.23-alpha (git-b85eb949b528f4d7)
250 OK
""".replace('\n', '\r\n')
GETINFO_INFONAMES = """250+info/names=
accounting/bytes -- Number of bytes read/written so far in the accounting interval.
accounting/bytes-left -- Number of bytes left to write/read so far in the accounting interval.
accounting/enabled -- Is accounting currently enabled?
accounting/hibernating -- Are we hibernating or awake?
stream-status -- List of current streams.
version -- The current version of Tor.
.
250 OK
""".replace('\n', '\r\n')
class TestControlMessage(unittest.TestCase):
def test_from_str(self):
msg = stem.response.ControlMessage.from_str(GETINFO_VERSION)
self.assertTrue(isinstance(msg, stem.response.ControlMessage))
self.assertEqual('version=0.2.2.23-alpha (git-b85eb949b528f4d7)\nOK', str(msg))
msg = stem.response.ControlMessage.from_str(GETINFO_VERSION, 'GETINFO')
self.assertTrue(isinstance(msg, stem.response.getinfo.GetInfoResponse))
self.assertEqual({'version': b'0.2.2.23-alpha (git-b85eb949b528f4d7)'}, msg.entries)
def test_ok_response(self):
"""
Checks the basic 'OK' response that we get for most commands.
"""
message = self._assert_message_parses(OK_REPLY)
self.assertEqual('OK', str(message))
contents = message.content()
self.assertEqual(1, len(contents))
self.assertEqual(('250', ' ', 'OK'), contents[0])
def test_event_response(self):
"""
Checks parsing of actual events.
"""
# BW event
message = self._assert_message_parses(EVENT_BW)
self.assertEqual('BW 32326 2856', str(message))
contents = message.content()
self.assertEqual(1, len(contents))
self.assertEqual(('650', ' ', 'BW 32326 2856'), contents[0])
# few types of CIRC events
for circ_content in (EVENT_CIRC_TIMEOUT, EVENT_CIRC_LAUNCHED, EVENT_CIRC_EXTENDED):
message = self._assert_message_parses(circ_content)
self.assertEqual(circ_content[4:-2], str(message))
contents = message.content()
self.assertEqual(1, len(contents))
self.assertEqual(('650', ' ', str(message)), contents[0])
def test_getinfo_response(self):
"""
Checks parsing of actual GETINFO responses.
"""
# GETINFO version (basic single-line results)
message = self._assert_message_parses(GETINFO_VERSION)
self.assertEqual(2, len(list(message)))
self.assertEqual(2, len(str(message).splitlines()))
# manually checks the contents
contents = message.content()
self.assertEqual(2, len(contents))
self.assertEqual(('250', '-', 'version=0.2.2.23-alpha (git-b85eb949b528f4d7)'), contents[0])
self.assertEqual(('250', ' ', 'OK'), contents[1])
# GETINFO info/names (data entry)
message = self._assert_message_parses(GETINFO_INFONAMES)
self.assertEqual(2, len(list(message)))
self.assertEqual(8, len(str(message).splitlines()))
# manually checks the contents
contents = message.content()
self.assertEqual(2, len(contents))
first_entry = (contents[0][0], contents[0][1], contents[0][2][:contents[0][2].find('\n')])
self.assertEqual(('250', '+', 'info/names='), first_entry)
self.assertEqual(('250', ' ', 'OK'), contents[1])
def test_no_crlf(self):
"""
Checks that we get a ProtocolError when we don't have both a carriage
return and newline for line endings. This doesn't really check for
newlines (since that's what readline would break on), but not the end of
the world.
"""
# Replaces each of the CRLF entries with just LF, confirming that this
# causes a parsing error. This should test line endings for both data
# entry parsing and non-data.
infonames_lines = [line + '\n' for line in GETINFO_INFONAMES.splitlines()]
for index, line in enumerate(infonames_lines):
# replace the CRLF for the line
infonames_lines[index] = line.rstrip('\r\n') + '\n'
test_socket_file = io.BytesIO(stem.util.str_tools._to_bytes(''.join(infonames_lines)))
self.assertRaises(stem.ProtocolError, stem.socket.recv_message, test_socket_file)
# puts the CRLF back
infonames_lines[index] = infonames_lines[index].rstrip('\n') + '\r\n'
# sanity check the above test isn't broken due to leaving infonames_lines
# with invalid data
self._assert_message_parses(''.join(infonames_lines))
def test_malformed_prefix(self):
"""
Checks parsing for responses where the header is missing a digit or divider.
"""
for index in range(len(EVENT_BW)):
# makes test input with that character missing or replaced
removal_test_input = EVENT_BW[:index] + EVENT_BW[index + 1:]
replacement_test_input = EVENT_BW[:index] + '#' + EVENT_BW[index + 1:]
if index < 4 or index >= (len(EVENT_BW) - 2):
# dropping the character should cause an error if...
# - this is part of the message prefix
# - this is disrupting the line ending
self.assertRaises(stem.ProtocolError, stem.socket.recv_message, io.BytesIO(stem.util.str_tools._to_bytes(removal_test_input)))
self.assertRaises(stem.ProtocolError, stem.socket.recv_message, io.BytesIO(stem.util.str_tools._to_bytes(replacement_test_input)))
else:
# otherwise the data will be malformed, but this goes undetected
self._assert_message_parses(removal_test_input)
self._assert_message_parses(replacement_test_input)
def test_disconnected_socket(self):
"""
Tests when the read function is given a file derived from a disconnected
socket.
"""
control_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
control_socket_file = control_socket.makefile()
self.assertRaises(stem.SocketClosed, stem.socket.recv_message, control_socket_file)
def _assert_message_parses(self, controller_reply):
"""
Performs some basic sanity checks that a reply mirrors its parsed result.
Returns:
stem.response.ControlMessage for the given input
"""
message = stem.socket.recv_message(io.BytesIO(stem.util.str_tools._to_bytes(controller_reply)))
# checks that the raw_content equals the input value
self.assertEqual(controller_reply, message.raw_content())
# checks that the contents match the input
message_lines = str(message).splitlines()
controller_lines = controller_reply.split('\r\n')
controller_lines.pop() # the ControlMessage won't have a trailing newline
while controller_lines:
line = controller_lines.pop(0)
# mismatching lines with just a period are probably data termination
if line == '.' and (not message_lines or line != message_lines[0]):
continue
self.assertTrue(line.endswith(message_lines.pop(0)))
return message
stem-1.6.0/test/unit/descriptor/ 0000775 0001750 0001750 00000000000 13177674754 017351 5 ustar atagar atagar 0000000 0000000 stem-1.6.0/test/unit/descriptor/networkstatus/ 0000775 0001750 0001750 00000000000 13177674754 022306 5 ustar atagar atagar 0000000 0000000 stem-1.6.0/test/unit/descriptor/networkstatus/__init__.py 0000664 0001750 0001750 00000000235 13115423200 024361 0 ustar atagar atagar 0000000 0000000 """
Unit tests for stem.descriptor.networkstatus.
"""
__all__ = ['bridge_document', 'directory_authority', 'key_certificate', 'document_v2', 'document_v3']
stem-1.6.0/test/unit/descriptor/networkstatus/key_certificate.py 0000664 0001750 0001750 00000030161 13125773507 026000 0 ustar atagar atagar 0000000 0000000 """
Unit tests for the KeyCertificate of stem.descriptor.networkstatus.
"""
import datetime
import unittest
import stem.descriptor
import test.require
from stem.descriptor.networkstatus import KeyCertificate
from test.unit.descriptor import get_resource
class TestKeyCertificate(unittest.TestCase):
def test_minimal(self):
"""
Parses a minimal key certificate.
"""
certificate = KeyCertificate.create()
self.assertEqual(3, certificate.version)
self.assertEqual(None, certificate.address)
self.assertEqual(None, certificate.dir_port)
self.assertEqual(40, len(certificate.fingerprint))
self.assertEqual(None, certificate.crosscert)
self.assertEqual([], certificate.get_unrecognized_lines())
def test_real_certificates(self):
"""
Checks that key certificates from chutney can be properly parsed.
"""
expected_identity_key = """\
-----BEGIN RSA PUBLIC KEY-----
MIIBigKCAYEAxfTHG1b3Sxe8n3JQ/nIk4+1/chj7+jAyLLK+WrEBiP1vnDxTXMuo
x26ntWEjOaxjtKB12k5wMQW94/KvE754Gn98uQRFBHqLkrS4hUnn4/MqiBQVd2y3
UtE6KDSRhJZ5LfFH+dCKwu5+695PyJp/pfCUSOyPj0HQbFOnAOqdHPok8dtdfsy0
LaI7ycpzqAalzgrlwFP5KwwLtL+VapUGN4QOZlIXgL4W5e7OAG42lZhHt0b7/zdt
oIegZM1y8tK2l75ijqsvbetddQcFlnVaYzNwlQAUIZuxJOGfnPfTo+WrjCgrK2ur
ed5NiQMrEbZn5uCUscs+xLlKl4uKW0XXo1EIL45yBrVbmlP6V3/9diTHk64W9+m8
2G4ToDyH8J7LvnYPsmD0cCaQEceebxYVlmmwgqdORH/ixbeGF7JalTwtWBQYo2r0
VZAqjRwxR9dri6m1MIpzmzWmrbXghZ1IzJEL1rpB0okA/bE8AUGRx61eKnbI415O
PmO06JMpvkxxAgMBAAE=
-----END RSA PUBLIC KEY-----"""
expected_signing_key = """\
-----BEGIN RSA PUBLIC KEY-----
MIIBCgKCAQEAvzugxJl1gc7BgXarBO5IWejNZC30U1xVjZ/myQTzxtiKkPU0agQh
sPqn4vVsaW6ZnWjJ2pSOq0/jg8WgFyGHGQ9cG8tv2TlpObeb/tI7iANxWx+MXJAh
/CnFDBQ1ifKntJrs2IcRKMivfobqaHAL3Pz93noLWOTQunWjZ8D6kovYvUXe+yUQ
tZEROrmXJx7ZIIJF6BNKYBTc+iEkYtkWlJVs0my7yP/bbS075QyBsr6CfT+O2yU4
mgIg43QuqcFRbjyUvGI/gap06QNlB6yj8pqeE5rWo++5EpEvMK76fK6ymYuTN2SN
Oil+Fo7qgG8UP/fv0GelSz6Tk7pBoeHJlQIDAQAB
-----END RSA PUBLIC KEY-----"""
expected_crosscert = """\
-----BEGIN ID SIGNATURE-----
Oz+rvXDzlxLgQSb3nS5/4hrHVWgGCy0OnuNmFsyw8bi2eBst5Yj79dQ+D25giZke
81FRGIFU4eS6dshB+pJ+z0hc9ozlRTYh/qevY6l6o0amvuhHyk/cQXrh8oYU9Ihe
XQ1yVItvxC24HENsoGIGbr5uxc85FOcNs+R9qTLYA/56TjvAU4WUje3nTZE1awml
lj/Y6DM7ruMF6UoYJZPTklukZ+XHZg4Z2eE55e/oIaD7bfU/lFWU/alMyTV/J5oT
sxaD2XBLBScYiKypUmgrZ50W4ZqsXaYk76ClrudZnDbce+FuugVxok+jKYGjMu75
2es2ucuik7iuO7QPdPIXfg==
-----END ID SIGNATURE-----"""
expected_key_cert = """\
-----BEGIN SIGNATURE-----
I86FTQ5ZyCZUzm19HVAQWByrrRgUmddoRBfNiCj0iTGN3kdIq9OfuNLhWAqz71xP
8Nn0Vun8Uj3/vBq/odIFpnngL3mKI6OEKcNDr0D5hEV9Yjrxe8msMoaUZT+LHzUW
1q3pzxfMx6EmlSilMhuzSsa4YEbXMZzMqASKANSJHo2fzUkzQOpPw2SlWSTIgyqw
wAOB6QOvFfP3c0NTwxXrYE/iT+r90wZBuzS+v7r9B94alNAkE1KZQKnq2QTTIznP
iF9LWMsZcMHCjoTxszK4jF4MRMN/S4Xl8yQo0/z6FoqBz4RIXzFtJoG/rbXdKfkE
nJK9iEhaZbS1IN0o+uIGtvOm2rQSu9gS8merurr5GDSK3szjesPVJuF00mCNgOx4
hAYPN9N8HAL4zGE/l1UM7BGg3L84A0RMpDxnpXePd9mlHLhl4UV2lrkkf8S9Z6fX
PPc3r7zKlL/jEGHwz+C7kE88HIvkVnKLLn//40b6HxitHSOCkZ1vtp8YyXae6xnU
-----END SIGNATURE-----"""
with open(get_resource('cached-certs'), 'rb') as cert_file:
cert = next(stem.descriptor.parse_file(cert_file, 'dir-key-certificate-3 1.0'))
self.assertEqual(3, cert.version)
self.assertEqual('127.0.0.1', cert.address)
self.assertEqual(7000, cert.dir_port)
self.assertEqual('BCB380A633592C218757BEE11E630511A485658A', cert.fingerprint)
self.assertEqual(expected_identity_key, cert.identity_key)
self.assertEqual(datetime.datetime(2017, 5, 25, 4, 45, 52), cert.published)
self.assertEqual(datetime.datetime(2018, 5, 25, 4, 45, 52), cert.expires)
self.assertEqual(expected_signing_key, cert.signing_key)
self.assertEqual(expected_crosscert, cert.crosscert)
self.assertEqual(expected_key_cert, cert.certification)
self.assertEqual([], cert.get_unrecognized_lines())
def test_metrics_certificate(self):
"""
Checks if consensus documents from Metrics are parsed properly.
"""
expected_identity_key = """-----BEGIN RSA PUBLIC KEY-----
MIIBigKCAYEA7cZXvDRxfjDYtr9/9UsQ852+6cmHMr8VVh8GkLwbq3RzqjkULwQ2
R9mFvG4FnqMcMKXi62rYYA3fZL1afhT804cpvyp/D3dPM8QxW88fafFAgIFP4LiD
0JYjnF8cva5qZ0nzlWnMXLb32IXSvsGSE2FRyAV0YN9a6k967LSgCfUnZ+IKMezW
1vhL9YK4QIfsDowgtVsavg63GzGmA7JvZmn77+/J5wKz11vGr7Wttf8XABbH2taX
O9j/KGBOX2OKhoF3mXfZSmUO2dV9NMwtkJ7zD///Ny6sfApWV6kVP4O9TdG3bAsl
+fHCoCKgF/jAAWzh6VckQTOPzQZaH5aMWfXrDlzFWg17MjonI+bBTD2Ex2pHczzJ
bN7coDMRH2SuOXv8wFf27KdUxZ/GcrXSRGzlRLygxqlripUanjVGN2JvrVQVr0kz
pjNjiZl2z8ZyZ5d4zQuBi074JPGgx62xAstP37v1mPw14sIWfLgY16ewYuS5bCxV
lyS28jsPht9VAgMBAAE=
-----END RSA PUBLIC KEY-----"""
expected_signing_key = """-----BEGIN RSA PUBLIC KEY-----
MIGJAoGBAOeE3Qr1Km97gTgiB3io0EU0fqHW2ESMXVHeQuNDtCWBa0XSCEG6gx4B
ZkkHjfVWqGQ7TmmzjYP9L9uCgtoKfhSvJA2w9NUMtMl8sgZmF4lcGpXXvGY9a566
Bn+3wP0lMhb/I8CPVPX+NWEjgl1noZxo1C59SO/iALGQOpxRYgmbAgMBAAE=
-----END RSA PUBLIC KEY-----"""
expected_key_cert = """-----BEGIN SIGNATURE-----
asvWwaMq34OfHoWUhAwh4+JDOuEUZJVIHQnedOYfQH8asS2QvW3Ma93OhrwVOC6b
FyKmTJmJsl0MJGiC7tcEOlL6knsKE4CsuIw/PEcu2Rnm+R9zWxQuMYiHvGQMoDxl
giOhLLs4LlzAAJlbfbd3hjF4STVAtTwmxYuIjb1Mq/JfAsx/wH3TLXgVZwj32w9s
zUd9KZwwLzFiiHpC+U7zh6+wRsZfo2tlpmcaP1dTSINgVbdzPJ/DOUlx9nwTCBsE
AQpUx2DpAikwrpw0zDqpQvYulcQlNLWFN/y/PkmiK8mIJk0OBMiQA7JgqWamnnk4
PwqaGv483LkBF+25JFGJmnUVve3RMc+s61+2kBcjfUMed4QaHkeCMHqlRqpfQVkk
RY22NXCwrJvSMEwiy7acC8FGysqwHRyE356+Rw6TB43g3Tno9KaHEK7MHXjSHwNs
GM9hAsAMRX9Ogqhq5UjDNqEsvDKuyVeyh7unSZEOip9Zr6K/+7VsVPNb8vfBRBjo
-----END SIGNATURE-----"""
with open(get_resource('metrics_cert'), 'rb') as cert_file:
cert = next(stem.descriptor.parse_file(cert_file))
self.assertEqual(3, cert.version)
self.assertEqual(None, cert.address)
self.assertEqual(None, cert.dir_port)
self.assertEqual('14C131DFC5C6F93646BE72FA1401C02A8DF2E8B4', cert.fingerprint)
self.assertEqual(expected_identity_key, cert.identity_key)
self.assertEqual(datetime.datetime(2008, 5, 9, 21, 13, 26), cert.published)
self.assertEqual(datetime.datetime(2009, 5, 9, 21, 13, 26), cert.expires)
self.assertEqual(expected_signing_key, cert.signing_key)
self.assertEqual(None, cert.crosscert)
self.assertEqual(expected_key_cert, cert.certification)
self.assertEqual([], cert.get_unrecognized_lines())
@test.require.cryptography
def test_descriptor_signing(self):
self.assertRaisesRegexp(NotImplementedError, 'Signing of KeyCertificate not implemented', KeyCertificate.create, sign = True)
def test_unrecognized_line(self):
"""
Includes unrecognized content in the descriptor.
"""
certificate = KeyCertificate.create({'pepperjack': 'is oh so tasty!'})
self.assertEqual(['pepperjack is oh so tasty!'], certificate.get_unrecognized_lines())
def test_first_and_last_lines(self):
"""
Includes a non-mandatory field before the 'dir-key-certificate-version'
line or after the 'dir-key-certification' line.
"""
content = KeyCertificate.content()
for cert_text in (b'dir-address 127.0.0.1:80\n' + content,
content + b'\ndir-address 127.0.0.1:80'):
self.assertRaises(ValueError, KeyCertificate, cert_text, True)
certificate = KeyCertificate(cert_text, False)
self.assertEqual('127.0.0.1', certificate.address)
self.assertEqual(80, certificate.dir_port)
def test_missing_fields(self):
"""
Parse a key certificate where a mandatory field is missing.
"""
mandatory_fields = (
'dir-key-certificate-version',
'fingerprint',
'dir-key-published',
'dir-key-expires',
'dir-identity-key',
'dir-signing-key',
'dir-key-certification',
)
for excluded_field in mandatory_fields:
content = KeyCertificate.content(exclude = (excluded_field,))
self.assertRaises(ValueError, KeyCertificate, content, True)
certificate = KeyCertificate(content, False)
if excluded_field == 'fingerprint':
self.assertEqual(3, certificate.version)
else:
self.assertEqual(40, len(certificate.fingerprint))
def test_blank_lines(self):
"""
Includes blank lines, which should be ignored.
"""
certificate = KeyCertificate.create({'dir-key-published': '2011-11-28 21:51:04\n\n\n'})
self.assertEqual(datetime.datetime(2011, 11, 28, 21, 51, 4), certificate.published)
def test_version(self):
"""
Parses the dir-key-certificate-version field, including trying to handle a
different certificate version with the v3 parser.
"""
certificate = KeyCertificate.create({'dir-key-certificate-version': '3'})
self.assertEqual(3, certificate.version)
content = KeyCertificate.content({'dir-key-certificate-version': '4'})
self.assertRaises(ValueError, KeyCertificate, content, True)
self.assertEqual(4, KeyCertificate(content, False).version)
content = KeyCertificate.content({'dir-key-certificate-version': 'boo'})
self.assertRaises(ValueError, KeyCertificate, content, True)
self.assertEqual(None, KeyCertificate(content, False).version)
def test_dir_address(self):
"""
Parses the dir-address field.
"""
certificate = KeyCertificate.create({'dir-address': '127.0.0.1:80'})
self.assertEqual('127.0.0.1', certificate.address)
self.assertEqual(80, certificate.dir_port)
test_values = (
(''),
(' '),
('127.0.0.1'),
('127.0.0.1:'),
('80'),
(':80'),
('127.0.0.1a:80'),
('127.0.0.1:80a'),
)
for test_value in test_values:
content = KeyCertificate.content({'dir-address': test_value})
self.assertRaises(ValueError, KeyCertificate, content, True)
certificate = KeyCertificate(content, False)
self.assertEqual(None, certificate.address)
self.assertEqual(None, certificate.dir_port)
def test_fingerprint(self):
"""
Parses the fingerprint field.
"""
test_values = (
'',
' ',
'27B6B5996C426270A5C95488AA5BCEB6BCC8695',
'27B6B5996C426270A5C95488AA5BCEB6BCC869568',
)
for test_value in test_values:
content = KeyCertificate.content({'fingerprint': test_value})
self.assertRaises(ValueError, KeyCertificate, content, True)
certificate = KeyCertificate(content, False)
self.assertEqual(None, certificate.fingerprint)
def test_time_fields(self):
"""
Parses the dir-key-published and dir-key-expires fields, which both have
datetime content.
"""
test_values = (
'',
' ',
'2012-12-12',
'2012-12-12 01:01:',
'2012-12-12 01:a1:01',
)
for field, attr in (('dir-key-published', 'published'), ('dir-key-expires', 'expires')):
for test_value in test_values:
content = KeyCertificate.content({field: test_value})
self.assertRaises(ValueError, KeyCertificate, content, True)
certificate = KeyCertificate(content, False)
self.assertEqual(None, getattr(certificate, attr))
def test_key_blocks(self):
"""
Parses the dir-identity-key, dir-signing-key, dir-key-crosscert, and
dir-key-certification fields which all just have signature content.
"""
# the only non-mandatory field that we haven't exercised yet is dir-key-crosscert
certificate = KeyCertificate.create({'dir-key-crosscert': '\n-----BEGIN ID SIGNATURE-----%s-----END ID SIGNATURE-----' % stem.descriptor.CRYPTO_BLOB})
self.assertTrue(stem.descriptor.CRYPTO_BLOB in certificate.crosscert)
test_value = '\n-----BEGIN ID SIGNATURE-----%s-----END UGABUGA SIGNATURE-----' % stem.descriptor.CRYPTO_BLOB
for field, attr in (('dir-identity-key', 'identity_key'),
('dir-signing-key', 'signing_key'),
('dir-key-crosscert', 'crosscert'),
('dir-key-certification', 'certification')):
content = KeyCertificate.content({field: test_value})
self.assertRaises(ValueError, KeyCertificate, content, True)
certificate = KeyCertificate(content, False)
self.assertEqual(None, getattr(certificate, attr))
def test_wrong_block_type(self):
"""
Checks that we validate the type of crypto content we receive.
"""
content = KeyCertificate.content({'dir-identity-key': '\n-----BEGIN MD5SUM-----%s-----END MD5SUM-----' % stem.descriptor.CRYPTO_BLOB})
self.assertRaises(ValueError, KeyCertificate, content, True)
stem-1.6.0/test/unit/descriptor/networkstatus/bridge_document.py 0000664 0001750 0001750 00000004331 13124757510 025773 0 ustar atagar atagar 0000000 0000000 """
Unit tests for the BridgeNetworkStatusDocument of stem.descriptor.networkstatus.
"""
import datetime
import unittest
import stem.descriptor
from stem.descriptor.networkstatus import BridgeNetworkStatusDocument
from test.unit.descriptor import get_resource
DOCUMENT = b"""\
published 2012-06-01 04:07:04
r Unnamed ABSiBVJ42z6w5Z6nAXQUFq8YVVg FI74aFuNJZZQrgln0f+OaocMd0M 2012-05-31 15:57:00 10.97.236.247 443 0
s Valid
w Bandwidth=55
p reject 1-65535
r TolFuin AFn9TveYjdtZEsgh7QsWp3qC5kU 1Sw8RPx2Tq/w+VHL+pZipiJUG5k 2012-05-31 18:12:39 10.99.47.37 80 0
s Fast Guard Running Stable Valid
w Bandwidth=32
p reject 1-65535
"""
class TestBridgeNetworkStatusDocument(unittest.TestCase):
def test_metrics_bridge_consensus(self):
"""
Checks if the bridge documents from Metrics are parsed properly.
"""
consensus_path = get_resource('bridge_network_status')
with open(consensus_path, 'rb') as descriptor_file:
router = next(stem.descriptor.parse_file(descriptor_file))
self.assertEqual('Unnamed', router.nickname)
self.assertEqual('0014A2055278DB3EB0E59EA701741416AF185558', router.fingerprint)
self.assertEqual('148EF8685B8D259650AE0967D1FF8E6A870C7743', router.digest)
self.assertEqual(datetime.datetime(2012, 5, 31, 15, 57, 0), router.published)
self.assertEqual('10.97.236.247', router.address)
self.assertEqual(443, router.or_port)
self.assertEqual(None, router.dir_port)
def test_empty_document(self):
"""
Parse a document without any router status entries.
"""
document = BridgeNetworkStatusDocument(b'published 2012-06-01 04:07:04')
self.assertEqual(datetime.datetime(2012, 6, 1, 4, 7, 4), document.published)
self.assertEqual({}, document.routers)
self.assertEqual([], document.get_unrecognized_lines())
def test_document(self):
"""
Parse a document with router status entries.
"""
document = BridgeNetworkStatusDocument(DOCUMENT)
self.assertEqual(datetime.datetime(2012, 6, 1, 4, 7, 4), document.published)
self.assertEqual(2, len(document.routers))
self.assertEqual(set(['Unnamed', 'TolFuin']), set([desc.nickname for desc in document.routers.values()]))
self.assertEqual([], document.get_unrecognized_lines())
stem-1.6.0/test/unit/descriptor/networkstatus/document_v2.py 0000664 0001750 0001750 00000011671 13125773507 025100 0 ustar atagar atagar 0000000 0000000 """
Unit tests for the NetworkStatusDocumentV2 of stem.descriptor.networkstatus.
"""
import datetime
import unittest
import test.require
from stem.descriptor.networkstatus import NetworkStatusDocumentV2
from test.unit.descriptor import get_resource
class TestNetworkStatusDocument(unittest.TestCase):
def test_consensus_v2(self):
"""
Checks that version 2 consensus documents are properly parsed.
"""
expected_signing_key = """-----BEGIN RSA PUBLIC KEY-----
MIGJAoGBAOcrht/y5rkaahfX7sMe2qnpqoPibsjTSJaDvsUtaNP/Bq0MgNDGOR48
rtwfqTRff275Edkp/UYw3G3vSgKCJr76/bqOHCmkiZrnPV1zxNfrK18gNw2Cxre0
nTA+fD8JQqpPtb8b0SnG9kwy75eS//sRu7TErie2PzGMxrf9LH0LAgMBAAE=
-----END RSA PUBLIC KEY-----"""
expected_signature = """-----BEGIN SIGNATURE-----
2nXCxVje3wzn6HrIFRNMc0nc48AhMVpHZyPwRKGXkuYfTQG55uvwQDaFgJHud4RT
27QhWltau3K1evhnzhKcpbTXwkVv1TBYJSzL6rEeAn8cQ7ZiCyqf4EJCaNcem3d2
TpQQk3nNQF8z6UIvdlvP+DnJV4izWVkQEZgUZgIVM0E=
-----END SIGNATURE-----"""
with open(get_resource('cached-consensus-v2'), 'rb') as descriptor_file:
descriptor_file.readline() # strip header
document = NetworkStatusDocumentV2(descriptor_file.read())
self.assertEqual(2, document.version)
self.assertEqual('18.244.0.114', document.hostname)
self.assertEqual('18.244.0.114', document.address)
self.assertEqual(80, document.dir_port)
self.assertEqual('719BE45DE224B607C53707D0E2143E2D423E74CF', document.fingerprint)
self.assertEqual('arma at mit dot edu', document.contact)
self.assertEqual(expected_signing_key, document.signing_key)
self.assertEqual(67, len(document.client_versions))
self.assertEqual('0.0.9rc2', document.client_versions[0])
self.assertEqual('0.1.1.10-alpha-cvs', document.client_versions[-1])
self.assertEqual(67, len(document.server_versions))
self.assertEqual('0.0.9rc2', document.server_versions[0])
self.assertEqual('0.1.1.10-alpha-cvs', document.server_versions[-1])
self.assertEqual(datetime.datetime(2005, 12, 16, 0, 13, 46), document.published)
self.assertEqual(['Names', 'Versions'], document.options)
self.assertEqual('moria2', document.signing_authority)
self.assertEqual(expected_signature, document.signature)
self.assertEqual([], document.get_unrecognized_lines())
self.assertEqual(3, len(document.routers))
router1 = document.routers['719BE45DE224B607C53707D0E2143E2D423E74CF']
self.assertEqual('moria2', router1.nickname)
self.assertEqual('719BE45DE224B607C53707D0E2143E2D423E74CF', router1.fingerprint)
self.assertEqual('B7F3F0975B87889DD1285FD57A1B1BB617F65432', router1.digest)
self.assertEqual(datetime.datetime(2005, 12, 15, 6, 57, 18), router1.published)
self.assertEqual('18.244.0.114', router1.address)
self.assertEqual(443, router1.or_port)
self.assertEqual(80, router1.dir_port)
self.assertEqual(set(['Authority', 'Fast', 'Named', 'Running', 'Valid', 'V2Dir']), set(router1.flags))
router2 = document.routers['0928BA467056C4A689FEE4EF5D71482B6289C3D5']
self.assertEqual('stnv', router2.nickname)
self.assertEqual('0928BA467056C4A689FEE4EF5D71482B6289C3D5', router2.fingerprint)
self.assertEqual('22D1A7ED4199BDA7ED6C416EECD769C18E1F2A5A', router2.digest)
self.assertEqual(datetime.datetime(2005, 12, 15, 16, 24, 42), router2.published)
self.assertEqual('84.16.236.173', router2.address)
self.assertEqual(9001, router2.or_port)
self.assertEqual(None, router2.dir_port)
self.assertEqual(set(['Named', 'Valid']), set(router2.flags))
router3 = document.routers['09E8582FF0E6F85E2B8E41C0DC0B9C9DC46E6968']
self.assertEqual('nggrplz', router3.nickname)
self.assertEqual('09E8582FF0E6F85E2B8E41C0DC0B9C9DC46E6968', router3.fingerprint)
self.assertEqual('B302C2B01C94F398E3EF38939526B0651F824DD6', router3.digest)
self.assertEqual(datetime.datetime(2005, 12, 15, 23, 25, 50), router3.published)
self.assertEqual('194.109.109.109', router3.address)
self.assertEqual(9001, router3.or_port)
self.assertEqual(None, router3.dir_port)
self.assertEqual(set(['Fast', 'Stable', 'Running', 'Valid']), set(router3.flags))
def test_minimal_document(self):
"""
Parses a minimal v2 network status document.
"""
document = NetworkStatusDocumentV2.create()
self.assertEqual({}, document.routers)
self.assertEqual(2, document.version)
self.assertEqual(80, document.dir_port)
self.assertEqual(40, len(document.fingerprint))
self.assertEqual('arma at mit dot edu', document.contact)
self.assertEqual([], document.client_versions)
self.assertEqual([], document.server_versions)
self.assertEqual([], document.options)
self.assertEqual('moria2', document.signing_authority)
@test.require.cryptography
def test_descriptor_signing(self):
self.assertRaisesRegexp(NotImplementedError, 'Signing of NetworkStatusDocumentV2 not implemented', NetworkStatusDocumentV2.create, sign = True)
stem-1.6.0/test/unit/descriptor/networkstatus/directory_authority.py 0000664 0001750 0001750 00000022476 13126263511 026762 0 ustar atagar atagar 0000000 0000000 """
Unit tests for the DirectoryAuthority of stem.descriptor.networkstatus.
"""
import unittest
import test.require
from stem.descriptor.networkstatus import (
DirectoryAuthority,
KeyCertificate,
)
DIR_SOURCE_LINE = 'turtles 27B6B5996C426270A5C95488AA5BCEB6BCC86956 no.place.com 76.73.17.194 9030 9090'
class TestDirectoryAuthority(unittest.TestCase):
def test_minimal_consensus_authority(self):
"""
Parses a minimal directory authority for a consensus.
"""
authority = DirectoryAuthority.create()
self.assertTrue(authority.nickname.startswith('Unnamed'))
self.assertEqual(40, len(authority.fingerprint))
self.assertEqual('no.place.com', authority.hostname)
self.assertEqual(9030, authority.dir_port)
self.assertEqual(9090, authority.or_port)
self.assertEqual(False, authority.is_legacy)
self.assertEqual('Mike Perry ', authority.contact)
self.assertEqual(40, len(authority.vote_digest))
self.assertEqual(None, authority.legacy_dir_key)
self.assertEqual(None, authority.key_certificate)
self.assertEqual([], authority.get_unrecognized_lines())
def test_minimal_vote_authority(self):
"""
Parses a minimal directory authority for a vote.
"""
authority = DirectoryAuthority.create(is_vote = True)
self.assertTrue(authority.nickname.startswith('Unnamed'))
self.assertEqual(40, len(authority.fingerprint))
self.assertEqual('no.place.com', authority.hostname)
self.assertEqual(9030, authority.dir_port)
self.assertEqual(9090, authority.or_port)
self.assertEqual(False, authority.is_legacy)
self.assertEqual('Mike Perry ', authority.contact)
self.assertEqual(None, authority.vote_digest)
self.assertEqual(None, authority.legacy_dir_key)
self.assertEqual([], authority.get_unrecognized_lines())
@test.require.cryptography
def test_descriptor_signing(self):
self.assertRaisesRegexp(NotImplementedError, 'Signing of DirectoryAuthority not implemented', DirectoryAuthority.create, sign = True)
def test_unrecognized_line(self):
"""
Includes unrecognized content in the descriptor.
"""
authority = DirectoryAuthority.create({'pepperjack': 'is oh so tasty!'})
self.assertEqual(['pepperjack is oh so tasty!'], authority.get_unrecognized_lines())
def test_legacy_authority(self):
"""
Parses an authority using the '-legacy' format.
"""
content = 'dir-source gabelmoo-legacy 81349FC1F2DBA2C2C11B45CB9706637D480AB913 131.188.40.189 131.188.40.189 80 443'
authority = DirectoryAuthority(content, is_vote = False)
self.assertEqual('gabelmoo-legacy', authority.nickname)
self.assertEqual('81349FC1F2DBA2C2C11B45CB9706637D480AB913', authority.fingerprint)
self.assertEqual('131.188.40.189', authority.hostname)
self.assertEqual('131.188.40.189', authority.address)
self.assertEqual(80, authority.dir_port)
self.assertEqual(443, authority.or_port)
self.assertEqual(True, authority.is_legacy)
self.assertEqual(None, authority.contact)
self.assertEqual(None, authority.vote_digest)
self.assertEqual(None, authority.legacy_dir_key)
self.assertEqual(None, authority.key_certificate)
self.assertEqual([], authority.get_unrecognized_lines())
def test_first_line(self):
"""
Includes a non-mandatory field before the 'dir-source' line.
"""
content = b'ho-hum 567\n' + DirectoryAuthority.content()
self.assertRaises(ValueError, DirectoryAuthority, content, True)
authority = DirectoryAuthority(content, False)
self.assertTrue(authority.nickname.startswith('Unnamed'))
self.assertEqual(['ho-hum 567'], authority.get_unrecognized_lines())
def test_missing_fields(self):
"""
Parse an authority where a mandatory field is missing.
"""
for excluded_field in ('dir-source', 'contact'):
content = DirectoryAuthority.content(exclude = (excluded_field,))
self.assertRaises(ValueError, DirectoryAuthority, content, True)
authority = DirectoryAuthority(content, False)
if excluded_field == 'dir-source':
self.assertEqual('Mike Perry ', authority.contact)
else:
self.assertTrue(authority.nickname.startswith('Unnamed'))
def test_blank_lines(self):
"""
Includes blank lines, which should be ignored.
"""
authority = DirectoryAuthority.create({'dir-source': DIR_SOURCE_LINE + '\n\n\n'})
self.assertEqual('Mike Perry ', authority.contact)
def test_duplicate_lines(self):
"""
Duplicates linesin the entry.
"""
lines = DirectoryAuthority.content().split(b'\n')
for index, duplicate_line in enumerate(lines):
content = b'\n'.join(lines[:index] + [duplicate_line] + lines[index:])
self.assertRaises(ValueError, DirectoryAuthority, content, True)
authority = DirectoryAuthority(content, False)
self.assertTrue(authority.nickname.startswith('Unnamed'))
def test_missing_dir_source_field(self):
"""
Excludes fields from the 'dir-source' line.
"""
for missing_value in DIR_SOURCE_LINE.split(' '):
dir_source = DIR_SOURCE_LINE.replace(missing_value, '').replace(' ', ' ')
content = DirectoryAuthority.content({'dir-source': dir_source})
self.assertRaises(ValueError, DirectoryAuthority, content, True)
authority = DirectoryAuthority(content, False)
self.assertEqual(None, authority.nickname)
self.assertEqual(None, authority.fingerprint)
self.assertEqual(None, authority.hostname)
self.assertEqual(None, authority.address)
self.assertEqual(None, authority.dir_port)
self.assertEqual(None, authority.or_port)
def test_malformed_fingerprint(self):
"""
Includes a malformed fingerprint on the 'dir-source' line.
"""
test_values = (
'',
'zzzzz',
'zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz',
)
for value in test_values:
dir_source = DIR_SOURCE_LINE.replace('27B6B5996C426270A5C95488AA5BCEB6BCC86956', value)
content = DirectoryAuthority.content({'dir-source': dir_source})
self.assertRaises(ValueError, DirectoryAuthority, content, True)
authority = DirectoryAuthority(content, False)
self.assertEqual(None, authority.fingerprint)
def test_malformed_address(self):
"""
Includes a malformed ip address on the 'dir-source' line.
"""
test_values = (
'',
'71.35.150.',
'71.35..29',
'71.35.150',
'71.35.150.256',
'[fd9f:2e19:3bcf::02:9970]',
)
for value in test_values:
dir_source = DIR_SOURCE_LINE.replace('76.73.17.194', value)
content = DirectoryAuthority.content({'dir-source': dir_source})
self.assertRaises(ValueError, DirectoryAuthority, content, True)
authority = DirectoryAuthority(content, False)
self.assertEqual(None, authority.address)
def test_malformed_port(self):
"""
Includes a malformed orport or dirport on the 'dir-source' line.
"""
test_values = (
'',
'-1',
'399482',
'blarg',
)
for value in test_values:
for include_or_port in (False, True):
for include_dir_port in (False, True):
if not include_or_port and not include_dir_port:
continue
dir_source = DIR_SOURCE_LINE
if include_or_port:
dir_source = dir_source.replace('9090', value)
if include_dir_port:
dir_source = dir_source.replace('9030', value)
content = DirectoryAuthority.content({'dir-source': dir_source})
self.assertRaises(ValueError, DirectoryAuthority, content, True)
authority = DirectoryAuthority(content, False)
actual_value = authority.or_port if include_or_port else authority.dir_port
self.assertEqual(None, actual_value)
def test_legacy_dir_key(self):
"""
Includes a 'legacy-dir-key' line with both valid and invalid content.
"""
test_value = '65968CCB6BECB5AA88459C5A072624C6995B6B72'
authority = DirectoryAuthority.create({'legacy-dir-key': test_value}, is_vote = True)
self.assertEqual(test_value, authority.legacy_dir_key)
# check that we'll fail if legacy-dir-key appears in a consensus
content = DirectoryAuthority.content({'legacy-dir-key': test_value})
self.assertRaises(ValueError, DirectoryAuthority, content, True)
test_values = (
'',
'zzzzz',
'zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz',
)
for value in test_values:
content = DirectoryAuthority.content({'legacy-dir-key': value})
self.assertRaises(ValueError, DirectoryAuthority, content, True)
authority = DirectoryAuthority(content, False)
self.assertEqual(None, authority.legacy_dir_key)
def test_key_certificate(self):
"""
Includes or exclude a key certificate from the directory entry.
"""
key_cert = KeyCertificate.content()
# include a key cert with a consensus
content = DirectoryAuthority.content() + b'\n' + key_cert
self.assertRaises(ValueError, DirectoryAuthority, content, True)
authority = DirectoryAuthority(content, False)
self.assertTrue(authority.nickname.startswith('Unnamed'))
# exclude key cert from a vote
content = b'\n'.join(DirectoryAuthority.content(is_vote = True).splitlines()[:-5])
self.assertRaises(ValueError, DirectoryAuthority, content, True, True)
authority = DirectoryAuthority(content, False, True)
self.assertTrue(authority.nickname.startswith('Unnamed'))
stem-1.6.0/test/unit/descriptor/networkstatus/document_v3.py 0000664 0001750 0001750 00000150736 13146346524 025105 0 ustar atagar atagar 0000000 0000000 """
Unit tests for the NetworkStatusDocumentV3 of stem.descriptor.networkstatus.
"""
import datetime
import io
import re
import unittest
import stem.descriptor
import stem.version
import test.require
from stem import Flag
from stem.util import str_type
from stem.descriptor import CRYPTO_BLOB
from stem.descriptor.networkstatus import (
HEADER_STATUS_DOCUMENT_FIELDS,
FOOTER_STATUS_DOCUMENT_FIELDS,
DEFAULT_PARAMS,
PackageVersion,
DirectoryAuthority,
NetworkStatusDocumentV3,
_parse_file,
)
from stem.descriptor.router_status_entry import (
RouterStatusEntryV3,
RouterStatusEntryMicroV3,
)
from test.unit.descriptor import get_resource
try:
# added in python 2.7
from collections import OrderedDict
except ImportError:
from stem.util.ordereddict import OrderedDict
BANDWIDTH_WEIGHT_ENTRIES = (
'Wbd', 'Wbe', 'Wbg', 'Wbm',
'Wdb',
'Web', 'Wed', 'Wee', 'Weg', 'Wem',
'Wgb', 'Wgd', 'Wgg', 'Wgm',
'Wmb', 'Wmd', 'Wme', 'Wmg', 'Wmm',
)
class TestNetworkStatusDocument(unittest.TestCase):
def test_metrics_consensus(self):
"""
Checks if consensus documents from Metrics are parsed properly.
"""
consensus_path = get_resource('metrics_consensus')
for specify_type in (True, False):
with open(consensus_path, 'rb') as descriptor_file:
if specify_type:
descriptors = stem.descriptor.parse_file(descriptor_file, 'network-status-consensus-3 1.0')
else:
descriptors = stem.descriptor.parse_file(descriptor_file)
router = next(descriptors)
self.assertEqual('sumkledi', router.nickname)
self.assertEqual('0013D22389CD50D0B784A3E4061CB31E8CE8CEB5', router.fingerprint)
self.assertEqual('F260ABF1297B445E04354E236F4159140FF7768F', router.digest)
self.assertEqual(datetime.datetime(2012, 7, 12, 4, 1, 55), router.published)
self.assertEqual('178.218.213.229', router.address)
self.assertEqual(80, router.or_port)
self.assertEqual(None, router.dir_port)
def test_real_consensus(self):
"""
Checks that version 3 consensus documents from chutney can be properly
parsed.
"""
expected_flags = set(
['Authority', 'Exit', 'Fast', 'Guard', 'HSDir',
'Running', 'Stable', 'V2Dir', 'Valid', 'NoEdConsensus'])
expected_bandwidth_weights = {
'Web': 10000, 'Wdb': 10000, 'Weg': 3333, 'Wee': 10000, 'Wed': 3333,
'Wgd': 3333, 'Wgb': 10000, 'Wgg': 10000, 'Wem': 10000, 'Wbg': 0,
'Wbd': 3333, 'Wbe': 0, 'Wmm': 10000, 'Wmb': 10000, 'Wgm': 10000,
'Wbm': 10000, 'Wmg': 0, 'Wme': 0, 'Wmd': 3333
}
expected_signature = """\
-----BEGIN SIGNATURE-----
Ho0rLojfLHs9cSPFxe6znuGuFU8BvRr6gnH1gULTjUZO0NSQvo5N628KFeAsq+pT
ElieQeV6UfwnYN1U2tomhBYv3+/p1xBxYS5oTDAITxLUYvH4pLYz09VutwFlFFtU
r/satajuOMST0M3wCCBC4Ru5o5FSklwJTPJ/tWRXDCEHv/N5ZUUkpnNdn+7tFSZ9
eFrPxPcQvB05BESo7C4/+ZnZVO/wduObSYu04eWwTEog2gkSWmsztKoXpx1QGrtG
sNL22Ws9ySGDO/ykFFyxkcuyB5A8oPyedR7DrJUfCUYyB8o+XLNwODkCFxlmtFOj
ci356fosgLiM1sVqCUkNdA==
-----END SIGNATURE-----"""
with open(get_resource('cached-consensus'), 'rb') as descriptor_file:
document = stem.descriptor.networkstatus.NetworkStatusDocumentV3(descriptor_file.read(), default_params = False)
self.assertEqual(3, document.version)
self.assertEqual(None, document.version_flavor)
self.assertEqual(True, document.is_consensus)
self.assertEqual(False, document.is_vote)
self.assertEqual(False, document.is_microdescriptor)
self.assertEqual(datetime.datetime(2017, 5, 25, 4, 46, 30), document.valid_after)
self.assertEqual(datetime.datetime(2017, 5, 25, 4, 46, 40), document.fresh_until)
self.assertEqual(datetime.datetime(2017, 5, 25, 4, 46, 50), document.valid_until)
self.assertEqual(2, document.vote_delay)
self.assertEqual(2, document.dist_delay)
self.assertEqual([], document.client_versions)
self.assertEqual([], document.server_versions)
self.assertEqual(expected_flags, set(document.known_flags))
self.assertEqual([], document.packages)
self.assertEqual({}, document.params)
self.assertEqual(26, document.consensus_method)
self.assertEqual(expected_bandwidth_weights, document.bandwidth_weights)
self.assertEqual([], document.consensus_methods)
self.assertEqual(None, document.published)
self.assertEqual([], document.get_unrecognized_lines())
router = document.routers['348225F83C854796B2DD6364E65CB189B33BD696']
self.assertEqual('test002r', router.nickname)
self.assertEqual('348225F83C854796B2DD6364E65CB189B33BD696', router.fingerprint)
self.assertEqual('533429F8413C1B46022AD365655CBEDE1E6DBF44', router.digest)
self.assertEqual(datetime.datetime(2017, 5, 25, 4, 46, 11), router.published)
self.assertEqual('127.0.0.1', router.address)
self.assertEqual(5002, router.or_port)
self.assertEqual(7002, router.dir_port)
self.assertEqual(set(['Exit', 'Fast', 'Running', 'Valid', 'V2Dir', 'Guard', 'HSDir', 'Stable']), set(router.flags))
authority = document.directory_authorities[0]
self.assertEqual(2, len(document.directory_authorities))
self.assertEqual('test001a', authority.nickname)
self.assertEqual('596CD48D61FDA4E868F4AA10FF559917BE3B1A35', authority.fingerprint)
self.assertEqual('127.0.0.1', authority.hostname)
self.assertEqual('127.0.0.1', authority.address)
self.assertEqual(7001, authority.dir_port)
self.assertEqual(5001, authority.or_port)
self.assertEqual('auth1@test.test', authority.contact)
self.assertEqual('2E7177224BBA39B505F7608FF376C07884CF926F', authority.vote_digest)
self.assertEqual(None, authority.legacy_dir_key)
self.assertEqual(None, authority.key_certificate)
signature = document.signatures[0]
self.assertEqual(2, len(document.signatures))
self.assertEqual('sha1', signature.method)
self.assertEqual('596CD48D61FDA4E868F4AA10FF559917BE3B1A35', signature.identity)
self.assertEqual('9FBF54D6A62364320308A615BF4CF6B27B254FAD', signature.key_digest)
self.assertEqual(expected_signature, signature.signature)
def test_metrics_vote(self):
"""
Checks if vote documents from Metrics are parsed properly.
"""
vote_path = get_resource('metrics_vote')
with open(vote_path, 'rb') as descriptor_file:
descriptors = stem.descriptor.parse_file(descriptor_file)
router = next(descriptors)
self.assertEqual('sumkledi', router.nickname)
self.assertEqual('0013D22389CD50D0B784A3E4061CB31E8CE8CEB5', router.fingerprint)
self.assertEqual('0799F806200B005F01E40A9A7F1A21C988AE8FB1', router.digest)
self.assertEqual(datetime.datetime(2012, 7, 11, 4, 22, 53), router.published)
self.assertEqual('178.218.213.229', router.address)
self.assertEqual(80, router.or_port)
self.assertEqual(None, router.dir_port)
def test_vote(self):
"""
Checks that vote documents are properly parsed.
"""
expected_flags = set(
['Authority', 'BadExit', 'Exit', 'Fast', 'Guard', 'HSDir',
'Running', 'Stable', 'V2Dir', 'Valid'])
expected_identity_key = """-----BEGIN RSA PUBLIC KEY-----
MIIBigKCAYEA6uSmsoxj2MiJ3qyZq0qYXlRoG8o82SNqg+22m+t1c7MlQOZWPJYn
XeMcBCt8xrTeIt2ZI+Q/Kt2QJSeD9WZRevTKk/kn5Tg2+xXPogalUU47y5tUohGz
+Q8+CxtRSXpDxBHL2P8rLHvGrI69wbNHGoQkce/7gJy9vw5Ie2qzbyXk1NG6V8Fb
pr6A885vHo6TbhUnolz2Wqt/kN+UorjLkN2H3fV+iGcQFv42SyHYGDLa0WwL3PJJ
r/veu36S3VaHBrfhutfioi+d3d4Ya0bKwiWi5Lm2CHuuRTgMpHLU9vlci8Hunuxq
HsULe2oMsr4VEic7sW5SPC5Obpx6hStHdNv1GxoSEm3/vIuPM8pINpU5ZYAyH9yO
Ef22ZHeiVMMKmpV9TtFyiFqvlI6GpQn3mNbsQqF1y3XCA3Q4vlRAkpgJVUSvTxFP
2bNDobOyVCpCM/rwxU1+RCNY5MFJ/+oktUY+0ydvTen3gFdZdgNqCYjKPLfBNm9m
RGL7jZunMUNvAgMBAAE=
-----END RSA PUBLIC KEY-----"""
expected_signing_key = """-----BEGIN RSA PUBLIC KEY-----
MIGJAoGBAJ5itcJRYNEM3Qf1OVWLRkwjqf84oXPc2ZusaJ5zOe7TVvBMra9GNyc0
NM9y6zVkHCAePAjr4KbW/8P1olA6FUE2LV9bozaU1jFf6K8B2OELKs5FUEW+n+ic
GM0x6MhngyXonWOcKt5Gj+mAu5lrno9tpNbPkz2Utr/Pi0nsDhWlAgMBAAE=
-----END RSA PUBLIC KEY-----"""
expected_key_crosscert = """-----BEGIN ID SIGNATURE-----
RHYImGTwg36wmEdAn7qaRg2sAfql7ZCtPIL/O3lU5OIdXXp0tNn/K00Bamqohjk+
Tz4FKsKXGDlbGv67PQcZPOK6NF0GRkNh4pk89prrDO4XwtEn7rkHHdBH6/qQ7IRG
GdDZHtZ1a69oFZvPWD3hUaB50xeIe7GoKdKIfdNNJ+8=
-----END ID SIGNATURE-----"""
expected_key_certification = """-----BEGIN SIGNATURE-----
fasWOGyUZ3iMCYpDfJ+0JcMiTH25sXPWzvlHorEOyOMbaMqRYpZU4GHzt1jLgdl6
AAoR6KdamsLg5VE8xzst48a4UFuzHFlklZ5O8om2rcvDd5DhSnWWYZnYJecqB+bo
dNisPmaIVSAWb29U8BpNRj4GMC9KAgGYUj8aE/KtutAeEekFfFEHTfWZ2fFp4j3m
9rY8FWraqyiF+Emq1T8pAAgMQ+79R3oZxq0TXS42Z4Anhms735ccauKhI3pDKjbl
tD5vAzIHOyjAOXj7a6jY/GrnaBNuJ4qe/4Hf9UmzK/jKKwG95BPJtPTT4LoFwEB0
KG2OUeQUNoCck4nDpsZwFqPlrWCHcHfTV2iDYFV1HQWDTtZz/qf+GtB8NXsq+I1w
brADmvReM2BD6p/13h0QURCI5hq7ZYlIKcKrBa0jn1d9cduULl7vgKsRCJDls/ID
emBZ6pUxMpBmV0v+PrA3v9w4DlE7GHAq61FF/zju2kpqj6MInbEvI/E+e438sWsL
-----END SIGNATURE-----"""
expected_signature = """-----BEGIN SIGNATURE-----
fskXN84wB3mXfo+yKGSt0AcDaaPuU3NwMR3ROxWgLN0KjAaVi2eV9PkPCsQkcgw3
JZ/1HL9sHyZfo6bwaC6YSM9PNiiY6L7rnGpS7UkHiFI+M96VCMorvjm5YPs3FioJ
DnN5aFtYKiTc19qIC7Nmo+afPdDEf0MlJvEOP5EWl3w=
-----END SIGNATURE-----"""
with open(get_resource('unparseable/vote'), 'rb') as descriptor_file:
document = stem.descriptor.networkstatus.NetworkStatusDocumentV3(descriptor_file.read(), default_params = False)
self.assertEqual(3, document.version)
self.assertEqual(None, document.version_flavor)
self.assertEqual(False, document.is_consensus)
self.assertEqual(True, document.is_vote)
self.assertEqual(False, document.is_microdescriptor)
self.assertEqual(datetime.datetime(2012, 7, 12, 0, 0, 0), document.valid_after)
self.assertEqual(datetime.datetime(2012, 7, 12, 1, 0, 0), document.fresh_until)
self.assertEqual(datetime.datetime(2012, 7, 12, 3, 0, 0), document.valid_until)
self.assertEqual(300, document.vote_delay)
self.assertEqual(300, document.dist_delay)
self.assertEqual([], document.client_versions)
self.assertEqual([], document.server_versions)
self.assertEqual(expected_flags, set(document.known_flags))
self.assertEqual([], document.packages)
self.assertEqual({'CircuitPriorityHalflifeMsec': 30000, 'bwauthpid': 1}, document.params)
self.assertEqual(None, document.consensus_method)
self.assertEqual({}, document.bandwidth_weights)
self.assertEqual(list(range(1, 13)), document.consensus_methods)
self.assertEqual(datetime.datetime(2012, 7, 11, 23, 50, 1), document.published)
self.assertEqual([], document.get_unrecognized_lines())
router = document.routers['0013D22389CD50D0B784A3E4061CB31E8CE8CEB5']
self.assertEqual('sumkledi', router.nickname)
self.assertEqual('0013D22389CD50D0B784A3E4061CB31E8CE8CEB5', router.fingerprint)
self.assertEqual('0799F806200B005F01E40A9A7F1A21C988AE8FB1', router.digest)
self.assertEqual(datetime.datetime(2012, 7, 11, 4, 22, 53), router.published)
self.assertEqual('178.218.213.229', router.address)
self.assertEqual(80, router.or_port)
self.assertEqual(None, router.dir_port)
authority = document.directory_authorities[0]
self.assertEqual(1, len(document.directory_authorities))
self.assertEqual('turtles', authority.nickname)
self.assertEqual('27B6B5996C426270A5C95488AA5BCEB6BCC86956', authority.fingerprint)
self.assertEqual('76.73.17.194', authority.hostname)
self.assertEqual('76.73.17.194', authority.address)
self.assertEqual(9030, authority.dir_port)
self.assertEqual(9090, authority.or_port)
self.assertEqual('Mike Perry ', authority.contact)
self.assertEqual(None, authority.vote_digest)
self.assertEqual(None, authority.legacy_dir_key)
certificate = authority.key_certificate
self.assertEqual(3, certificate.version)
self.assertEqual(None, certificate.address)
self.assertEqual(None, certificate.dir_port)
self.assertEqual('27B6B5996C426270A5C95488AA5BCEB6BCC86956', certificate.fingerprint)
self.assertEqual(expected_identity_key, certificate.identity_key)
self.assertEqual(datetime.datetime(2011, 11, 28, 21, 51, 4), certificate.published)
self.assertEqual(datetime.datetime(2012, 11, 28, 21, 51, 4), certificate.expires)
self.assertEqual(expected_signing_key, certificate.signing_key)
self.assertEqual(expected_key_crosscert, certificate.crosscert)
self.assertEqual(expected_key_certification, certificate.certification)
signature = document.signatures[0]
self.assertEqual(1, len(document.signatures))
self.assertEqual('sha1', signature.method)
self.assertEqual('27B6B5996C426270A5C95488AA5BCEB6BCC86956', signature.identity)
self.assertEqual('D5C30C15BB3F1DA27669C2D88439939E8F418FCF', signature.key_digest)
self.assertEqual(expected_signature, signature.signature)
def test_minimal_consensus(self):
"""
Parses a minimal network status document.
"""
document = NetworkStatusDocumentV3.create()
expected_known_flags = [
Flag.AUTHORITY, Flag.BADEXIT, Flag.EXIT,
Flag.FAST, Flag.GUARD, Flag.HSDIR, Flag.NAMED, Flag.RUNNING,
Flag.STABLE, Flag.UNNAMED, Flag.V2DIR, Flag.VALID]
self.assertEqual({}, document.routers)
self.assertEqual(3, document.version)
self.assertEqual(None, document.version_flavor)
self.assertEqual(True, document.is_consensus)
self.assertEqual(False, document.is_vote)
self.assertEqual(False, document.is_microdescriptor)
self.assertEqual(9, document.consensus_method)
self.assertEqual([], document.consensus_methods)
self.assertEqual(None, document.published)
self.assertEqual(300, document.vote_delay)
self.assertEqual(300, document.dist_delay)
self.assertEqual([], document.client_versions)
self.assertEqual([], document.server_versions)
self.assertEqual(expected_known_flags, document.known_flags)
self.assertEqual([], document.packages)
self.assertEqual({}, document.flag_thresholds)
self.assertEqual(False, document.is_shared_randomness_participate)
self.assertEqual([], document.shared_randomness_commitments)
self.assertEqual(None, document.shared_randomness_previous_reveal_count)
self.assertEqual(None, document.shared_randomness_previous_value)
self.assertEqual(None, document.shared_randomness_current_reveal_count)
self.assertEqual(None, document.shared_randomness_current_value)
self.assertEqual({}, document.recommended_client_protocols)
self.assertEqual({}, document.recommended_relay_protocols)
self.assertEqual({}, document.required_client_protocols)
self.assertEqual({}, document.required_relay_protocols)
self.assertEqual(DEFAULT_PARAMS, document.params)
self.assertEqual((), document.directory_authorities)
self.assertEqual({}, document.bandwidth_weights)
self.assertEqual([], document.get_unrecognized_lines())
def test_minimal_vote(self):
"""
Parses a minimal network status document.
"""
document = NetworkStatusDocumentV3.create({'vote-status': 'vote'})
expected_known_flags = [
Flag.AUTHORITY, Flag.BADEXIT, Flag.EXIT,
Flag.FAST, Flag.GUARD, Flag.HSDIR, Flag.NAMED, Flag.RUNNING,
Flag.STABLE, Flag.UNNAMED, Flag.V2DIR, Flag.VALID]
self.assertEqual({}, document.routers)
self.assertEqual(3, document.version)
self.assertEqual(False, document.is_consensus)
self.assertEqual(True, document.is_vote)
self.assertEqual(None, document.consensus_method)
self.assertEqual([1, 9], document.consensus_methods)
self.assertEqual(300, document.vote_delay)
self.assertEqual(300, document.dist_delay)
self.assertEqual([], document.client_versions)
self.assertEqual([], document.server_versions)
self.assertEqual(expected_known_flags, document.known_flags)
self.assertEqual([], document.packages)
self.assertEqual({}, document.flag_thresholds)
self.assertEqual(False, document.is_shared_randomness_participate)
self.assertEqual([], document.shared_randomness_commitments)
self.assertEqual(None, document.shared_randomness_previous_reveal_count)
self.assertEqual(None, document.shared_randomness_previous_value)
self.assertEqual(None, document.shared_randomness_current_reveal_count)
self.assertEqual(None, document.shared_randomness_current_value)
self.assertEqual(DEFAULT_PARAMS, document.params)
self.assertEqual({}, document.bandwidth_weights)
self.assertEqual([], document.get_unrecognized_lines())
@test.require.cryptography
def test_descriptor_signing(self):
self.assertRaisesRegexp(NotImplementedError, 'Signing of NetworkStatusDocumentV3 not implemented', NetworkStatusDocumentV3.create, sign = True)
def test_examples(self):
"""
Run something similar to the examples in the header pydocs.
"""
# makes a consensus with a couple routers, both with the same nickname
entry1 = RouterStatusEntryV3.create({'s': 'Fast'})
entry2 = RouterStatusEntryV3.create({'s': 'Valid'})
content = NetworkStatusDocumentV3.content(routers = (entry1, entry2))
# first example: parsing via the NetworkStatusDocumentV3 constructor
consensus_file = io.BytesIO(content)
consensus = NetworkStatusDocumentV3(consensus_file.read())
consensus_file.close()
for router in consensus.routers.values():
self.assertTrue(router.nickname.startswith('Unnamed'))
# second example: using stem.descriptor.parse_file
with io.BytesIO(content) as consensus_file:
for router in stem.descriptor.parse_file(consensus_file, 'network-status-consensus-3 1.0'):
self.assertTrue(router.nickname.startswith('Unnamed'))
@test.require.cryptography
def test_signature_validation(self):
"""
Check that we can validate the consensus with its certificates.
"""
with open(get_resource('cached-consensus'), 'rb') as descriptor_file:
consensus_content = descriptor_file.read()
with open(get_resource('cached-certs'), 'rb') as cert_file:
certs = list(stem.descriptor.parse_file(cert_file, 'dir-key-certificate-3 1.0'))
consensus = stem.descriptor.networkstatus.NetworkStatusDocumentV3(consensus_content)
consensus.validate_signatures(certs)
# change a relay's nickname in the consensus so it's no longer validly signed
consensus = stem.descriptor.networkstatus.NetworkStatusDocumentV3(consensus_content.replace(b'test002r', b'different_nickname'))
self.assertRaisesRegexp(ValueError, 'Network Status Document has 0 valid signatures out of 2 total, needed 1', consensus.validate_signatures, certs)
def test_handlers(self):
"""
Try parsing a document with DocumentHandler.DOCUMENT and
DocumentHandler.BARE_DOCUMENT.
"""
# Simple sanity check that they provide the right type, and that the
# document includes or excludes the router status entries as appropriate.
entry1 = RouterStatusEntryV3.create({'s': 'Fast'})
entry2 = RouterStatusEntryV3.create({
'r': 'Nightfae AWt0XNId/OU2xX5xs5hVtDc5Mes 6873oEfM7fFIbxYtwllw9GPDwkA 2013-02-20 11:12:27 85.177.66.233 9001 9030',
's': 'Valid',
})
content = NetworkStatusDocumentV3.content(routers = (entry1, entry2))
descriptors = list(stem.descriptor.parse_file(io.BytesIO(content), 'network-status-consensus-3 1.0', document_handler = stem.descriptor.DocumentHandler.DOCUMENT))
self.assertEqual(1, len(descriptors))
self.assertTrue(isinstance(descriptors[0], NetworkStatusDocumentV3))
self.assertEqual(2, len(descriptors[0].routers))
descriptors = list(stem.descriptor.parse_file(io.BytesIO(content), 'network-status-consensus-3 1.0', document_handler = stem.descriptor.DocumentHandler.BARE_DOCUMENT))
self.assertEqual(1, len(descriptors))
self.assertTrue(isinstance(descriptors[0], NetworkStatusDocumentV3))
self.assertEqual(0, len(descriptors[0].routers))
def test_parse_file(self):
"""
Try parsing a document via the _parse_file() function.
"""
entry1 = RouterStatusEntryV3.create({'s': 'Fast'})
entry2 = RouterStatusEntryV3.create({'s': 'Valid'})
content = NetworkStatusDocumentV3.content(routers = (entry1, entry2))
# the document that the entries refer to should actually be the minimal
# descriptor (ie, without the entries)
descriptor_file = io.BytesIO(content)
entries = list(_parse_file(descriptor_file))
self.assertEqual(entry1, entries[0])
self.assertEqual(entry2, entries[1])
def test_missing_fields(self):
"""
Excludes mandatory fields from both a vote and consensus document.
"""
for is_consensus in (True, False):
attr = {'vote-status': 'consensus'} if is_consensus else {'vote-status': 'vote'}
is_vote = not is_consensus
for entries in (HEADER_STATUS_DOCUMENT_FIELDS, FOOTER_STATUS_DOCUMENT_FIELDS):
for field, in_votes, in_consensus, is_mandatory in entries:
if is_mandatory and field != 'vote-status' and ((is_consensus and in_consensus) or (is_vote and in_votes)):
content = NetworkStatusDocumentV3.content(attr, exclude = (field,))
self.assertRaises(ValueError, NetworkStatusDocumentV3, content, True)
NetworkStatusDocumentV3(content, False) # constructs without validation
def test_unrecognized_line(self):
"""
Includes unrecognized content in the document.
"""
document = NetworkStatusDocumentV3.create({'pepperjack': 'is oh so tasty!'})
self.assertEqual(['pepperjack is oh so tasty!'], document.get_unrecognized_lines())
def test_duplicate_fields(self):
"""
Almost all fields can only appear once. Checking that duplicates cause
validation errors.
"""
for is_consensus in (True, False):
attr = {'vote-status': 'consensus'} if is_consensus else {'vote-status': 'vote'}
lines = NetworkStatusDocumentV3.content(attr).split(b'\n')
for index, line in enumerate(lines):
if not is_consensus and lines[index].startswith(b'dir-source'):
break
# Stop when we hit the 'directory-signature' for a couple reasons...
# - that is the one field that can validly appear multiple times
# - after it is a crypto blob, which won't trigger this kind of
# validation failure
test_lines = list(lines)
if line.startswith(b'directory-signature '):
break
# duplicates the line
test_lines.insert(index, line)
content = b'\n'.join(test_lines)
self.assertRaises(ValueError, NetworkStatusDocumentV3, content, True)
NetworkStatusDocumentV3(content, False) # constructs without validation
def test_version(self):
"""
Parses the network-status-version field, including trying to handle a
different document version with the v3 parser.
"""
document = NetworkStatusDocumentV3.create({'network-status-version': '3'})
self.assertEqual(3, document.version)
self.assertEqual(None, document.version_flavor)
self.assertEqual(False, document.is_microdescriptor)
document = NetworkStatusDocumentV3.create({'network-status-version': '3 microdesc'})
self.assertEqual(3, document.version)
self.assertEqual('microdesc', document.version_flavor)
self.assertEqual(True, document.is_microdescriptor)
content = NetworkStatusDocumentV3.content({'network-status-version': '4'})
self.assertRaises(ValueError, NetworkStatusDocumentV3, content, True)
document = NetworkStatusDocumentV3(content, False)
self.assertEqual(4, document.version)
self.assertEqual(None, document.version_flavor)
self.assertEqual(False, document.is_microdescriptor)
def test_vote_status(self):
"""
Parses the vote-status field.
"""
document = NetworkStatusDocumentV3.create({'vote-status': 'vote'})
self.assertEqual(False, document.is_consensus)
self.assertEqual(True, document.is_vote)
content = NetworkStatusDocumentV3.content({'vote-status': 'consensus'})
document = NetworkStatusDocumentV3(content)
self.assertEqual(True, document.is_consensus)
self.assertEqual(False, document.is_vote)
test_values = (
'',
' ',
'votee',
)
for test_value in test_values:
content = NetworkStatusDocumentV3.content({'vote-status': test_value})
self.assertRaises(ValueError, NetworkStatusDocumentV3, content, True)
document = NetworkStatusDocumentV3(content, False)
self.assertEqual(True, document.is_consensus)
self.assertEqual(False, document.is_vote)
def test_consensus_methods(self):
"""
Parses the consensus-methods field.
"""
document = NetworkStatusDocumentV3.create({'vote-status': 'vote', 'consensus-methods': '12 3 1 780'})
self.assertEqual([12, 3, 1, 780], document.consensus_methods)
# check that we default to including consensus-method 1
content = NetworkStatusDocumentV3.content({'vote-status': 'vote'}, ('consensus-methods',))
document = NetworkStatusDocumentV3(content, False)
self.assertEqual([1], document.consensus_methods)
self.assertEqual(None, document.consensus_method)
test_values = (
(''),
(' '),
('1 2 3 a 5'),
('1 2 3 4.0 5'),
('2 3 4'), # spec says version one must be included
)
for test_value in test_values:
content = NetworkStatusDocumentV3.content({'vote-status': 'vote', 'consensus-methods': test_value})
self.assertRaises(ValueError, NetworkStatusDocumentV3, content, True)
expected_value = [2, 3, 4] if test_value == '2 3 4' else [1]
document = NetworkStatusDocumentV3(content, False)
self.assertEqual(expected_value, document.consensus_methods)
def test_consensus_method(self):
"""
Parses the consensus-method field.
"""
document = NetworkStatusDocumentV3.create({'consensus-method': '12'})
self.assertEqual(12, document.consensus_method)
# check that we default to being consensus-method 1
content = NetworkStatusDocumentV3.content(exclude = ('consensus-method',))
document = NetworkStatusDocumentV3(content, False)
self.assertEqual(1, document.consensus_method)
self.assertEqual([], document.consensus_methods)
test_values = (
'',
' ',
'a',
'1 2',
'2.0',
)
for test_value in test_values:
content = NetworkStatusDocumentV3.content({'consensus-method': test_value})
self.assertRaises(ValueError, NetworkStatusDocumentV3, content, True)
document = NetworkStatusDocumentV3(content, False)
self.assertEqual(1, document.consensus_method)
def test_time_fields(self):
"""
Parses invalid published, valid-after, fresh-until, and valid-until fields.
All are simply datetime values.
"""
expected = datetime.datetime(2012, 9, 2, 22, 0, 0)
test_value = '2012-09-02 22:00:00'
document = NetworkStatusDocumentV3.create({
'vote-status': 'vote',
'published': test_value,
'valid-after': test_value,
'fresh-until': test_value,
'valid-until': test_value,
})
self.assertEqual(expected, document.published)
self.assertEqual(expected, document.valid_after)
self.assertEqual(expected, document.fresh_until)
self.assertEqual(expected, document.valid_until)
test_values = (
'',
' ',
'2012-12-12',
'2012-12-12 01:01:',
'2012-12-12 01:a1:01',
)
for test_value in test_values:
content = NetworkStatusDocumentV3.content({'vote-status': 'vote', 'published': test_value})
self.assertRaises(ValueError, NetworkStatusDocumentV3, content, True)
document = NetworkStatusDocumentV3(content, False)
self.assertEqual(None, document.published)
def test_voting_delay(self):
"""
Parses the voting-delay field.
"""
document = NetworkStatusDocumentV3.create({'voting-delay': '12 345'})
self.assertEqual(12, document.vote_delay)
self.assertEqual(345, document.dist_delay)
test_values = (
'',
' ',
'1 a',
'1\t2',
'1 2.0',
)
for test_value in test_values:
content = NetworkStatusDocumentV3.content({'voting-delay': test_value})
self.assertRaises(ValueError, NetworkStatusDocumentV3, content, True)
document = NetworkStatusDocumentV3(content, False)
self.assertEqual(None, document.vote_delay)
self.assertEqual(None, document.dist_delay)
def test_version_lists(self):
"""
Parses client-versions and server-versions fields. Both are comma separated
lists of tor versions.
"""
expected = [stem.version.Version('1.2.3.4'), stem.version.Version('56.789.12.34-alpha')]
test_value = '1.2.3.4,56.789.12.34-alpha'
document = NetworkStatusDocumentV3.create({'client-versions': test_value, 'server-versions': test_value})
self.assertEqual(expected, document.client_versions)
self.assertEqual(expected, document.server_versions)
test_values = (
(''),
(' '),
('1.2.3.4,'),
('1.2.3.4,1.2.3.a'),
)
for field in ('client-versions', 'server-versions'):
attr = field.replace('-', '_')
for test_value in test_values:
content = NetworkStatusDocumentV3.content({field: test_value})
self.assertRaises(ValueError, NetworkStatusDocumentV3, content, True)
document = NetworkStatusDocumentV3(content, False)
self.assertEqual([], getattr(document, attr))
def test_packages(self):
"""
Parse the package line. These can appear multiple times, and have any
number of digests.
"""
test_values = (
(['Stem 1.3.0 https://stem.torproject.org/'],
[PackageVersion('Stem', '1.3.0', 'https://stem.torproject.org/', {})]),
(['Stem 1.3.0 https://stem.torproject.org/ sha1=5d676c8124b4be1f52ddc8e15ca143cad211eeb4 md5=600ad5e2fc4caf585c1bdaaa532b7e82'],
[PackageVersion('Stem', '1.3.0', 'https://stem.torproject.org/', {'sha1': '5d676c8124b4be1f52ddc8e15ca143cad211eeb4', 'md5': '600ad5e2fc4caf585c1bdaaa532b7e82'})]),
(['Stem 1.3.0 https://stem.torproject.org/', 'Txtorcon 0.13.0 https://github.com/meejah/txtorcon'],
[PackageVersion('Stem', '1.3.0', 'https://stem.torproject.org/', {}),
PackageVersion('Txtorcon', '0.13.0', 'https://github.com/meejah/txtorcon', {})]),
)
for test_value, expected_value in test_values:
document = NetworkStatusDocumentV3.create({'package': '\npackage '.join(test_value)})
self.assertEqual(expected_value, document.packages)
test_values = (
'',
' ',
'Stem',
'Stem 1.3.0',
'Stem 1.3.0 https://stem.torproject.org/ keyword_field',
'Stem 1.3.0 https://stem.torproject.org/ keyword_field key=value',
'Stem 1.3.0 https://stem.torproject.org/ key=value keyword_field',
)
for test_value in test_values:
content = NetworkStatusDocumentV3.content({'package': test_value})
self.assertRaises(ValueError, NetworkStatusDocumentV3, content, True)
document = NetworkStatusDocumentV3(content, False)
self.assertEqual([], document.packages)
def test_known_flags(self):
"""
Parses some known-flag entries. Just exercising the field, there's not much
to test here.
"""
test_values = (
('', []),
(' ', []),
('BadExit', [Flag.BADEXIT]),
('BadExit ', [Flag.BADEXIT]),
('BadExit ', [Flag.BADEXIT]),
('BadExit Fast', [Flag.BADEXIT, Flag.FAST]),
('BadExit Unrecognized Fast', [Flag.BADEXIT, 'Unrecognized', Flag.FAST]),
)
for test_value, expected_value in test_values:
document = NetworkStatusDocumentV3.create({'known-flags': test_value})
self.assertEqual(expected_value, document.known_flags)
def test_flag_thresholds(self):
"""
Parses the flag-thresholds entry.
"""
test_values = (
('', {}),
('fast-speed=40960', {str_type('fast-speed'): 40960}), # numeric value
('guard-wfu=94.669%', {str_type('guard-wfu'): 0.94669}), # percentage value
('guard-wfu=94.669% guard-tk=691200', {str_type('guard-wfu'): 0.94669, str_type('guard-tk'): 691200}), # multiple values
('stable-uptime=0 stable-mtbf=0 fast-speed=0 guard-wfu=0.000% guard-tk=0 guard-bw-inc-exits=0 guard-bw-exc-exits=0 enough-mtbf=1 ignoring-advertised-bws=0', {
str_type('stable-uptime'): 0,
str_type('stable-mtbf'): 0,
str_type('fast-speed'): 0,
str_type('guard-wfu'): 0.0,
str_type('guard-tk'): 0,
str_type('guard-bw-inc-exits'): 0,
str_type('guard-bw-exc-exits'): 0,
str_type('enough-mtbf'): 1,
str_type('ignoring-advertised-bws'): 0,
}),
)
for test_value, expected_value in test_values:
document = NetworkStatusDocumentV3.create({'vote-status': 'vote', 'flag-thresholds': test_value})
self.assertEqual(expected_value, document.flag_thresholds)
# parses a full entry found in an actual vote
full_line = 'stable-uptime=693369 stable-mtbf=153249 fast-speed=40960 guard-wfu=94.669% guard-tk=691200 guard-bw-inc-exits=174080 guard-bw-exc-exits=184320 enough-mtbf=1'
expected_value = {
str_type('stable-uptime'): 693369,
str_type('stable-mtbf'): 153249,
str_type('fast-speed'): 40960,
str_type('guard-wfu'): 0.94669,
str_type('guard-tk'): 691200,
str_type('guard-bw-inc-exits'): 174080,
str_type('guard-bw-exc-exits'): 184320,
str_type('enough-mtbf'): 1,
}
document = NetworkStatusDocumentV3.create({'vote-status': 'vote', 'flag-thresholds': full_line})
self.assertEqual(expected_value, document.flag_thresholds)
test_values = (
'stable-uptime 693369', # not a key=value mapping
'stable-uptime=a693369', # non-numeric value
'guard-wfu=94.669%%', # double quote
'stable-uptime=693369\tstable-mtbf=153249', # non-space divider
)
for test_value in test_values:
content = NetworkStatusDocumentV3.content({'vote-status': 'vote', 'flag-thresholds': test_value})
self.assertRaises(ValueError, NetworkStatusDocumentV3, content, True)
document = NetworkStatusDocumentV3(content, False)
self.assertEqual({}, document.flag_thresholds)
def test_parameters(self):
"""
Parses the parameters attributes.
"""
document = NetworkStatusDocumentV3.create(OrderedDict([
('vote-status', 'vote'),
('recommended-client-protocols', 'HSDir=1 HSIntro=3'),
('recommended-relay-protocols', 'Cons=1 Desc=1'),
('required-client-protocols', 'HSRend=1 Link=1-4 LinkAuth=1 Microdesc=1'),
('required-relay-protocols', 'DirCache=1'),
]))
self.assertEqual(2, len(document.recommended_client_protocols))
self.assertEqual(2, len(document.recommended_relay_protocols))
self.assertEqual(4, len(document.required_client_protocols))
self.assertEqual(1, len(document.required_relay_protocols))
def test_params(self):
"""
General testing for the 'params' line, exercising the happy cases.
"""
document = NetworkStatusDocumentV3.create({'params': 'CircuitPriorityHalflifeMsec=30000 bwauthpid=1 unrecognized=-122'})
self.assertEqual(30000, document.params['CircuitPriorityHalflifeMsec'])
self.assertEqual(1, document.params['bwauthpid'])
self.assertEqual(-122, document.params['unrecognized'])
# empty params line
content = NetworkStatusDocumentV3.content({'params': ''})
document = NetworkStatusDocumentV3(content, default_params = True)
self.assertEqual(DEFAULT_PARAMS, document.params)
content = NetworkStatusDocumentV3.content({'params': ''})
document = NetworkStatusDocumentV3(content, default_params = False)
self.assertEqual({}, document.params)
def test_params_malformed(self):
"""
Parses a 'params' line with malformed content.
"""
test_values = (
'foo=',
'foo=abc',
'foo=+123',
'foo=12\tbar=12',
)
for test_value in test_values:
content = NetworkStatusDocumentV3.content({'params': test_value})
self.assertRaises(ValueError, NetworkStatusDocumentV3, content, True)
document = NetworkStatusDocumentV3(content, False)
self.assertEqual(DEFAULT_PARAMS, document.params)
def test_params_range(self):
"""
Check both the furthest valid 'params' values and values that are out of
bounds.
"""
test_values = (
('foo=2147483648', {'foo': 2147483648}, False),
('foo=-2147483649', {'foo': -2147483649}, False),
('foo=2147483647', {'foo': 2147483647}, True),
('foo=-2147483648', {'foo': -2147483648}, True),
# param with special range constraints
('circwindow=99', {'circwindow': 99}, False),
('circwindow=1001', {'circwindow': 1001}, False),
('circwindow=500', {'circwindow': 500}, True),
# param that relies on another param for its constraints
('cbtclosequantile=79 cbtquantile=80', {'cbtclosequantile': 79, 'cbtquantile': 80}, False),
('cbtclosequantile=80 cbtquantile=80', {'cbtclosequantile': 80, 'cbtquantile': 80}, True),
)
for test_value, expected_value, is_ok in test_values:
content = NetworkStatusDocumentV3.content({'params': test_value})
if is_ok:
document = NetworkStatusDocumentV3(content, default_params = False)
else:
self.assertRaises(ValueError, NetworkStatusDocumentV3, content, True)
document = NetworkStatusDocumentV3(content, False, default_params = False)
self.assertEqual(expected_value, document.params)
def test_params_misordered(self):
"""
Check that the 'params' line is rejected if out of order.
"""
content = NetworkStatusDocumentV3.content({'params': 'unrecognized=-122 bwauthpid=1'})
self.assertRaises(ValueError, NetworkStatusDocumentV3, content, True)
document = NetworkStatusDocumentV3(content, False, default_params = False)
self.assertEqual({}, document.params)
def test_footer_consensus_method_requirement(self):
"""
Check that validation will notice if a footer appears before it was
introduced.
"""
content = NetworkStatusDocumentV3.content({'consensus-method': '8'})
self.assertRaises(ValueError, NetworkStatusDocumentV3, content, True)
document = NetworkStatusDocumentV3(content, False)
self.assertEqual([], document.get_unrecognized_lines())
# excludes a footer from a version that shouldn't have it
document = NetworkStatusDocumentV3.create({'consensus-method': '8'}, ('directory-footer', 'directory-signature'))
self.assertEqual([], document.signatures)
self.assertEqual([], document.get_unrecognized_lines())
# Prior to conensus method 9 votes can still have a signature in their
# footer...
#
# https://trac.torproject.org/7932
document = NetworkStatusDocumentV3.create(
{
'vote-status': 'vote',
'consensus-methods': '1 8',
},
exclude = ('directory-footer',),
authorities = (DirectoryAuthority.create(is_vote = True),)
)
self.assertEqual([], document.get_unrecognized_lines())
def test_footer_with_value(self):
"""
Tries to parse a descriptor with content on the 'directory-footer' line.
"""
content = NetworkStatusDocumentV3.content({'directory-footer': 'blarg'})
self.assertRaises(ValueError, NetworkStatusDocumentV3, content, True)
document = NetworkStatusDocumentV3(content, False)
self.assertEqual([], document.get_unrecognized_lines())
def test_bandwidth_wights_ok(self):
"""
Parses a properly formed 'bandwidth-wights' line. Negative bandwidth
weights might or might not be valid. The spec doesn't say, so making sure
that we accept them.
"""
weight_entries, expected = [], {}
for index, key in enumerate(BANDWIDTH_WEIGHT_ENTRIES):
weight_entries.append('%s=%i' % (key, index - 5))
expected[key] = index - 5
document = NetworkStatusDocumentV3.create({'bandwidth-weights': ' '.join(weight_entries)})
self.assertEqual(expected, document.bandwidth_weights)
def test_bandwidth_wights_malformed(self):
"""
Provides malformed content in the 'bandwidth-wights' line.
"""
test_values = (
'Wbe',
'Wbe=',
'Wbe=a',
'Wbe=+7',
)
base_weight_entry = ' '.join(['%s=5' % e for e in BANDWIDTH_WEIGHT_ENTRIES])
for test_value in test_values:
weight_entry = base_weight_entry.replace('Wbe=5', test_value)
content = NetworkStatusDocumentV3.content({'bandwidth-weights': weight_entry})
self.assertRaises(ValueError, NetworkStatusDocumentV3, content, True)
document = NetworkStatusDocumentV3(content, False)
self.assertEqual({}, document.bandwidth_weights)
def test_bandwidth_wights_misordered(self):
"""
Check that the 'bandwidth-wights' line is rejected if out of order.
"""
weight_entry = ' '.join(['%s=5' % e for e in reversed(BANDWIDTH_WEIGHT_ENTRIES)])
content = NetworkStatusDocumentV3.content({'bandwidth-weights': weight_entry})
self.assertRaises(ValueError, NetworkStatusDocumentV3, content, True)
document = NetworkStatusDocumentV3(content, False)
self.assertEqual({}, document.bandwidth_weights)
def test_bandwidth_wights_in_vote(self):
"""
Tries adding a 'bandwidth-wights' line to a vote.
"""
weight_entry = ' '.join(['%s=5' % e for e in BANDWIDTH_WEIGHT_ENTRIES])
expected = dict([(e, 5) for e in BANDWIDTH_WEIGHT_ENTRIES])
content = NetworkStatusDocumentV3.content({'vote-status': 'vote', 'bandwidth-weights': weight_entry})
self.assertRaises(ValueError, NetworkStatusDocumentV3, content, True)
document = NetworkStatusDocumentV3(content, False)
self.assertEqual(expected, document.bandwidth_weights)
def test_microdescriptor_signature(self):
"""
The 'directory-signature' lines both with and without a defined method for
the signature format.
"""
# including the signature method field should work
document = NetworkStatusDocumentV3.create({
'network-status-version': '3 microdesc',
'directory-signature': 'sha256 14C131DFC5C6F93646BE72FA1401C02A8DF2E8B4 BF112F1C6D5543CFD0A32215ACABD4197B5279AD\n-----BEGIN SIGNATURE-----%s-----END SIGNATURE-----' % CRYPTO_BLOB,
})
self.assertEqual('sha256', document.signatures[0].method)
# excluding the method should default to sha1
document = NetworkStatusDocumentV3.create({
'network-status-version': '3 microdesc',
})
self.assertEqual('sha1', document.signatures[0].method)
def test_malformed_signature(self):
"""
Provides malformed or missing content in the 'directory-signature' line.
"""
test_values = (
'',
'\n',
'blarg',
)
for test_value in test_values:
for test_attr in range(3):
attrs = [
'14C131DFC5C6F93646BE72FA1401C02A8DF2E8B4',
'BF112F1C6D5543CFD0A32215ACABD4197B5279AD',
'-----BEGIN SIGNATURE-----%s-----END SIGNATURE-----' % CRYPTO_BLOB,
]
attrs[test_attr] = test_value
content = NetworkStatusDocumentV3.content({'directory-signature': '%s %s\n%s' % tuple(attrs)})
self.assertRaises(ValueError, NetworkStatusDocumentV3, content, True)
NetworkStatusDocumentV3(content, False) # checks that it's still parsable without validation
def test_with_router_status_entries(self):
"""
Includes router status entries within the document. This isn't to test the
RouterStatusEntry parsing but rather the inclusion of it within the
document.
"""
entry1 = RouterStatusEntryV3.create({'s': 'Fast'})
entry2 = RouterStatusEntryV3.create({
'r': 'Nightfae AWt0XNId/OU2xX5xs5hVtDc5Mes 6873oEfM7fFIbxYtwllw9GPDwkA 2013-02-20 11:12:27 85.177.66.233 9001 9030',
's': 'Valid',
})
document = NetworkStatusDocumentV3.create(routers = (entry1, entry2))
self.assertTrue(entry1 in document.routers.values())
self.assertTrue(entry2 in document.routers.values())
# try with an invalid RouterStatusEntry
entry3 = RouterStatusEntryV3(RouterStatusEntryV3.content({'r': 'ugabuga'}), False)
content = NetworkStatusDocumentV3.content(routers = (entry3,))
self.assertRaises(ValueError, NetworkStatusDocumentV3, content, True)
document = NetworkStatusDocumentV3(content, False)
self.assertEqual([entry3], list(document.routers.values()))
# try including with a microdescriptor consensus
content = NetworkStatusDocumentV3.content({'network-status-version': '3 microdesc'}, routers = (entry1,))
self.assertRaises(ValueError, NetworkStatusDocumentV3, content, True)
document = NetworkStatusDocumentV3(content, False)
self.assertEqual([RouterStatusEntryMicroV3(str(entry1), False)], list(document.routers.values()))
def test_with_microdescriptor_router_status_entries(self):
"""
Includes microdescriptor flavored router status entries within the
document.
"""
entry1 = RouterStatusEntryMicroV3.create({'s': 'Fast'})
entry2 = RouterStatusEntryMicroV3.create({
'r': 'tornodeviennasil AcWxDFxrHetHYS5m6/MVt8ZN6AM 2013-03-13 22:09:13 78.142.142.246 443 80',
's': 'Valid',
})
document = NetworkStatusDocumentV3.create({'network-status-version': '3 microdesc'}, routers = (entry1, entry2))
self.assertTrue(entry1 in document.routers.values())
self.assertTrue(entry2 in document.routers.values())
# try with an invalid RouterStatusEntry
entry3 = RouterStatusEntryMicroV3(RouterStatusEntryMicroV3.content({'r': 'ugabuga'}), False)
content = NetworkStatusDocumentV3.content({'network-status-version': '3 microdesc'}, routers = (entry3,))
self.assertRaises(ValueError, NetworkStatusDocumentV3, content, True)
document = NetworkStatusDocumentV3(content, False)
self.assertEqual([entry3], list(document.routers.values()))
# try including microdescriptor entry in a normal consensus
content = NetworkStatusDocumentV3.content(routers = (entry1,))
self.assertRaises(ValueError, NetworkStatusDocumentV3, content, True)
document = NetworkStatusDocumentV3(content, False)
self.assertEqual([RouterStatusEntryV3(str(entry1), False)], list(document.routers.values()))
def test_with_directory_authorities(self):
"""
Includes a couple directory authorities in the document.
"""
for is_document_vote in (False, True):
for is_authorities_vote in (False, True):
authority1 = DirectoryAuthority.create({'contact': 'doctor jekyll'}, is_vote = is_authorities_vote)
authority2 = DirectoryAuthority.create({'contact': 'mister hyde'}, is_vote = is_authorities_vote)
vote_status = 'vote' if is_document_vote else 'consensus'
content = NetworkStatusDocumentV3.content({'vote-status': vote_status}, authorities = (authority1, authority2))
if is_document_vote == is_authorities_vote:
if is_document_vote:
# votes can only have a single authority
self.assertRaises(ValueError, NetworkStatusDocumentV3, content, True)
document = NetworkStatusDocumentV3(content, validate = False)
else:
document = NetworkStatusDocumentV3(content)
self.assertEqual((authority1, authority2), document.directory_authorities)
else:
# authority votes in a consensus or consensus authorities in a vote
self.assertRaises(ValueError, NetworkStatusDocumentV3, content, True)
document = NetworkStatusDocumentV3(content, validate = False)
self.assertEqual((authority1, authority2), document.directory_authorities)
def test_shared_randomness(self):
"""
Parses the shared randomness attributes.
"""
COMMITMENT_1 = '1 sha3-256 4CAEC248004A0DC6CE86EBD5F608C9B05500C70C AAAAAFd4/kAaklgYr4ijHZjXXy/B354jQfL31BFhhE46nuOHSPITyw== AAAAAFd4/kCpZeis3yJyr//rz8hXCeeAhHa4k3lAcAiMJd1vEMTPuw=='
COMMITMENT_2 = '1 sha3-256 598536A9DD4E6C0F18B4AD4B88C7875A0A29BA31 AAAAAFd4/kC7S920awC5/HF5RfX4fKZtYqjm6qMh9G91AcjZm13DQQ=='
authority = DirectoryAuthority.create(OrderedDict([
('shared-rand-participate', ''),
('shared-rand-commit', '%s\nshared-rand-commit %s' % (COMMITMENT_1, COMMITMENT_2)),
('shared-rand-previous-value', '8 hAQLxyt0U3gu7QR2owixRCbIltcyPrz3B0YBfUshOkE='),
('shared-rand-current-value', '7 KEIfSB7Db+ToasQIzJhbh0CtkeSePHLEehO+ams/RTU='),
]))
self.assertEqual(True, authority.is_shared_randomness_participate)
self.assertEqual(8, authority.shared_randomness_previous_reveal_count)
self.assertEqual('hAQLxyt0U3gu7QR2owixRCbIltcyPrz3B0YBfUshOkE=', authority.shared_randomness_previous_value)
self.assertEqual(7, authority.shared_randomness_current_reveal_count)
self.assertEqual('KEIfSB7Db+ToasQIzJhbh0CtkeSePHLEehO+ams/RTU=', authority.shared_randomness_current_value)
self.assertEqual(2, len(authority.shared_randomness_commitments))
first_commitment = authority.shared_randomness_commitments[0]
self.assertEqual(1, first_commitment.version)
self.assertEqual('sha3-256', first_commitment.algorithm)
self.assertEqual('4CAEC248004A0DC6CE86EBD5F608C9B05500C70C', first_commitment.identity)
self.assertEqual('AAAAAFd4/kAaklgYr4ijHZjXXy/B354jQfL31BFhhE46nuOHSPITyw==', first_commitment.commit)
self.assertEqual('AAAAAFd4/kCpZeis3yJyr//rz8hXCeeAhHa4k3lAcAiMJd1vEMTPuw==', first_commitment.reveal)
second_commitment = authority.shared_randomness_commitments[1]
self.assertEqual(1, second_commitment.version)
self.assertEqual('sha3-256', second_commitment.algorithm)
self.assertEqual('598536A9DD4E6C0F18B4AD4B88C7875A0A29BA31', second_commitment.identity)
self.assertEqual('AAAAAFd4/kC7S920awC5/HF5RfX4fKZtYqjm6qMh9G91AcjZm13DQQ==', second_commitment.commit)
self.assertEqual(None, second_commitment.reveal)
def test_shared_randomness_malformed(self):
"""
Checks shared randomness with malformed values.
"""
test_values = [
({'vote-status': 'vote', 'shared-rand-commit': 'hi sha3-256 598536A9DD4E6C0F18B4AD4B88C7875A0A29BA31 AAAAAFd4/kC7S920awC5/HF5RfX4fKZtYqjm6qMh9G91AcjZm13DQQ=='},
"The version on our 'shared-rand-commit' line wasn't an integer: hi sha3-256 598536A9DD4E6C0F18B4AD4B88C7875A0A29BA31 AAAAAFd4/kC7S920awC5/HF5RfX4fKZtYqjm6qMh9G91AcjZm13DQQ=="),
({'vote-status': 'vote', 'shared-rand-commit': 'sha3-256 598536A9DD4E6C0F18B4AD4B88C7875A0A29BA31 AAAAAFd4/kC7S920awC5/HF5RfX4fKZtYqjm6qMh9G91AcjZm13DQQ=='},
"'shared-rand-commit' must at least have a 'Version AlgName Identity Commit': sha3-256 598536A9DD4E6C0F18B4AD4B88C7875A0A29BA31 AAAAAFd4/kC7S920awC5/HF5RfX4fKZtYqjm6qMh9G91AcjZm13DQQ=="),
({'vote-status': 'vote', 'shared-rand-current-value': 'hi KEIfSB7Db+ToasQIzJhbh0CtkeSePHLEehO+ams/RTU='},
"A network status document's 'shared-rand-current-value' line must be a pair of values, the first an integer but was 'hi KEIfSB7Db+ToasQIzJhbh0CtkeSePHLEehO+ams/RTU='"),
({'vote-status': 'vote', 'shared-rand-current-value': 'KEIfSB7Db+ToasQIzJhbh0CtkeSePHLEehO+ams/RTU='},
"A network status document's 'shared-rand-current-value' line must be a pair of values, the first an integer but was 'KEIfSB7Db+ToasQIzJhbh0CtkeSePHLEehO+ams/RTU='"),
]
for attr, expected_exception in test_values:
content = DirectoryAuthority.content(attr)
self.assertRaisesRegexp(ValueError, re.escape(expected_exception), DirectoryAuthority, content, True)
authority = DirectoryAuthority(content, False)
self.assertEqual([], authority.shared_randomness_commitments)
self.assertEqual(None, authority.shared_randomness_previous_reveal_count)
self.assertEqual(None, authority.shared_randomness_previous_value)
self.assertEqual(None, authority.shared_randomness_current_reveal_count)
self.assertEqual(None, authority.shared_randomness_current_value)
def test_with_legacy_directory_authorities(self):
"""
Includes both normal authorities and those following the '-legacy' format.
"""
legacy_content = 'dir-source gabelmoo-legacy 81349FC1F2DBA2C2C11B45CB9706637D480AB913 131.188.40.189 131.188.40.189 80 443'
authority1 = DirectoryAuthority.create({'contact': 'doctor jekyll'}, is_vote = False)
authority2 = DirectoryAuthority(legacy_content, validate = True, is_vote = False)
authority3 = DirectoryAuthority.create({'contact': 'mister hyde'}, is_vote = False)
document = NetworkStatusDocumentV3.create({'vote-status': 'consensus'}, authorities = (authority1, authority2, authority3))
self.assertEqual((authority1, authority2, authority3), document.directory_authorities)
def test_authority_validation_flag_propagation(self):
"""
Includes invalid certificate content in an authority entry. This is testing
that the 'validate' flag propagages from the document to authority, and
authority to certificate classes.
"""
# make the dir-key-published field of the certiciate be malformed
authority_content = DirectoryAuthority.content(is_vote = True)
authority_content = authority_content.replace(b'dir-key-published 2', b'dir-key-published b2')
authority = DirectoryAuthority(authority_content, False, True)
content = NetworkStatusDocumentV3.content({'vote-status': 'vote'}, authorities = (authority,))
self.assertRaises(ValueError, NetworkStatusDocumentV3, content, True)
document = NetworkStatusDocumentV3(content, validate = False)
self.assertEqual((authority,), document.directory_authorities)
stem-1.6.0/test/unit/descriptor/microdescriptor.py 0000664 0001750 0001750 00000016733 13125773507 023132 0 ustar atagar atagar 0000000 0000000 """
Unit tests for stem.descriptor.microdescriptor.
"""
import unittest
import stem.descriptor
import stem.exit_policy
import test.require
from stem.util import str_type
from stem.descriptor.microdescriptor import Microdescriptor
from test.unit.descriptor import get_resource
FIRST_ONION_KEY = """\
-----BEGIN RSA PUBLIC KEY-----
MIGJAoGBAMhPQtZPaxP3ukybV5LfofKQr20/ljpRk0e9IlGWWMSTkfVvBcHsa6IM
H2KE6s4uuPHp7FqhakXAzJbODobnPHY8l1E4efyrqMQZXEQk2IMhgSNtG6YqUrVF
CxdSKSSy0mmcBe2TOyQsahlGZ9Pudxfnrey7KcfqnArEOqNH09RpAgMBAAE=
-----END RSA PUBLIC KEY-----\
"""
SECOND_ONION_KEY = """\
-----BEGIN RSA PUBLIC KEY-----
MIGJAoGBALCOxZdpMI2WO496njSQ2M7b4IgAGATqpJmH3So7lXOa25sK6o7JipgP
qQE83K/t/xsMIpxQ/hHkft3G78HkeXXFc9lVUzH0HmHwYEu0M+PMVULSkG36MfEl
7WeSZzaG+Tlnh9OySAzVyTsv1ZJsTQFHH9V8wuM0GOMo9X8DFC+NAgMBAAE=
-----END RSA PUBLIC KEY-----\
"""
THIRD_ONION_KEY = """\
-----BEGIN RSA PUBLIC KEY-----
MIGJAoGBAOWFQHxO+5kGuhwPUX5jB7wJCrTbSU0fZwolNV1t9UaDdjGDvIjIhdit
y2sMbyd9K8lbQO7x9rQjNst5ZicuaSOs854XQddSjm++vMdjYbOcVMqnKGSztvpd
w/1LVWFfhcBnsGi4JMGbmP+KUZG9A8kI9deSyJhfi35jA7UepiHHAgMBAAE=
-----END RSA PUBLIC KEY-----\
"""
class TestMicrodescriptor(unittest.TestCase):
def test_local_microdescriptors(self):
"""
Checks a small microdescriptor file with known contents.
"""
descriptor_path = get_resource('cached-microdescs')
with open(descriptor_path, 'rb') as descriptor_file:
descriptors = stem.descriptor.parse_file(descriptor_file, 'microdescriptor 1.0')
router = next(descriptors)
self.assertEqual(FIRST_ONION_KEY, router.onion_key)
self.assertEqual(None, router.ntor_onion_key)
self.assertEqual([], router.or_addresses)
self.assertEqual([], router.family)
self.assertEqual(stem.exit_policy.MicroExitPolicy('reject 1-65535'), router.exit_policy)
self.assertEqual({b'@last-listed': b'2013-02-24 00:18:36'}, router.get_annotations())
self.assertEqual([b'@last-listed 2013-02-24 00:18:36'], router.get_annotation_lines())
router = next(descriptors)
self.assertEqual(SECOND_ONION_KEY, router.onion_key)
self.assertEqual(str_type('r5572HzD+PMPBbXlZwBhsm6YEbxnYgis8vhZ1jmdI2k='), router.ntor_onion_key)
self.assertEqual([], router.or_addresses)
self.assertEqual(['$6141629FA0D15A6AEAEF3A1BEB76E64C767B3174'], router.family)
self.assertEqual(stem.exit_policy.MicroExitPolicy('reject 1-65535'), router.exit_policy)
self.assertEqual({b'@last-listed': b'2013-02-24 00:18:37'}, router.get_annotations())
self.assertEqual([b'@last-listed 2013-02-24 00:18:37'], router.get_annotation_lines())
router = next(descriptors)
self.assertEqual(THIRD_ONION_KEY, router.onion_key)
self.assertEqual(None, router.ntor_onion_key)
self.assertEqual([(str_type('2001:6b0:7:125::242'), 9001, True)], router.or_addresses)
self.assertEqual([], router.family)
self.assertEqual(stem.exit_policy.MicroExitPolicy('accept 80,443'), router.exit_policy)
self.assertEqual({b'@last-listed': b'2013-02-24 00:18:36'}, router.get_annotations())
self.assertEqual([b'@last-listed 2013-02-24 00:18:36'], router.get_annotation_lines())
def test_minimal_microdescriptor(self):
"""
Basic sanity check that we can parse a microdescriptor with minimal
attributes.
"""
desc = Microdescriptor.create()
self.assertEqual(None, desc.ntor_onion_key)
self.assertEqual([], desc.or_addresses)
self.assertEqual([], desc.family)
self.assertEqual(stem.exit_policy.MicroExitPolicy('reject 1-65535'), desc.exit_policy)
self.assertEqual(None, desc.exit_policy_v6)
self.assertEqual({}, desc.identifiers)
self.assertEqual(None, desc.identifier_type)
self.assertEqual(None, desc.identifier)
self.assertEqual({}, desc.protocols)
self.assertEqual([], desc.get_unrecognized_lines())
@test.require.cryptography
def test_descriptor_signing(self):
self.assertRaisesRegexp(NotImplementedError, 'Signing of Microdescriptor not implemented', Microdescriptor.create, sign = True)
def test_unrecognized_line(self):
"""
Includes unrecognized content in the descriptor.
"""
desc = Microdescriptor.create({'pepperjack': 'is oh so tasty!'})
self.assertEqual(['pepperjack is oh so tasty!'], desc.get_unrecognized_lines())
def test_proceeding_line(self):
"""
Includes a line prior to the 'onion-key' entry.
"""
desc_text = b'family Amunet1\n' + Microdescriptor.content()
self.assertRaises(ValueError, Microdescriptor, desc_text, True)
desc = Microdescriptor(desc_text, validate = False)
self.assertEqual(['Amunet1'], desc.family)
def test_a_line(self):
"""
Sanity test with both an IPv4 and IPv6 address.
"""
desc_text = Microdescriptor.content()
desc_text += b'\na 10.45.227.253:9001'
desc_text += b'\na [fd9f:2e19:3bcf::02:9970]:9001'
expected = [
('10.45.227.253', 9001, False),
('fd9f:2e19:3bcf::02:9970', 9001, True),
]
desc = Microdescriptor(desc_text)
self.assertEqual(expected, desc.or_addresses)
def test_family(self):
"""
Check the family line.
"""
desc = Microdescriptor.create({'family': 'Amunet1 Amunet2 Amunet3'})
self.assertEqual(['Amunet1', 'Amunet2', 'Amunet3'], desc.family)
# try multiple family lines
desc_text = Microdescriptor.content()
desc_text += b'\nfamily Amunet1'
desc_text += b'\nfamily Amunet2'
self.assertRaises(ValueError, Microdescriptor, desc_text, True)
# family entries will overwrite each other
desc = Microdescriptor(desc_text, validate = False)
self.assertEqual(1, len(desc.family))
def test_exit_policy(self):
"""
Basic check for 'p' lines. The router status entries contain an identical
field so we're not investing much effort here.
"""
desc = Microdescriptor.create({'p': 'accept 80,110,143,443'})
self.assertEqual(stem.exit_policy.MicroExitPolicy('accept 80,110,143,443'), desc.exit_policy)
def test_protocols(self):
"""
Basic check for 'pr' lines.
"""
desc = Microdescriptor.create({'pr': 'Cons=1 Desc=1 DirCache=1 HSDir=1 HSIntro=3 HSRend=1 Link=1-4 LinkAuth=1 Microdesc=1 Relay=1-2'})
self.assertEqual(10, len(desc.protocols))
def test_identifier(self):
"""
Basic check for 'id' lines.
"""
desc = Microdescriptor.create({'id': 'rsa1024 Cd47okjCHD83YGzThGBDptXs9Z4'})
self.assertEqual({'rsa1024': 'Cd47okjCHD83YGzThGBDptXs9Z4'}, desc.identifiers)
self.assertEqual('rsa1024', desc.identifier_type)
self.assertEqual('Cd47okjCHD83YGzThGBDptXs9Z4', desc.identifier)
# check when there's multiple key types
desc_text = b'\n'.join((
Microdescriptor.content(),
b'id rsa1024 Cd47okjCHD83YGzThGBDptXs9Z4',
b'id ed25519 50f6ddbecdc848dcc6b818b14d1',
))
desc = Microdescriptor(desc_text, validate = True)
self.assertEqual({'rsa1024': 'Cd47okjCHD83YGzThGBDptXs9Z4', 'ed25519': '50f6ddbecdc848dcc6b818b14d1'}, desc.identifiers)
self.assertEqual('ed25519', desc.identifier_type)
self.assertEqual('50f6ddbecdc848dcc6b818b14d1', desc.identifier)
# check when there's conflicting keys
desc_text = b'\n'.join((
Microdescriptor.content(),
b'id rsa1024 Cd47okjCHD83YGzThGBDptXs9Z4',
b'id rsa1024 50f6ddbecdc848dcc6b818b14d1',
))
desc = Microdescriptor(desc_text)
self.assertEqual({}, desc.identifiers)
exc_msg = "There can only be one 'id' line per a key type, but 'rsa1024' appeared multiple times"
self.assertRaisesRegexp(ValueError, exc_msg, Microdescriptor, desc_text, validate = True)
stem-1.6.0/test/unit/descriptor/__init__.py 0000664 0001750 0001750 00000002674 13124757510 021453 0 ustar atagar atagar 0000000 0000000 """
Unit tests for stem.descriptor.
"""
import os
__all__ = [
'export',
'extrainfo_descriptor',
'microdescriptor',
'networkstatus',
'reader',
'router_status_entry',
'server_descriptor',
]
DESCRIPTOR_TEST_DATA = os.path.join(os.path.dirname(__file__), 'data')
def get_resource(filename):
"""
Provides the path for a file in our descriptor data directory.
"""
return os.path.join(DESCRIPTOR_TEST_DATA, filename)
def base_expect_invalid_attr(cls, default_attr, default_value, test, desc_attrs, attr = None, expected_value = None):
return base_expect_invalid_attr_for_text(cls, default_attr, default_value, test, cls.content(desc_attrs), attr, expected_value)
def base_expect_invalid_attr_for_text(cls, default_attr, default_prefix, test, desc_text, attr = None, expected_value = None):
"""
Asserts that construction will fail due to desc_text having a malformed
attribute. If an attr is provided then we check that it matches an expected
value when we're constructed without validation.
"""
test.assertRaises(ValueError, cls, desc_text, True)
desc = cls(desc_text, validate = False)
if attr:
# check that the invalid attribute matches the expected value when
# constructed without validation
test.assertEqual(expected_value, getattr(desc, attr))
elif default_attr and default_prefix:
test.assertTrue(getattr(desc, default_attr).startswith(default_prefix)) # check a default attribute
return desc
stem-1.6.0/test/unit/descriptor/remote.py 0000664 0001750 0001750 00000015446 13115423200 021172 0 ustar atagar atagar 0000000 0000000 """
Unit tests for stem.descriptor.remote.
"""
import io
import socket
import unittest
import stem.prereq
import stem.descriptor.remote
try:
# added in python 3.3
from unittest.mock import patch
except ImportError:
from mock import patch
# The urlopen() method is in a different location depending on if we're using
# python 2.x or 3.x. The 2to3 converter accounts for this in imports, but not
# mock annotations.
URL_OPEN = 'urllib.request.urlopen' if stem.prereq.is_python_3() else 'urllib2.urlopen'
# Output from requesting moria1's descriptor from itself...
# % curl http://128.31.0.39:9131/tor/server/fp/9695DFC35FFEB861329B9F1AB04C46397020CE31
TEST_DESCRIPTOR = b"""\
router moria1 128.31.0.34 9101 0 9131
platform Tor 0.2.5.0-alpha-dev on Linux
protocols Link 1 2 Circuit 1
published 2013-07-05 23:48:52
fingerprint 9695 DFC3 5FFE B861 329B 9F1A B04C 4639 7020 CE31
uptime 1818933
bandwidth 512000 62914560 1307929
extra-info-digest 17D0142F6EBCDF60160EB1794FA6C9717D581F8C
caches-extra-info
onion-key
-----BEGIN RSA PUBLIC KEY-----
MIGJAoGBALzd4bhz1usB7wpoaAvP+BBOnNIk7mByAKV6zvyQ0p1M09oEmxPMc3qD
AAm276oJNf0eq6KWC6YprzPWFsXEIdXSqA6RWXCII1JG/jOoy6nt478BkB8TS9I9
1MJW27ppRaqnLiTmBmM+qzrsgJGwf+onAgUKKH2GxlVgahqz8x6xAgMBAAE=
-----END RSA PUBLIC KEY-----
signing-key
-----BEGIN RSA PUBLIC KEY-----
MIGJAoGBALtJ9uD7cD7iHjqNA3AgsX9prES5QN+yFQyr2uOkxzhvunnaf6SNhzWW
bkfylnMrRm/qCz/czcjZO6N6EKHcXmypehvP566B7gAQ9vDsb+l7VZVWgXvzNc2s
tl3P7qpC08rgyJh1GqmtQTCesIDqkEyWxwToympCt09ZQRq+fIttAgMBAAE=
-----END RSA PUBLIC KEY-----
hidden-service-dir
contact 1024D/28988BF5 arma mit edu
ntor-onion-key 9ZVjNkf/iLEnD685SpC5kcDytQ7u5ViiI9JOftdbE0k=
reject *:*
router-signature
-----BEGIN SIGNATURE-----
Y8Tj2e7mPbFJbguulkPEBVYzyO57p4btpWEXvRMD6vxIh/eyn25pehg5dUVBtZlL
iO3EUE0AEYah2W9gdz8t+i3Dtr0zgqLS841GC/TyDKCm+MKmN8d098qnwK0NGF9q
01NZPuSqXM1b6hnl2espFzL7XL8XEGRU+aeg+f/ukw4=
-----END SIGNATURE-----
"""
FALLBACK_DIR_CONTENT = b"""\
/* Trial fallbacks for 0.2.8.1-alpha with ADDRESS_AND_PORT_STABLE_DAYS = 30
* This works around an issue where relays post a descriptor without a DirPort
* when restarted. If these relays stay up, they will have been up for 120 days
* by the 0.2.8 stable release -- teor */
"5.175.233.86:80 orport=443 id=5525D0429BFE5DC4F1B0E9DE47A4CFA169661E33"
" weight=43680",
"62.210.124.124:9130 orport=9101 id=2EBD117806EE43C3CC885A8F1E4DC60F207E7D3E"
" ipv6=[2001:bc8:3f23:100::1]:9101"
" weight=43680",
"""
class TestDescriptorDownloader(unittest.TestCase):
@patch(URL_OPEN)
def test_query_download(self, urlopen_mock):
"""
Check Query functionality when we successfully download a descriptor.
"""
urlopen_mock.return_value = io.BytesIO(TEST_DESCRIPTOR)
query = stem.descriptor.remote.Query(
'/tor/server/fp/9695DFC35FFEB861329B9F1AB04C46397020CE31',
'server-descriptor 1.0',
endpoints = [('128.31.0.39', 9131)],
validate = True,
)
expeced_url = 'http://128.31.0.39:9131/tor/server/fp/9695DFC35FFEB861329B9F1AB04C46397020CE31'
self.assertEqual(expeced_url, query._pick_url())
descriptors = list(query)
self.assertEqual(1, len(descriptors))
desc = descriptors[0]
self.assertEqual('moria1', desc.nickname)
self.assertEqual('128.31.0.34', desc.address)
self.assertEqual('9695DFC35FFEB861329B9F1AB04C46397020CE31', desc.fingerprint)
self.assertEqual(TEST_DESCRIPTOR.strip(), desc.get_bytes())
urlopen_mock.assert_called_once_with(expeced_url, timeout = None)
@patch(URL_OPEN)
def test_query_with_malformed_content(self, urlopen_mock):
"""
Query with malformed descriptor content.
"""
descriptor_content = b'some malformed stuff'
urlopen_mock.return_value = io.BytesIO(descriptor_content)
query = stem.descriptor.remote.Query(
'/tor/server/fp/9695DFC35FFEB861329B9F1AB04C46397020CE31',
'server-descriptor 1.0',
endpoints = [('128.31.0.39', 9131)],
validate = True,
)
# checking via the iterator
expected_error_msg = 'Content conform to being a server descriptor:\nsome malformed stuff'
descriptors = list(query)
self.assertEqual(0, len(descriptors))
self.assertEqual(ValueError, type(query.error))
self.assertEqual(expected_error_msg, str(query.error))
# check via the run() method
self.assertRaises(ValueError, query.run)
@patch(URL_OPEN)
def test_query_with_timeout(self, urlopen_mock):
urlopen_mock.side_effect = socket.timeout('connection timed out')
query = stem.descriptor.remote.Query(
'/tor/server/fp/9695DFC35FFEB861329B9F1AB04C46397020CE31',
'server-descriptor 1.0',
endpoints = [('128.31.0.39', 9131)],
fall_back_to_authority = False,
timeout = 5,
validate = True,
)
self.assertRaises(socket.timeout, query.run)
urlopen_mock.assert_called_with(
'http://128.31.0.39:9131/tor/server/fp/9695DFC35FFEB861329B9F1AB04C46397020CE31',
timeout = 5,
)
self.assertEqual(3, urlopen_mock.call_count)
@patch(URL_OPEN)
def test_can_iterate_multiple_times(self, urlopen_mock):
urlopen_mock.return_value = io.BytesIO(TEST_DESCRIPTOR)
query = stem.descriptor.remote.Query(
'/tor/server/fp/9695DFC35FFEB861329B9F1AB04C46397020CE31',
'server-descriptor 1.0',
endpoints = [('128.31.0.39', 9131)],
validate = True,
)
# check that iterating over the query provides the descriptors each time
self.assertEqual(1, len(list(query)))
self.assertEqual(1, len(list(query)))
self.assertEqual(1, len(list(query)))
def test_using_authorities_in_hash(self):
# ensure our DirectoryAuthority instances can be used in hashes
{stem.descriptor.remote.get_authorities()['moria1']: 'hello'}
def test_fallback_directories_from_cache(self):
# quick sanity test that we can load cached content
fallback_directories = stem.descriptor.remote.FallbackDirectory.from_cache()
self.assertTrue(len(fallback_directories) > 10)
self.assertEqual('5.39.92.199', fallback_directories['0BEA4A88D069753218EAAAD6D22EA87B9A1319D6'].address)
@patch(URL_OPEN)
def test_fallback_directories_from_remote(self, urlopen_mock):
urlopen_mock.return_value = io.BytesIO(FALLBACK_DIR_CONTENT)
fallback_directories = stem.descriptor.remote.FallbackDirectory.from_remote()
expected = {
'5525D0429BFE5DC4F1B0E9DE47A4CFA169661E33': stem.descriptor.remote.FallbackDirectory(
address = '5.175.233.86',
or_port = 443,
dir_port = 80,
fingerprint = '5525D0429BFE5DC4F1B0E9DE47A4CFA169661E33',
),
'2EBD117806EE43C3CC885A8F1E4DC60F207E7D3E': stem.descriptor.remote.FallbackDirectory(
address = '62.210.124.124',
or_port = 9101,
dir_port = 9130,
fingerprint = '2EBD117806EE43C3CC885A8F1E4DC60F207E7D3E',
orport_v6 = ('2001:bc8:3f23:100::1', 9101),
),
}
self.assertEqual(expected, fallback_directories)
stem-1.6.0/test/unit/descriptor/export.py 0000664 0001750 0001750 00000005767 13124757510 021243 0 ustar atagar atagar 0000000 0000000 """
Unit tests for stem.descriptor.export.
"""
import unittest
try:
from StringIO import StringIO
except ImportError:
from io import StringIO
import stem.prereq
from stem.descriptor.server_descriptor import RelayDescriptor, BridgeDescriptor
from stem.descriptor.export import export_csv, export_csv_file
class TestExport(unittest.TestCase):
def test_minimal_descriptor(self):
"""
Exports a single minimal tor server descriptor.
"""
if stem.prereq._is_python_26():
self.skipTest('(header added in python 2.7)')
return
desc = RelayDescriptor.create({
'router': 'caerSidi 71.35.133.197 9001 0 0',
'published': '2012-03-01 17:15:27',
})
desc_csv = export_csv(desc, included_fields = ('nickname', 'address', 'published'), header = False)
expected = 'caerSidi,71.35.133.197,2012-03-01 17:15:27\n'
self.assertEqual(expected, desc_csv)
desc_csv = export_csv(desc, included_fields = ('nickname', 'address', 'published'), header = True)
expected = 'nickname,address,published\n' + expected
self.assertEqual(expected, desc_csv)
def test_multiple_descriptors(self):
"""
Exports multiple descriptors, making sure that we get them back in the same
order.
"""
nicknames = ('relay1', 'relay3', 'relay2', 'caerSidi', 'zeus')
descriptors = []
for nickname in nicknames:
router_line = '%s 71.35.133.197 9001 0 0' % nickname
descriptors.append(RelayDescriptor.create({'router': router_line}))
expected = '\n'.join(nicknames) + '\n'
self.assertEqual(expected, export_csv(descriptors, included_fields = ('nickname',), header = False))
def test_file_output(self):
"""
Basic test for the export_csv_file() function, checking that it provides
the same output as export_csv().
"""
desc = RelayDescriptor.create()
desc_csv = export_csv(desc)
csv_buffer = StringIO()
export_csv_file(csv_buffer, desc)
self.assertEqual(desc_csv, csv_buffer.getvalue())
def test_excludes_private_attr(self):
"""
Checks that the default attributes for our csv output doesn't include private fields.
"""
if stem.prereq._is_python_26():
self.skipTest('(header added in python 2.7)')
return
desc = RelayDescriptor.create()
desc_csv = export_csv(desc)
self.assertTrue(',signature' in desc_csv)
self.assertFalse(',_digest' in desc_csv)
self.assertFalse(',_annotation_lines' in desc_csv)
def test_empty_input(self):
"""
Exercises when we don't provide any descriptors.
"""
self.assertEqual('', export_csv([]))
def test_invalid_attributes(self):
"""
Attempts to make a csv with attributes that don't exist.
"""
desc = RelayDescriptor.create()
self.assertRaises(ValueError, export_csv, desc, ('nickname', 'blarg!'))
def test_multiple_descriptor_types(self):
"""
Attempts to make a csv with multiple descriptor types.
"""
self.assertRaises(ValueError, export_csv, (RelayDescriptor.create(), BridgeDescriptor.create()))
stem-1.6.0/test/unit/descriptor/server_descriptor.py 0000664 0001750 0001750 00000116102 13167173763 023461 0 ustar atagar atagar 0000000 0000000 """
Unit tests for stem.descriptor.server_descriptor.
"""
import datetime
import functools
import io
import pickle
import tarfile
import time
import unittest
import stem.descriptor
import stem.descriptor.router_status_entry
import stem.descriptor.server_descriptor
import stem.exit_policy
import stem.prereq
import stem.version
import stem.util.str_tools
import test.require
from stem.util import str_type
from stem.descriptor.certificate import CertType, ExtensionType
from stem.descriptor.server_descriptor import BridgeDistribution, RelayDescriptor, BridgeDescriptor
from test.unit.descriptor import (
get_resource,
base_expect_invalid_attr,
base_expect_invalid_attr_for_text,
)
try:
# Added in 2.7
from collections import OrderedDict
except ImportError:
from stem.util.ordereddict import OrderedDict
try:
# added in python 3.3
from unittest.mock import Mock, patch
except ImportError:
from mock import Mock, patch
TARFILE_FINGERPRINTS = set([
str_type('B6D83EC2D9E18B0A7A33428F8CFA9C536769E209'),
str_type('E0BD57A11F00041A9789577C53A1B784473669E4'),
str_type('1F43EE37A0670301AD9CB555D94AFEC2C89FDE86'),
])
expect_invalid_attr = functools.partial(base_expect_invalid_attr, RelayDescriptor, 'nickname', 'Unnamed')
expect_invalid_attr_for_text = functools.partial(base_expect_invalid_attr_for_text, RelayDescriptor, 'nickname', 'Unnamed')
class TestServerDescriptor(unittest.TestCase):
def test_with_tarfile_path(self):
"""
Fetch server descriptors via parse_file() for a tarfile path.
"""
descriptors = list(stem.descriptor.parse_file(get_resource('descriptor_archive.tar')))
self.assertEqual(3, len(descriptors))
fingerprints = set([desc.fingerprint for desc in descriptors])
self.assertEqual(TARFILE_FINGERPRINTS, fingerprints)
def test_with_tarfile_object(self):
"""
Fetch server descriptors via parse_file() for a tarfile object.
"""
# TODO: When dropping python 2.6 support we can go back to using the 'with'
# keyword here.
tar_file = tarfile.open(get_resource('descriptor_archive.tar'))
descriptors = list(stem.descriptor.parse_file(tar_file))
self.assertEqual(3, len(descriptors))
fingerprints = set([desc.fingerprint for desc in descriptors])
self.assertEqual(TARFILE_FINGERPRINTS, fingerprints)
tar_file.close()
def test_metrics_descriptor(self):
"""
Parses and checks our results against a server descriptor from metrics.
"""
expected_family = set([
'$0CE3CFB1E9CC47B63EA8869813BF6FAB7D4540C1',
'$1FD187E8F69A9B74C9202DC16A25B9E7744AB9F6',
'$74FB5EFA6A46DE4060431D515DC9A790E6AD9A7C',
'$77001D8DA9BF445B0F81AA427A675F570D222E6A',
'$B6D83EC2D9E18B0A7A33428F8CFA9C536769E209',
'$D2F37F46182C23AB747787FD657E680B34EAF892',
'$E0BD57A11F00041A9789577C53A1B784473669E4',
'$E5E3E9A472EAF7BE9682B86E92305DB4C71048EF',
])
expected_onion_key = """-----BEGIN RSA PUBLIC KEY-----
MIGJAoGBAJv5IIWQ+WDWYUdyA/0L8qbIkEVH/cwryZWoIaPAzINfrw1WfNZGtBmg
skFtXhOHHqTRN4GPPrZsAIUOQGzQtGb66IQgT4tO/pj+P6QmSCCdTfhvGfgTCsC+
WPi4Fl2qryzTb3QO5r5x7T8OsG2IBUET1bLQzmtbC560SYR49IvVAgMBAAE=
-----END RSA PUBLIC KEY-----"""
expected_signing_key = """-----BEGIN RSA PUBLIC KEY-----
MIGJAoGBAKwvOXyztVKnuYvpTKt+nS3XIKeO8dVungi8qGoeS+6gkR6lDtGfBTjd
uE9UIkdAl9zi8/1Ic2wsUNHE9jiS0VgeupITGZY8YOyMJJ/xtV1cqgiWhq1dUYaq
51TOtUogtAPgXPh4J+V8HbFFIcCzIh3qCO/xXo+DSHhv7SSif1VpAgMBAAE=
-----END RSA PUBLIC KEY-----"""
expected_signature = """-----BEGIN SIGNATURE-----
dskLSPz8beUW7bzwDjR6EVNGpyoZde83Ejvau+5F2c6cGnlu91fiZN3suE88iE6e
758b9ldq5eh5mapb8vuuV3uO+0Xsud7IEOqfxdkmk0GKnUX8ouru7DSIUzUL0zqq
Qlx9HNCqCY877ztFRC624ja2ql6A2hBcuoYMbkHjcQ4=
-----END SIGNATURE-----"""
with open(get_resource('example_descriptor'), 'rb') as descriptor_file:
desc = next(stem.descriptor.parse_file(descriptor_file, 'server-descriptor 1.0'))
self.assertEqual('caerSidi', desc.nickname)
self.assertEqual('A7569A83B5706AB1B1A9CB52EFF7D2D32E4553EB', desc.fingerprint)
self.assertEqual('71.35.133.197', desc.address)
self.assertEqual(9001, desc.or_port)
self.assertEqual(None, desc.socks_port)
self.assertEqual(None, desc.dir_port)
self.assertEqual(None, desc.certificate)
self.assertEqual(None, desc.ed25519_certificate)
self.assertEqual(None, desc.ed25519_master_key)
self.assertEqual(None, desc.ed25519_signature)
self.assertEqual(b'Tor 0.2.1.30 on Linux x86_64', desc.platform)
self.assertEqual(stem.version.Version('0.2.1.30'), desc.tor_version)
self.assertEqual('Linux x86_64', desc.operating_system)
self.assertEqual(588217, desc.uptime)
self.assertEqual(datetime.datetime(2012, 3, 1, 17, 15, 27), desc.published)
self.assertEqual(b'www.atagar.com/contact', desc.contact)
self.assertEqual(['1', '2'], desc.link_protocols)
self.assertEqual(['1'], desc.circuit_protocols)
self.assertEqual(False, desc.hibernating)
self.assertEqual(False, desc.allow_single_hop_exits)
self.assertEqual(False, desc.allow_tunneled_dir_requests)
self.assertEqual(False, desc.extra_info_cache)
self.assertEqual('D225B728768D7EA4B5587C13A7A9D22EBBEE6E66', desc.extra_info_digest)
self.assertEqual(None, desc.extra_info_sha256_digest)
self.assertEqual(['2'], desc.hidden_service_dir)
self.assertEqual(BridgeDistribution.ANY, desc.bridge_distribution)
self.assertEqual(expected_family, desc.family)
self.assertEqual(153600, desc.average_bandwidth)
self.assertEqual(256000, desc.burst_bandwidth)
self.assertEqual(104590, desc.observed_bandwidth)
self.assertEqual(stem.exit_policy.ExitPolicy('reject *:*'), desc.exit_policy)
self.assertEqual(expected_onion_key, desc.onion_key)
self.assertEqual(None, desc.onion_key_crosscert)
self.assertEqual(None, desc.ntor_onion_key_crosscert)
self.assertEqual(None, desc.onion_key_crosscert)
self.assertEqual(expected_signing_key, desc.signing_key)
self.assertEqual(expected_signature, desc.signature)
self.assertEqual([], desc.get_unrecognized_lines())
self.assertEqual('2C7B27BEAB04B4E2459D89CA6D5CD1CC5F95A689', desc.digest())
def test_metrics_descriptor_multiple(self):
"""
Parses and checks our results against a server descriptor from metrics.
"""
with open(get_resource('metrics_server_desc_multiple'), 'rb') as descriptor_file:
descriptors = list(stem.descriptor.parse_file(descriptor_file, 'server-descriptor 1.0'))
self.assertEqual(2, len(descriptors))
self.assertEqual('anonion', descriptors[0].nickname)
self.assertEqual('9A5EC5BB866517E53962AF4D3E776536694B069E', descriptors[0].fingerprint)
self.assertEqual('Unnamed', descriptors[1].nickname)
self.assertEqual('5366F1D198759F8894EA6E5FF768C667F59AFD24', descriptors[1].fingerprint)
def test_old_descriptor(self):
"""
Parses a relay server descriptor from 2005.
"""
with open(get_resource('old_descriptor'), 'rb') as descriptor_file:
desc = next(stem.descriptor.parse_file(descriptor_file, 'server-descriptor 1.0', validate = True))
self.assertEqual('krypton', desc.nickname)
self.assertEqual('3E2F63E2356F52318B536A12B6445373808A5D6C', desc.fingerprint)
self.assertEqual('212.37.39.59', desc.address)
self.assertEqual(8000, desc.or_port)
self.assertEqual(None, desc.socks_port)
self.assertEqual(None, desc.dir_port)
self.assertEqual(b'Tor 0.1.0.14 on FreeBSD i386', desc.platform)
self.assertEqual(stem.version.Version('0.1.0.14'), desc.tor_version)
self.assertEqual('FreeBSD i386', desc.operating_system)
self.assertEqual(64820, desc.uptime)
self.assertEqual(datetime.datetime(2005, 12, 16, 18, 1, 3), desc.published)
self.assertEqual(None, desc.contact)
self.assertEqual(None, desc.link_protocols)
self.assertEqual(None, desc.circuit_protocols)
self.assertEqual(True, desc.hibernating)
self.assertEqual(False, desc.allow_single_hop_exits)
self.assertEqual(False, desc.allow_tunneled_dir_requests)
self.assertEqual(False, desc.extra_info_cache)
self.assertEqual(None, desc.extra_info_digest)
self.assertEqual(None, desc.extra_info_sha256_digest)
self.assertEqual(None, desc.hidden_service_dir)
self.assertEqual(BridgeDistribution.ANY, desc.bridge_distribution)
self.assertEqual(set(), desc.family)
self.assertEqual(102400, desc.average_bandwidth)
self.assertEqual(10485760, desc.burst_bandwidth)
self.assertEqual(0, desc.observed_bandwidth)
self.assertEqual(datetime.datetime(2005, 12, 16, 18, 0, 48), desc.read_history_end)
self.assertEqual(900, desc.read_history_interval)
self.assertEqual(datetime.datetime(2005, 12, 16, 18, 0, 48), desc.write_history_end)
self.assertEqual(900, desc.write_history_interval)
self.assertEqual([], desc.get_unrecognized_lines())
# The read-history and write-history lines are pretty long so just checking
# the initial contents for the line and parsed values.
read_values_start = [20774, 489973, 510022, 511163, 20949]
self.assertEqual(read_values_start, desc.read_history_values[:5])
write_values_start = [81, 8848, 8927, 8927, 83, 8848, 8931, 8929, 81, 8846]
self.assertEqual(write_values_start, desc.write_history_values[:10])
def test_non_ascii_descriptor(self):
"""
Parses a descriptor with non-ascii content.
"""
with open(get_resource('non-ascii_descriptor'), 'rb') as descriptor_file:
desc = next(stem.descriptor.parse_file(descriptor_file, 'server-descriptor 1.0', validate = True))
self.assertEqual('Coruscant', desc.nickname)
self.assertEqual('0B9821545C48E496AEED9ECC0DB506C49FF8158D', desc.fingerprint)
self.assertEqual('88.182.161.122', desc.address)
self.assertEqual(9001, desc.or_port)
self.assertEqual(None, desc.socks_port)
self.assertEqual(9030, desc.dir_port)
self.assertEqual(b'Tor 0.2.3.25 on Linux', desc.platform)
self.assertEqual(stem.version.Version('0.2.3.25'), desc.tor_version)
self.assertEqual('Linux', desc.operating_system)
self.assertEqual(259738, desc.uptime)
self.assertEqual(datetime.datetime(2013, 5, 18, 11, 16, 19), desc.published)
self.assertEqual(b'1024D/04D2E818 L\xc3\xa9na\xc3\xafc Huard ', desc.contact)
self.assertEqual(['1', '2'], desc.link_protocols)
self.assertEqual(['1'], desc.circuit_protocols)
self.assertEqual(False, desc.hibernating)
self.assertEqual(False, desc.allow_single_hop_exits)
self.assertEqual(False, desc.allow_tunneled_dir_requests)
self.assertEqual(False, desc.extra_info_cache)
self.assertEqual('56403D838DE152421CD401B8E57DAD4483A3D56B', desc.extra_info_digest)
self.assertEqual(None, desc.extra_info_sha256_digest)
self.assertEqual(['2'], desc.hidden_service_dir)
self.assertEqual(BridgeDistribution.ANY, desc.bridge_distribution)
self.assertEqual(set(), desc.family)
self.assertEqual(102400, desc.average_bandwidth)
self.assertEqual(204800, desc.burst_bandwidth)
self.assertEqual(122818, desc.observed_bandwidth)
self.assertEqual(stem.exit_policy.ExitPolicy('reject *:*'), desc.exit_policy)
self.assertEqual([], desc.get_unrecognized_lines())
# Make sure that we can get a string representation for this descriptor
# (having non-unicode content risks a UnicodeEncodeError)...
#
# https://trac.torproject.org/8265
self.assertTrue(isinstance(str(desc), str))
@test.require.cryptography
def test_descriptor_signing(self):
RelayDescriptor.create(sign = True)
self.assertRaisesRegexp(NotImplementedError, 'Signing of BridgeDescriptor not implemented', BridgeDescriptor.create, sign = True)
def test_router_status_entry(self):
"""
Tests creation of router status entries.
"""
desc_without_fingerprint = RelayDescriptor.create()
exc_msg = 'Server descriptor lacks a fingerprint. This is an optional field, but required to make a router status entry.'
self.assertRaisesRegexp(ValueError, exc_msg, desc_without_fingerprint.make_router_status_entry)
desc = RelayDescriptor.create(OrderedDict((
('router', 'caerSidi 71.35.133.197 9001 0 0'),
('published', '2012-02-29 04:03:19'),
('fingerprint', '4F0C 867D F0EF 6816 0568 C826 838F 482C EA7C FE44'),
('or-address', ['71.35.133.197:9001', '[12ab:2e19:3bcf::02:9970]:9001']),
('onion-key', '\n-----BEGIN RSA PUBLIC KEY-----%s-----END RSA PUBLIC KEY-----' % stem.descriptor.CRYPTO_BLOB),
('signing-key', '\n-----BEGIN RSA PUBLIC KEY-----%s-----END RSA PUBLIC KEY-----' % stem.descriptor.CRYPTO_BLOB),
))).make_router_status_entry()
self.assertEqual(stem.descriptor.router_status_entry.RouterStatusEntryV3, type(desc))
self.assertEqual('caerSidi', desc.nickname)
self.assertEqual('4F0C867DF0EF68160568C826838F482CEA7CFE44', desc.fingerprint)
self.assertEqual(datetime.datetime(2012, 2, 29, 4, 3, 19), desc.published)
self.assertEqual('71.35.133.197', desc.address)
self.assertEqual(9001, desc.or_port)
self.assertEqual(None, desc.dir_port)
self.assertEqual(['Fast', 'Named', 'Running', 'Stable', 'Valid'], desc.flags)
self.assertEqual(None, desc.version)
self.assertEqual(None, desc.version_line)
self.assertEqual([('71.35.133.197', 9001, False), ('12ab:2e19:3bcf::02:9970', 9001, True)], desc.or_addresses)
self.assertEqual(None, desc.identifier_type)
self.assertEqual(None, desc.identifier)
self.assertEqual('A863EFE8395C41C880782B89B850D20EDD242BDA', desc.digest)
self.assertEqual(153600, desc.bandwidth)
self.assertEqual(None, desc.measured)
self.assertEqual(False, desc.is_unmeasured)
self.assertEqual([], desc.unrecognized_bandwidth_entries)
self.assertEqual(stem.exit_policy.MicroExitPolicy('reject 1-65535'), desc.exit_policy)
self.assertEqual([], desc.microdescriptor_hashes)
def test_make_router_status_entry_with_live_descriptor(self):
"""
Tests creation of router status entries with a live server descriptor.
"""
with open(get_resource('server_descriptor_with_ed25519'), 'rb') as descriptor_file:
desc = next(stem.descriptor.parse_file(descriptor_file, validate = True)).make_router_status_entry()
self.assertEqual(stem.descriptor.router_status_entry.RouterStatusEntryV3, type(desc))
self.assertEqual('destiny', desc.nickname)
self.assertEqual('F65E0196C94DFFF48AFBF2F5F9E3E19AAE583FD0', desc.fingerprint)
self.assertEqual(datetime.datetime(2015, 8, 22, 15, 21, 45), desc.published)
self.assertEqual('94.242.246.23', desc.address)
self.assertEqual(9001, desc.or_port)
self.assertEqual(443, desc.dir_port)
self.assertEqual(['Fast', 'Named', 'Running', 'Stable', 'Valid'], desc.flags)
self.assertEqual(stem.version.Version('0.2.7.2-alpha-dev'), desc.version)
self.assertEqual('Tor 0.2.7.2-alpha-dev', desc.version_line)
self.assertEqual([('2a01:608:ffff:ff07::1:23', 9003, True)], desc.or_addresses)
self.assertEqual('ed25519', desc.identifier_type)
self.assertEqual('pbYagEQPUiNjcDp/oY2oESXkDzd8PZlr26kaR7nUkao', desc.identifier)
self.assertEqual('B5E441051D139CCD84BC765D130B01E44DAC29AD', desc.digest)
self.assertEqual(149715200, desc.bandwidth)
self.assertEqual(None, desc.measured)
self.assertEqual(False, desc.is_unmeasured)
self.assertEqual([], desc.unrecognized_bandwidth_entries)
self.assertEqual(stem.exit_policy.MicroExitPolicy('reject 25,465,587,10000,14464'), desc.exit_policy)
self.assertEqual([], desc.microdescriptor_hashes)
@patch('time.time', Mock(return_value = time.mktime(datetime.date(2010, 1, 1).timetuple())))
def test_with_ed25519(self):
"""
Parses a descriptor with a ed25519 identity key, as added by proposal 228
(cross certification onionkeys).
"""
with open(get_resource('server_descriptor_with_ed25519'), 'rb') as descriptor_file:
desc = next(stem.descriptor.parse_file(descriptor_file, validate = True))
family = set([
'$379FB450010D17078B3766C2273303C358C3A442',
'$3EB46C1D8D8B1C0BBCB6E4F08301EF68B7F5308D',
'$B0279A521375F3CB2AE210BDBFC645FDD2E1973A',
'$EC116BCB80565A408CE67F8EC3FE3B0B02C3A065',
])
self.assertEqual(1, desc.certificate.version)
self.assertEqual(CertType.SIGNING, desc.certificate.type)
self.assertEqual(datetime.datetime(2015, 8, 28, 17, 0, 0), desc.certificate.expiration)
self.assertEqual(1, desc.certificate.key_type)
self.assertTrue(desc.certificate.key.startswith(b'\xa5\xb6\x1a\x80D\x0f'))
self.assertTrue(desc.certificate.signature.startswith(b'\xc6\x8e\xd3\xae\x0b'))
self.assertEqual(1, len(desc.certificate.extensions))
self.assertTrue('bWPo2fIzo3uOywfoM' in desc.certificate.encoded)
extension = desc.certificate.extensions[0]
self.assertEqual(ExtensionType.HAS_SIGNING_KEY, extension.type)
self.assertEqual([], extension.flags)
self.assertEqual(0, extension.flag_int)
self.assertTrue(extension.data.startswith(b'g\xa6\xb5Q\xa6\xd2'))
self.assertEqual('destiny', desc.nickname)
self.assertEqual('F65E0196C94DFFF48AFBF2F5F9E3E19AAE583FD0', desc.fingerprint)
self.assertEqual('94.242.246.23', desc.address)
self.assertEqual(9001, desc.or_port)
self.assertEqual(None, desc.socks_port)
self.assertEqual(443, desc.dir_port)
self.assertTrue('bWPo2fIzo3uOywfoM' in desc.ed25519_certificate)
self.assertEqual('Z6a1UabSK+N21j6NnyM6N7jssH6DK68qa6W5uB4QpGQ', desc.ed25519_master_key)
self.assertEqual('w+cKNZTlL7vz/4WgYdFUblzJy3VdTw0mfFK4N3SPFCt20fNKt9SgiZ5V/2ai3kgGsc6oCsyUesSiYtPcTXMLCw', desc.ed25519_signature)
self.assertEqual(b'Tor 0.2.7.2-alpha-dev on Linux', desc.platform)
self.assertEqual(stem.version.Version('0.2.7.2-alpha-dev'), desc.tor_version)
self.assertEqual('Linux', desc.operating_system)
self.assertEqual(1362680, desc.uptime)
self.assertEqual(datetime.datetime(2015, 8, 22, 15, 21, 45), desc.published)
self.assertEqual(b'0x02225522 Frenn vun der Enn (FVDE) ', desc.contact)
self.assertEqual(['1', '2'], desc.link_protocols)
self.assertEqual(['1'], desc.circuit_protocols)
self.assertEqual(False, desc.hibernating)
self.assertEqual(False, desc.allow_single_hop_exits)
self.assertEqual(False, desc.allow_tunneled_dir_requests)
self.assertEqual(False, desc.extra_info_cache)
self.assertEqual('44E9B679AF0B4EB09296985BAF4066AE9CA5BB93', desc.extra_info_digest)
self.assertEqual('r+roMxhsjd1GPpn5knQoBvtE9Rhsv8zQHCqiYL6u2CA', desc.extra_info_sha256_digest)
self.assertEqual(['2'], desc.hidden_service_dir)
self.assertEqual(family, desc.family)
self.assertEqual(149715200, desc.average_bandwidth)
self.assertEqual(1048576000, desc.burst_bandwidth)
self.assertEqual(51867731, desc.observed_bandwidth)
self.assertTrue(desc.exit_policy is not None)
self.assertEqual(stem.exit_policy.MicroExitPolicy('reject 25,465,587,10000,14464'), desc.exit_policy_v6)
self.assertTrue('MIGJAoGBAKpPOe' in desc.onion_key)
self.assertTrue('iW8BqwH5VKqZai' in desc.onion_key_crosscert)
self.assertTrue('AQoABhtwAWemtV' in desc.ntor_onion_key_crosscert)
self.assertEqual('0', desc.ntor_onion_key_crosscert_sign)
self.assertTrue('MIGJAoGBAOUS7x' in desc.signing_key)
self.assertTrue('y72z1dZOYxVQVL' in desc.signature)
self.assertEqual('B5E441051D139CCD84BC765D130B01E44DAC29AD', desc.digest())
self.assertEqual([], desc.get_unrecognized_lines())
@patch('time.time', Mock(return_value = time.mktime(datetime.date(2020, 1, 1).timetuple())))
def test_with_ed25519_expired_cert(self):
"""
Parses a server descriptor with an expired ed25519 certificate
"""
desc_text = open(get_resource('bridge_descriptor_with_ed25519'), 'rb').read()
desc_iter = stem.descriptor.server_descriptor._parse_file(io.BytesIO(desc_text), validate = True)
self.assertRaises(ValueError, list, desc_iter)
def test_bridge_with_ed25519(self):
"""
Parses a bridge descriptor with ed25519.
"""
with open(get_resource('bridge_descriptor_with_ed25519'), 'rb') as descriptor_file:
desc = next(stem.descriptor.parse_file(descriptor_file, validate = True))
self.assertEqual('ChandlerObfs11', desc.nickname)
self.assertEqual('678912ABD7398DF8EFC8FA2BC7DEF610710360C4', desc.fingerprint)
self.assertEqual('10.162.85.172', desc.address)
self.assertFalse(hasattr(desc, 'ed25519_certificate'))
self.assertEqual('lgIuiAJCoXPRwWoHgG4ZAoKtmrv47aPr4AsbmESj8AA', desc.ed25519_certificate_hash)
self.assertEqual('OB/fqLD8lYmjti09R+xXH/D4S2qlizxdZqtudnsunxE', desc.router_digest_sha256)
self.assertEqual([], desc.get_unrecognized_lines())
def test_cr_in_contact_line(self):
"""
Parses a descriptor with a huge contact line containing anomalous carriage
returns ('\r' entries).
"""
with open(get_resource('cr_in_contact_line'), 'rb') as descriptor_file:
desc = next(stem.descriptor.parse_file(descriptor_file, 'server-descriptor 1.0', validate = True))
self.assertEqual('pogonip', desc.nickname)
self.assertEqual('6DABD62BC65D4E6FE620293157FC76968DAB9C9B', desc.fingerprint)
self.assertEqual('75.5.248.48', desc.address)
# the contact info block is huge so just checking the start and end,
# including some of the embedded carriage returns
contact_start = b'jie1 at pacbell dot net -----BEGIN PGP PUBLIC KEY BLOCK-----\rVersion:'
contact_end = b'YFRk3NhCY=\r=Xaw3\r-----END PGP PUBLIC KEY BLOCK-----'
self.assertTrue(desc.contact.startswith(contact_start))
self.assertTrue(desc.contact.endswith(contact_end))
def test_negative_uptime(self):
"""
Parses a descriptor where we are tolerant of a negative uptime, and another
where we shouldn't be.
"""
with open(get_resource('negative_uptime'), 'rb') as descriptor_file:
desc = next(stem.descriptor.parse_file(descriptor_file, 'server-descriptor 1.0', validate = True))
self.assertEqual('TipTor', desc.nickname)
self.assertEqual('137962D4931DBF08A24E843288B8A155D6D2AEDD', desc.fingerprint)
self.assertEqual('62.99.247.83', desc.address)
# modify the relay version so it's after when the negative uptime bug
# should appear
descriptor_contents = desc.get_bytes().replace(b'Tor 0.1.1.25', b'Tor 0.1.2.7')
self.assertRaises(ValueError, stem.descriptor.server_descriptor.RelayDescriptor, descriptor_contents, True)
def test_bridge_descriptor(self):
"""
Parses a bridge descriptor.
"""
with open(get_resource('bridge_descriptor'), 'rb') as descriptor_file:
desc = next(stem.descriptor.parse_file(descriptor_file, 'bridge-server-descriptor 1.0', validate = True))
self.assertEqual('Unnamed', desc.nickname)
self.assertEqual('4ED573582B16ACDAF6E42AA044A038F83A7F6333', desc.fingerprint)
self.assertEqual('10.18.111.71', desc.address)
self.assertEqual(9001, desc.or_port)
self.assertEqual(None, desc.socks_port)
self.assertEqual(None, desc.dir_port)
self.assertEqual(b'Tor 0.2.0.26-rc (r14597) on Linux i686', desc.platform)
self.assertEqual(stem.version.Version('0.2.0.26-rc'), desc.tor_version)
self.assertEqual('Linux i686', desc.operating_system)
self.assertEqual(204, desc.uptime)
self.assertEqual(datetime.datetime(2008, 5, 20, 19, 45, 0), desc.published)
self.assertEqual(None, desc.contact)
self.assertEqual(['1', '2'], desc.link_protocols)
self.assertEqual(['1'], desc.circuit_protocols)
self.assertEqual(False, desc.hibernating)
self.assertEqual(False, desc.allow_single_hop_exits)
self.assertEqual(False, desc.allow_tunneled_dir_requests)
self.assertEqual(True, desc.extra_info_cache)
self.assertEqual('BB1F13AA431421BEA29B840A2E33BB1C31C2990B', desc.extra_info_digest)
self.assertEqual(None, desc.extra_info_sha256_digest)
self.assertEqual(None, desc.hidden_service_dir)
self.assertEqual(BridgeDistribution.ANY, desc.bridge_distribution)
self.assertEqual(set(), desc.family)
self.assertEqual(3220480, desc.average_bandwidth)
self.assertEqual(6441984, desc.burst_bandwidth)
self.assertEqual(59408, desc.observed_bandwidth)
self.assertEqual(stem.exit_policy.ExitPolicy('reject *:*'), desc.exit_policy)
self.assertEqual('00F1CD29AD308A59A9AB5A88B49ECB46E0F215FD', desc.digest())
self.assertEqual([], desc.get_unrecognized_lines())
def test_minimal_relay_descriptor(self):
"""
Basic sanity check that we can parse a relay server descriptor with minimal
attributes.
"""
desc = RelayDescriptor.create({'router': 'caerSidi 71.35.133.197 9001 0 0'})
self.assertEqual('caerSidi', desc.nickname)
self.assertEqual('71.35.133.197', desc.address)
self.assertEqual(None, desc.fingerprint)
def test_with_opt(self):
"""
Includes an 'opt ' entry.
"""
desc = RelayDescriptor.create({'opt': 'contact www.atagar.com/contact/'})
self.assertEqual(b'www.atagar.com/contact/', desc.contact)
def test_unrecognized_line(self):
"""
Includes unrecognized content in the descriptor.
"""
desc = RelayDescriptor.create({'pepperjack': 'is oh so tasty!'})
self.assertEqual(['pepperjack is oh so tasty!'], desc.get_unrecognized_lines())
def test_proceeding_line(self):
"""
Includes a line prior to the 'router' entry.
"""
desc_text = b'hibernate 1\n' + RelayDescriptor.content()
expect_invalid_attr_for_text(self, desc_text)
def test_trailing_line(self):
"""
Includes a line after the 'router-signature' entry.
"""
desc_text = RelayDescriptor.content() + b'\nhibernate 1'
expect_invalid_attr_for_text(self, desc_text)
def test_nickname_missing(self):
"""
Constructs with a malformed router entry.
"""
expect_invalid_attr(self, {'router': ' 71.35.133.197 9001 0 0'}, 'nickname')
def test_nickname_too_long(self):
"""
Constructs with a nickname that is an invalid length.
"""
expect_invalid_attr(self, {'router': 'saberrider2008ReallyLongNickname 71.35.133.197 9001 0 0'}, 'nickname')
def test_nickname_invalid_char(self):
"""
Constructs with an invalid relay nickname.
"""
expect_invalid_attr(self, {'router': '$aberrider2008 71.35.133.197 9001 0 0'}, 'nickname')
def test_address_malformed(self):
"""
Constructs with an invalid ip address.
"""
expect_invalid_attr(self, {'router': 'caerSidi 371.35.133.197 9001 0 0'}, 'address')
def test_port_too_high(self):
"""
Constructs with an ORPort that is too large.
"""
expect_invalid_attr(self, {'router': 'caerSidi 71.35.133.197 900001 0 0'}, 'or_port')
def test_port_malformed(self):
"""
Constructs with an ORPort that isn't numeric.
"""
expect_invalid_attr(self, {'router': 'caerSidi 71.35.133.197 900a1 0 0'}, 'or_port')
def test_port_newline(self):
"""
Constructs with a newline replacing the ORPort.
"""
expect_invalid_attr(self, {'router': 'caerSidi 71.35.133.197 \n 0 0'}, 'or_port')
def test_platform_empty(self):
"""
Constructs with an empty platform entry.
"""
desc_text = RelayDescriptor.content({'platform': ''})
desc = RelayDescriptor(desc_text, validate = False)
self.assertEqual(b'', desc.platform)
# does the same but with 'platform ' replaced with 'platform'
desc_text = desc_text.replace(b'platform ', b'platform')
desc = RelayDescriptor(desc_text, validate = False)
self.assertEqual(b'', desc.platform)
def test_platform_for_node_tor(self):
"""
Parse a platform line belonging to a node-Tor relay.
"""
desc = RelayDescriptor.create({'platform': 'node-Tor 0.1.0 on Linux x86_64'})
self.assertEqual(b'node-Tor 0.1.0 on Linux x86_64', desc.platform)
self.assertEqual(stem.version.Version('0.1.0'), desc.tor_version)
self.assertEqual('Linux x86_64', desc.operating_system)
def test_protocols_no_circuit_versions(self):
"""
Constructs with a protocols line without circuit versions.
"""
expect_invalid_attr(self, {'opt': 'protocols Link 1 2'}, 'circuit_protocols')
@patch('stem.prereq.is_crypto_available', Mock(return_value = False))
def test_published_leap_year(self):
"""
Constructs with a published entry for a leap year, and when the date is
invalid.
"""
expect_invalid_attr(self, {'published': '2011-02-29 04:03:19'}, 'published')
desc = RelayDescriptor.create({'published': '2012-02-29 04:03:19'})
self.assertEqual(datetime.datetime(2012, 2, 29, 4, 3, 19), desc.published)
def test_published_no_time(self):
"""
Constructs with a published entry without a time component.
"""
expect_invalid_attr(self, {'published': '2012-01-01'}, 'published')
def test_read_and_write_history(self):
"""
Parses a read-history and write-history entry. This is now a deprecated
field for relay server descriptors but is still found in archives and
extra-info descriptors.
"""
for field in ('read-history', 'write-history'):
value = '2005-12-16 18:00:48 (900 s) 81,8848,8927,8927,83,8848'
desc = RelayDescriptor.create({'opt %s' % field: value})
if field == 'read-history':
attr = (desc.read_history_end, desc.read_history_interval, desc.read_history_values)
else:
attr = (desc.write_history_end, desc.write_history_interval, desc.write_history_values)
expected_end = datetime.datetime(2005, 12, 16, 18, 0, 48)
expected_values = [81, 8848, 8927, 8927, 83, 8848]
self.assertEqual(expected_end, attr[0])
self.assertEqual(900, attr[1])
self.assertEqual(expected_values, attr[2])
def test_read_history_empty(self):
"""
Parses a read-history with an empty value.
"""
desc = RelayDescriptor.create({'opt read-history': '2005-12-17 01:23:11 (900 s) '})
self.assertEqual(datetime.datetime(2005, 12, 17, 1, 23, 11), desc.read_history_end)
self.assertEqual(900, desc.read_history_interval)
self.assertEqual([], desc.read_history_values)
@patch('stem.prereq.is_crypto_available', Mock(return_value = False))
def test_annotations(self):
"""
Checks that content before a descriptor are parsed as annotations.
"""
desc_text = b'@pepperjack very tasty\n@mushrooms not so much\n'
desc_text += RelayDescriptor.content()
desc_text += b'\ntrailing text that should be invalid, ho hum'
# running _parse_file should provide an iterator with a single descriptor
desc_iter = stem.descriptor.server_descriptor._parse_file(io.BytesIO(desc_text), validate = True)
self.assertRaises(ValueError, list, desc_iter)
desc_text = b'@pepperjack very tasty\n@mushrooms not so much\n'
desc_text += RelayDescriptor.content({'router': 'caerSidi 71.35.133.197 9001 0 0'})
desc_iter = stem.descriptor.server_descriptor._parse_file(io.BytesIO(desc_text))
desc_entries = list(desc_iter)
self.assertEqual(1, len(desc_entries))
desc = desc_entries[0]
self.assertEqual('caerSidi', desc.nickname)
self.assertEqual(b'@pepperjack very tasty', desc.get_annotation_lines()[0])
self.assertEqual(b'@mushrooms not so much', desc.get_annotation_lines()[1])
self.assertEqual({b'@pepperjack': b'very tasty', b'@mushrooms': b'not so much'}, desc.get_annotations())
self.assertEqual([], desc.get_unrecognized_lines())
def test_duplicate_field(self):
"""
Constructs with a field appearing twice.
"""
desc_text = RelayDescriptor.content({'': ''})
desc_text = desc_text.replace(b'', b'contact foo\ncontact bar')
expect_invalid_attr_for_text(self, desc_text, 'contact', b'foo')
def test_missing_required_attr(self):
"""
Test making a descriptor with a missing required attribute.
"""
for attr in stem.descriptor.server_descriptor.REQUIRED_FIELDS:
desc_text = RelayDescriptor.content(exclude = [attr])
self.assertRaises(ValueError, RelayDescriptor, desc_text, True)
# check that we can still construct it without validation
desc = RelayDescriptor(desc_text, validate = False)
# for one of them checks that the corresponding values are None
if attr == 'router':
self.assertEqual(None, desc.nickname)
self.assertEqual(None, desc.address)
self.assertEqual(None, desc.or_port)
self.assertEqual(None, desc.socks_port)
self.assertEqual(None, desc.dir_port)
def test_fingerprint_invalid(self):
"""
Checks that, with a correctly formed fingerprint, we'll fail validation if
it doesn't match the hash of our signing key.
"""
fingerprint = '4F0C 867D F0EF 6816 0568 C826 838F 482C EA7C FE45'
expect_invalid_attr(self, {'opt fingerprint': fingerprint}, 'fingerprint', fingerprint.replace(' ', ''))
def test_with_bridge_distribution(self):
"""
Include a preferred method of bridge distribution.
"""
desc = RelayDescriptor.create({'bridge-distribution-request': 'email'})
self.assertEqual(BridgeDistribution.EMAIL, desc.bridge_distribution)
def test_ipv6_policy(self):
"""
Checks a 'ipv6-policy' line.
"""
desc = RelayDescriptor.create({'ipv6-policy': 'accept 22-23,53,80,110'})
self.assertEqual(stem.exit_policy.MicroExitPolicy('accept 22-23,53,80,110'), desc.exit_policy_v6)
def test_extrainfo_sha256_digest(self):
"""
Extrainfo descriptor line with both a hex and base64 encoded sha256 digest.
"""
desc = RelayDescriptor.create({'extra-info-digest': '03272BF7C68484AFBDA508DAE3734D809E4A5BC4 DWMz1AEdqPlcroubwx3lPEoGbT+oX7S2BH653sPIqfI'})
self.assertEqual('03272BF7C68484AFBDA508DAE3734D809E4A5BC4', desc.extra_info_digest)
self.assertEqual('DWMz1AEdqPlcroubwx3lPEoGbT+oX7S2BH653sPIqfI', desc.extra_info_sha256_digest)
def test_protocols(self):
"""
Checks a 'proto' line.
"""
desc = RelayDescriptor.create({'proto': 'Cons=1 Desc=1 DirCache=1 HSDir=1 HSIntro=3 HSRend=1 Link=1-4 LinkAuth=1 Microdesc=1 Relay=1-2'})
self.assertEqual({'Cons': [1], 'Desc': [1], 'DirCache': [1], 'HSDir': [1], 'HSIntro': [3], 'HSRend': [1], 'Link': [1, 2, 3, 4], 'LinkAuth': [1], 'Microdesc': [1], 'Relay': [1, 2]}, desc.protocols)
def test_protocols_with_no_mapping(self):
"""
Checks a 'proto' line when it's not key=value pairs.
"""
exc_msg = "Protocol entires are expected to be a series of 'key=value' pairs but was: proto Desc Link=1-4"
self.assertRaisesRegexp(ValueError, exc_msg, RelayDescriptor.create, {'proto': 'Desc Link=1-4'})
def test_parse_with_non_int_version(self):
"""
Checks a 'proto' line with non-numeric content.
"""
exc_msg = 'Protocol values should be a number or number range, but was: proto Desc=hi Link=1-4'
self.assertRaisesRegexp(ValueError, exc_msg, RelayDescriptor.create, {'proto': 'Desc=hi Link=1-4'})
def test_ntor_onion_key(self):
"""
Checks a 'ntor-onion-key' line.
"""
desc = RelayDescriptor.create({'ntor-onion-key': 'Od2Sj3UXFyDjwESLXk6fhatqW9z/oBL/vAKJ+tbDqUU='})
self.assertEqual('Od2Sj3UXFyDjwESLXk6fhatqW9z/oBL/vAKJ+tbDqUU=', desc.ntor_onion_key)
def test_minimal_bridge_descriptor(self):
"""
Basic sanity check that we can parse a descriptor with minimal attributes.
"""
desc = BridgeDescriptor.create()
self.assertTrue(desc.nickname.startswith('Unnamed'))
self.assertEqual(None, desc.fingerprint)
self.assertEqual('006FD96BA35E7785A6A3B8B75FE2E2435A13BDB4', desc.digest())
# check that we don't have crypto fields
self.assertRaises(AttributeError, getattr, desc, 'onion_key')
self.assertRaises(AttributeError, getattr, desc, 'signing_key')
self.assertRaises(AttributeError, getattr, desc, 'signature')
def test_bridge_unsanitized(self):
"""
Targeted check that individual unsanitized attributes will be detected.
"""
unsanitized_attr = [
{'router': 'Unnamed 75.45.227.253 9001 0 0'},
{'contact': 'Damian'},
{'or-address': '71.35.133.197:9001'},
{'or-address': '[12ab:2e19:3bcf::02:9970]:9001'},
{'onion-key': '\n-----BEGIN RSA PUBLIC KEY-----%s-----END RSA PUBLIC KEY-----' % stem.descriptor.CRYPTO_BLOB},
{'signing-key': '\n-----BEGIN RSA PUBLIC KEY-----%s-----END RSA PUBLIC KEY-----' % stem.descriptor.CRYPTO_BLOB},
{'router-signature': '\n-----BEGIN SIGNATURE-----%s-----END SIGNATURE-----' % stem.descriptor.CRYPTO_BLOB},
]
for attr in unsanitized_attr:
desc = BridgeDescriptor.create(attr)
self.assertFalse(desc.is_scrubbed())
def test_bridge_unsanitized_relay(self):
"""
Checks that parsing a normal relay descriptor as a bridge will fail due to
its unsanatized content.
"""
desc_text = RelayDescriptor.content({'router-digest': '006FD96BA35E7785A6A3B8B75FE2E2435A13BDB4'})
desc = BridgeDescriptor(desc_text)
self.assertFalse(desc.is_scrubbed())
def test_router_digest(self):
"""
Constructs with a router-digest line with both valid and invalid contents.
"""
# checks with valid content
router_digest = '068A2E28D4C934D9490303B7A645BA068DCA0504'
desc = BridgeDescriptor.create({'router-digest': router_digest})
self.assertEqual(router_digest, desc.digest())
# checks when missing
desc_text = BridgeDescriptor.content(exclude = ['router-digest'])
self.assertRaises(ValueError, BridgeDescriptor, desc_text, True)
# check that we can still construct it without validation
desc = BridgeDescriptor(desc_text, validate = False)
self.assertEqual(None, desc.digest())
# checks with invalid content
test_values = (
'',
'006FD96BA35E7785A6A3B8B75FE2E2435A13BDB44',
'006FD96BA35E7785A6A3B8B75FE2E2435A13BDB',
'006FD96BA35E7785A6A3B8B75FE2E2435A13BDBH',
)
for value in test_values:
desc_text = BridgeDescriptor.content({'router-digest': value})
self.assertRaises(ValueError, BridgeDescriptor, desc_text, True)
desc = BridgeDescriptor(desc_text, validate = False)
self.assertEqual(None, desc.digest())
def test_or_address_v4(self):
"""
Constructs a bridge descriptor with a sanatized IPv4 or-address entry.
"""
desc = BridgeDescriptor.create({'or-address': '10.45.227.253:9001'})
self.assertEqual([('10.45.227.253', 9001, False)], desc.or_addresses)
def test_or_address_v6(self):
"""
Constructs a bridge descriptor with a sanatized IPv6 or-address entry.
"""
desc = BridgeDescriptor.create({'or-address': '[fd9f:2e19:3bcf::02:9970]:9001'})
self.assertEqual([('fd9f:2e19:3bcf::02:9970', 9001, True)], desc.or_addresses)
def test_or_address_multiple(self):
"""
Constructs a bridge descriptor with multiple or-address entries and multiple ports.
"""
desc_text = b'\n'.join((
BridgeDescriptor.content(),
b'or-address 10.45.227.253:9001',
b'or-address [fd9f:2e19:3bcf::02:9970]:443',
))
expected_or_addresses = [
('10.45.227.253', 9001, False),
('fd9f:2e19:3bcf::02:9970', 443, True),
]
desc = BridgeDescriptor(desc_text)
self.assertEqual(expected_or_addresses, desc.or_addresses)
def test_pickleability(self):
"""
Checks that we can unpickle lazy loaded server descriptors.
"""
with open(get_resource('example_descriptor'), 'rb') as descriptor_file:
desc = next(stem.descriptor.parse_file(descriptor_file, 'server-descriptor 1.0'))
encoded_desc = pickle.dumps(desc)
restored_desc = pickle.loads(encoded_desc)
self.assertEqual('caerSidi', restored_desc.nickname)
self.assertEqual('A7569A83B5706AB1B1A9CB52EFF7D2D32E4553EB', restored_desc.fingerprint)
self.assertEqual('71.35.133.197', restored_desc.address)
self.assertEqual(9001, restored_desc.or_port)
self.assertEqual(None, restored_desc.socks_port)
stem-1.6.0/test/unit/descriptor/extrainfo_descriptor.py 0000664 0001750 0001750 00000070713 13125773507 024155 0 ustar atagar atagar 0000000 0000000 """
Unit tests for stem.descriptor.extrainfo_descriptor.
"""
import datetime
import functools
import re
import unittest
import stem.descriptor
import test.require
from stem.descriptor.extrainfo_descriptor import (
RelayExtraInfoDescriptor,
BridgeExtraInfoDescriptor,
DirResponse,
DirStat,
)
from test.unit.descriptor import (
get_resource,
base_expect_invalid_attr,
base_expect_invalid_attr_for_text,
)
expect_invalid_attr = functools.partial(base_expect_invalid_attr, RelayExtraInfoDescriptor, 'nickname', 'Unnamed')
expect_invalid_attr_for_text = functools.partial(base_expect_invalid_attr_for_text, RelayExtraInfoDescriptor, 'nickname', 'Unnamed')
class TestExtraInfoDescriptor(unittest.TestCase):
def test_metrics_relay_descriptor(self):
"""
Parses and checks our results against an extrainfo descriptor from metrics.
"""
descriptor_file = open(get_resource('extrainfo_relay_descriptor'), 'rb')
expected_signature = """-----BEGIN SIGNATURE-----
K5FSywk7qvw/boA4DQcqkls6Ize5vcBYfhQ8JnOeRQC9+uDxbnpm3qaYN9jZ8myj
k0d2aofcVbHr4fPQOSST0LXDrhFl5Fqo5um296zpJGvRUeO6S44U/EfJAGShtqWw
7LZqklu+gVvhMKREpchVqlAwXkWR44VENm24Hs+mT3M=
-----END SIGNATURE-----"""
desc = next(stem.descriptor.parse_file(descriptor_file, 'extra-info 1.0'))
self.assertEqual('NINJA', desc.nickname)
self.assertEqual('B2289C3EAB83ECD6EB916A2F481A02E6B76A0A48', desc.fingerprint)
self.assertEqual(datetime.datetime(2012, 5, 5, 17, 3, 50), desc.published)
self.assertEqual(datetime.datetime(2012, 5, 5, 17, 2, 45), desc.read_history_end)
self.assertEqual(900, desc.read_history_interval)
self.assertEqual(datetime.datetime(2012, 5, 5, 17, 2, 45), desc.write_history_end)
self.assertEqual(900, desc.write_history_interval)
self.assertEqual(datetime.datetime(2012, 5, 5, 17, 2, 45), desc.dir_read_history_end)
self.assertEqual(900, desc.dir_read_history_interval)
self.assertEqual(datetime.datetime(2012, 5, 5, 17, 2, 45), desc.dir_write_history_end)
self.assertEqual(900, desc.dir_write_history_interval)
self.assertEqual(expected_signature, desc.signature)
self.assertEqual('00A57A9AAB5EA113898E2DD02A755E31AFC27227', desc.digest())
self.assertEqual([], desc.get_unrecognized_lines())
# The read-history, write-history, dirreq-read-history, and
# dirreq-write-history lines are pretty long so just checking
# the initial contents for the line and parsed values.
read_values_start = [3309568, 9216, 41984, 27648, 123904]
self.assertEqual(read_values_start, desc.read_history_values[:5])
write_values_start = [1082368, 19456, 50176, 272384, 485376]
self.assertEqual(write_values_start, desc.write_history_values[:5])
dir_read_values_start = [0, 0, 0, 0, 33792, 27648, 48128]
self.assertEqual(dir_read_values_start, desc.dir_read_history_values[:7])
dir_write_values_start = [0, 0, 0, 227328, 349184, 382976, 738304]
self.assertEqual(dir_write_values_start, desc.dir_write_history_values[:7])
def test_metrics_bridge_descriptor(self):
"""
Parses and checks our results against an extrainfo bridge descriptor from
metrics.
"""
descriptor_file = open(get_resource('extrainfo_bridge_descriptor'), 'rb')
expected_dir_v2_responses = {
DirResponse.OK: 0,
DirResponse.UNAVAILABLE: 0,
DirResponse.NOT_FOUND: 0,
DirResponse.NOT_MODIFIED: 0,
DirResponse.BUSY: 0,
}
expected_dir_v3_responses = {
DirResponse.OK: 72,
DirResponse.NOT_ENOUGH_SIGS: 0,
DirResponse.UNAVAILABLE: 0,
DirResponse.NOT_FOUND: 0,
DirResponse.NOT_MODIFIED: 0,
DirResponse.BUSY: 0,
}
desc = next(stem.descriptor.parse_file(descriptor_file, 'bridge-extra-info 1.0'))
self.assertEqual('ec2bridgereaac65a3', desc.nickname)
self.assertEqual('1EC248422B57D9C0BD751892FE787585407479A4', desc.fingerprint)
self.assertEqual(datetime.datetime(2012, 6, 8, 2, 21, 27), desc.published)
self.assertEqual(datetime.datetime(2012, 6, 8, 2, 10, 38), desc.read_history_end)
self.assertEqual(900, desc.read_history_interval)
self.assertEqual(datetime.datetime(2012, 6, 8, 2, 10, 38), desc.write_history_end)
self.assertEqual(900, desc.write_history_interval)
self.assertEqual(datetime.datetime(2012, 6, 8, 2, 10, 38), desc.dir_read_history_end)
self.assertEqual(900, desc.dir_read_history_interval)
self.assertEqual(datetime.datetime(2012, 6, 8, 2, 10, 38), desc.dir_write_history_end)
self.assertEqual(900, desc.dir_write_history_interval)
self.assertEqual('00A2AECCEAD3FEE033CFE29893387143146728EC', desc.digest())
self.assertEqual([], desc.get_unrecognized_lines())
read_values_start = [337920, 437248, 3995648, 48726016]
self.assertEqual(read_values_start, desc.read_history_values[:4])
write_values_start = [343040, 991232, 5649408, 49548288]
self.assertEqual(write_values_start, desc.write_history_values[:4])
dir_read_values_start = [0, 71680, 99328, 25600]
self.assertEqual(dir_read_values_start, desc.dir_read_history_values[:4])
dir_write_values_start = [5120, 664576, 2419712, 578560]
self.assertEqual(dir_write_values_start, desc.dir_write_history_values[:4])
self.assertEqual({}, desc.dir_v2_requests)
self.assertEqual({}, desc.dir_v3_requests)
self.assertEqual(expected_dir_v2_responses, desc.dir_v2_responses)
self.assertEqual(expected_dir_v3_responses, desc.dir_v3_responses)
self.assertEqual({}, desc.dir_v2_responses_unknown)
self.assertEqual({}, desc.dir_v2_responses_unknown)
@test.require.cryptography
def test_descriptor_signing(self):
RelayExtraInfoDescriptor.create(sign = True)
self.assertRaisesRegexp(NotImplementedError, 'Signing of BridgeExtraInfoDescriptor not implemented', BridgeExtraInfoDescriptor.create, sign = True)
def test_multiple_metrics_bridge_descriptors(self):
"""
Check that we can read bridge descriptors when there's multiple in a file.
"""
descriptor_file = open(get_resource('extrainfo_bridge_descriptor_multiple'), 'rb')
desc_list = list(stem.descriptor.parse_file(descriptor_file))
self.assertEqual(6, len(desc_list))
self.assertEqual('909B07DB17E21D263C55794AB815BF1DB195FDD9', desc_list[0].fingerprint)
self.assertEqual('7F7798A3CBB0F643B1CFCE3FD4F2B7C553764498', desc_list[1].fingerprint)
self.assertEqual('B4869206C1EEA4A090FE614155BD6942701F80F1', desc_list[2].fingerprint)
self.assertEqual('C18896EB6274DC8123491FAE1DD17E1769C54C4F', desc_list[3].fingerprint)
self.assertEqual('478B4CB438302981DE9AAF246F48DBE57F69050A', desc_list[4].fingerprint)
self.assertEqual('25D9D52A0350B42E69C8AB7CE945DB1CA38DA0CF', desc_list[5].fingerprint)
def test_with_ed25519(self):
"""
Parses a descriptor with a ed25519 identity key.
"""
with open(get_resource('extrainfo_descriptor_with_ed25519'), 'rb') as descriptor_file:
desc = next(stem.descriptor.parse_file(descriptor_file, validate = True))
self.assertEqual('silverfoxden', desc.nickname)
self.assertEqual('4970B1DC3DBC8D82D7F1E43FF44B28DBF4765A4E', desc.fingerprint)
self.assertTrue('AQQABhz0AQFcf5tGWLvPvr' in desc.ed25519_certificate)
self.assertEqual('g6Zg7Er8K7C1etmt7p20INE1ExIvMRPvhwt6sjbLqEK+EtQq8hT+86hQ1xu7cnz6bHee+Zhhmcc4JamV4eiMAw', desc.ed25519_signature)
self.assertEqual([], desc.get_unrecognized_lines())
def test_bridge_with_ed25519(self):
"""
Parses a bridge descriptor with a ed25519 identity key.
"""
with open(get_resource('bridge_extrainfo_descriptor_with_ed25519'), 'rb') as descriptor_file:
desc = next(stem.descriptor.parse_file(descriptor_file, validate = True))
self.assertEqual('Unnamed', desc.nickname)
self.assertEqual('B8AB331047F1C1637EFE07FB1B94CCC0FE0ABFFA', desc.fingerprint)
self.assertFalse(hasattr(desc, 'ed25519_certificate'))
self.assertEqual('VigmhxML9uw8CT1XeGqZ8KLMhKk6AOKnChQt24usBbI', desc.ed25519_certificate_hash)
self.assertEqual('7DSOQz9eGgjDX6GT7qcrVViK8yqJD4aoEnuhdAgYtgA', desc.router_digest_sha256)
self.assertEqual([], desc.get_unrecognized_lines())
def test_nonascii_v3_reqs(self):
"""
Malformed descriptor with non-ascii content for the 'dirreq-v3-reqs' line.
"""
with open(get_resource('unparseable/extrainfo_nonascii_v3_reqs'), 'rb') as descriptor_file:
desc_generator = stem.descriptor.parse_file(descriptor_file, 'extra-info 1.0', validate = True)
exc_msg = "'dirreq-v3-reqs' line had non-ascii content: S?=4026597208,S?=4026597208,S?=4026597208,S?=4026597208,S?=4026597208,S?=4026597208,??=4026591624,6?=4026537520,6?=4026537520,6?=4026537520,us=8"
self.assertRaisesRegexp(ValueError, re.escape(exc_msg), next, desc_generator)
def test_minimal_extrainfo_descriptor(self):
"""
Basic sanity check that we can parse an extrainfo descriptor with minimal
attributes.
"""
desc = RelayExtraInfoDescriptor.create()
self.assertTrue(desc.nickname.startswith('Unnamed'))
def test_unrecognized_line(self):
"""
Includes unrecognized content in the descriptor.
"""
desc = RelayExtraInfoDescriptor.create({'pepperjack': 'is oh so tasty!'})
self.assertEqual(['pepperjack is oh so tasty!'], desc.get_unrecognized_lines())
def test_proceeding_line(self):
"""
Includes a line prior to the 'extra-info' entry.
"""
expect_invalid_attr_for_text(self, b'exit-streams-opened port=80\n' + RelayExtraInfoDescriptor.content())
def test_trailing_line(self):
"""
Includes a line after the 'router-signature' entry.
"""
expect_invalid_attr_for_text(self, RelayExtraInfoDescriptor.content() + b'\nexit-streams-opened port=80')
def test_extrainfo_line_missing_fields(self):
"""
Checks that validation catches when the extra-info line is missing fields
and that without validation both the nickname and fingerprint are left as
None.
"""
test_entries = (
'ninja',
'ninja ',
'B2289C3EAB83ECD6EB916A2F481A02E6B76A0A48',
' B2289C3EAB83ECD6EB916A2F481A02E6B76A0A48',
)
for entry in test_entries:
desc = expect_invalid_attr(self, {'extra-info': entry}, 'nickname')
self.assertEqual(None, desc.nickname)
self.assertEqual(None, desc.fingerprint)
def test_geoip_db_digest(self):
"""
Parses the geoip-db-digest and geoip6-db-digest lines with valid and
invalid data.
"""
geoip_db_digest = '916A3CA8B7DF61473D5AE5B21711F35F301CE9E8'
desc = RelayExtraInfoDescriptor.create({'geoip-db-digest': geoip_db_digest})
self.assertEqual(geoip_db_digest, desc.geoip_db_digest)
desc = RelayExtraInfoDescriptor.create({'geoip6-db-digest': geoip_db_digest})
self.assertEqual(geoip_db_digest, desc.geoip6_db_digest)
test_entries = (
'',
'916A3CA8B7DF61473D5AE5B21711F35F301CE9E',
'916A3CA8B7DF61473D5AE5B21711F35F301CE9E88',
'916A3CA8B7DF61473D5AE5B21711F35F301CE9EG',
'916A3CA8B7DF61473D5AE5B21711F35F301CE9E-',
)
for entry in test_entries:
expect_invalid_attr(self, {'geoip-db-digest': entry}, 'geoip_db_digest')
expect_invalid_attr(self, {'geoip6-db-digest': entry}, 'geoip6_db_digest')
def test_cell_circuits_per_decile(self):
"""
Parses the cell-circuits-per-decile line with valid and invalid data.
"""
test_entries = (
('0', 0),
('11', 11),
)
for entry in ('0', '11', '25'):
desc = RelayExtraInfoDescriptor.create({'cell-circuits-per-decile': entry})
self.assertEqual(int(entry), desc.cell_circuits_per_decile)
test_entries = (
'',
' ',
'-5',
'blarg',
)
for entry in test_entries:
expect_invalid_attr(self, {'cell-circuits-per-decile': entry}, 'cell_circuits_per_decile')
def test_dir_response_lines(self):
"""
Parses the dirreq-v2-resp and dirreq-v3-resp lines with valid and invalid
data.
"""
for keyword in ('dirreq-v2-resp', 'dirreq-v3-resp'):
attr = keyword.replace('-', '_').replace('dirreq', 'dir').replace('resp', 'responses')
unknown_attr = attr + '_unknown'
test_value = 'ok=0,unavailable=0,not-found=984,not-modified=0,something-new=7'
desc = RelayExtraInfoDescriptor.create({keyword: test_value})
self.assertEqual(0, getattr(desc, attr)[DirResponse.OK])
self.assertEqual(0, getattr(desc, attr)[DirResponse.UNAVAILABLE])
self.assertEqual(984, getattr(desc, attr)[DirResponse.NOT_FOUND])
self.assertEqual(0, getattr(desc, attr)[DirResponse.NOT_MODIFIED])
self.assertEqual(7, getattr(desc, unknown_attr)['something-new'])
test_entries = (
'ok=-4',
'ok:4',
'ok=4.not-found=3',
)
for entry in test_entries:
desc = expect_invalid_attr(self, {keyword: entry})
self.assertEqual(None, getattr(desc, attr))
self.assertEqual(None, getattr(desc, unknown_attr))
def test_dir_stat_lines(self):
"""
Parses the dirreq-v2-direct-dl, dirreq-v3-direct-dl, dirreq-v2-tunneled-dl,
and dirreq-v3-tunneled-dl lines with valid and invalid data.
"""
for keyword in ('dirreq-v2-direct-dl', 'dirreq-v2-direct-dl', 'dirreq-v2-tunneled-dl', 'dirreq-v2-tunneled-dl'):
attr = keyword.replace('-', '_').replace('dirreq', 'dir')
unknown_attr = attr + '_unknown'
test_value = 'complete=2712,timeout=32,running=4,min=741,d1=14507,d2=22702,q1=28881,d3=38277,d4=73729,md=111455,d6=168231,d7=257218,q3=319833,d8=390507,d9=616301,something-new=11,max=29917857'
desc = RelayExtraInfoDescriptor.create({keyword: test_value})
self.assertEqual(2712, getattr(desc, attr)[DirStat.COMPLETE])
self.assertEqual(32, getattr(desc, attr)[DirStat.TIMEOUT])
self.assertEqual(4, getattr(desc, attr)[DirStat.RUNNING])
self.assertEqual(741, getattr(desc, attr)[DirStat.MIN])
self.assertEqual(14507, getattr(desc, attr)[DirStat.D1])
self.assertEqual(22702, getattr(desc, attr)[DirStat.D2])
self.assertEqual(28881, getattr(desc, attr)[DirStat.Q1])
self.assertEqual(38277, getattr(desc, attr)[DirStat.D3])
self.assertEqual(73729, getattr(desc, attr)[DirStat.D4])
self.assertEqual(111455, getattr(desc, attr)[DirStat.MD])
self.assertEqual(168231, getattr(desc, attr)[DirStat.D6])
self.assertEqual(257218, getattr(desc, attr)[DirStat.D7])
self.assertEqual(319833, getattr(desc, attr)[DirStat.Q3])
self.assertEqual(390507, getattr(desc, attr)[DirStat.D8])
self.assertEqual(616301, getattr(desc, attr)[DirStat.D9])
self.assertEqual(29917857, getattr(desc, attr)[DirStat.MAX])
self.assertEqual(11, getattr(desc, unknown_attr)['something-new'])
test_entries = (
'complete=-4',
'complete:4',
'complete=4.timeout=3',
)
for entry in test_entries:
desc = expect_invalid_attr(self, {keyword: entry})
self.assertEqual(None, getattr(desc, attr))
self.assertEqual(None, getattr(desc, unknown_attr))
def test_conn_bi_direct(self):
"""
Parses the conn-bi-direct line with valid and invalid data.
"""
desc = RelayExtraInfoDescriptor.create({'conn-bi-direct': '2012-05-03 12:07:50 (500 s) 277431,12089,0,2134'})
self.assertEqual(datetime.datetime(2012, 5, 3, 12, 7, 50), desc.conn_bi_direct_end)
self.assertEqual(500, desc.conn_bi_direct_interval)
self.assertEqual(277431, desc.conn_bi_direct_below)
self.assertEqual(12089, desc.conn_bi_direct_read)
self.assertEqual(0, desc.conn_bi_direct_write)
self.assertEqual(2134, desc.conn_bi_direct_both)
test_entries = (
'',
'2012-05-03',
'2012-05-03 12:07:60 (500 s)',
'2012-05-03 12:07:50 (500 s',
'2012-05-03 12:07:50 (500s)',
'2012-05-03 12:07:50 (500 s)11',
'2012-05-03 12:07:50 (500 s) 277431,12089,0',
'2012-05-03 12:07:50 (500 s) 277431,12089,0a,2134',
'2012-05-03 12:07:50 (500 s) -277431,12089,0,2134',
)
for entry in test_entries:
desc = expect_invalid_attr(self, {'conn-bi-direct': entry})
self.assertEqual(None, desc.conn_bi_direct_end)
self.assertEqual(None, desc.conn_bi_direct_interval)
self.assertEqual(None, desc.conn_bi_direct_below)
self.assertEqual(None, desc.conn_bi_direct_read)
self.assertEqual(None, desc.conn_bi_direct_write)
self.assertEqual(None, desc.conn_bi_direct_both)
def test_percentage_lines(self):
"""
Uses valid and invalid data to tests lines of the form...
"" num%
"""
for keyword in ('dirreq-v2-share', 'dirreq-v3-share'):
attr = keyword.replace('-', '_').replace('dirreq', 'dir')
test_entries = (
('0.00%', 0.0),
('0.01%', 0.0001),
('50%', 0.5),
('100.0%', 1.0),
)
for test_value, expected_value in test_entries:
desc = RelayExtraInfoDescriptor.create({keyword: test_value})
self.assertEqual(expected_value, getattr(desc, attr))
test_entries = (
(''),
(' '),
('100'),
('-5%'),
)
for entry in test_entries:
expect_invalid_attr(self, {keyword: entry}, attr)
def test_number_list_lines(self):
"""
Uses valid and invalid data to tests lines of the form...
"" num,...,num
"""
for keyword in ('cell-processed-cells', 'cell-queued-cells', 'cell-time-in-queue'):
attr = keyword.replace('-', '_')
test_entries = (
('', []),
(' ', []),
('0,0,0', [0.0, 0.0, 0.0]),
('2.3,-4.6,8.9,16.12,32.15', [2.3, -4.6, 8.9, 16.12, 32.15]),
)
for test_value, expected_value in test_entries:
desc = RelayExtraInfoDescriptor.create({keyword: test_value})
self.assertEqual(expected_value, getattr(desc, attr))
test_entries = (
(',,11', [11.0]),
('abc,5.7,def', [5.7]),
('blarg', []),
)
for entry, expected in test_entries:
expect_invalid_attr(self, {keyword: entry}, attr, expected)
def test_timestamp_lines(self):
"""
Uses valid and invalid data to tests lines of the form...
"" YYYY-MM-DD HH:MM:SS
"""
for keyword in ('published', 'geoip-start-time'):
attr = keyword.replace('-', '_')
desc = RelayExtraInfoDescriptor.create({keyword: '2012-05-03 12:07:50'})
self.assertEqual(datetime.datetime(2012, 5, 3, 12, 7, 50), getattr(desc, attr))
test_entries = (
'',
'2012-05-03 12:07:60',
'2012-05-03 ',
'2012-05-03',
)
for entry in test_entries:
expect_invalid_attr(self, {keyword: entry}, attr)
def test_timestamp_and_interval_lines(self):
"""
Uses valid and invalid data to tests lines of the form...
"" YYYY-MM-DD HH:MM:SS (NSEC s)
"""
for keyword in ('cell-stats-end', 'entry-stats-end', 'exit-stats-end', 'bridge-stats-end', 'dirreq-stats-end'):
end_attr = keyword.replace('-', '_').replace('dirreq', 'dir')
interval_attr = end_attr[:-4] + '_interval'
desc = RelayExtraInfoDescriptor.create({keyword: '2012-05-03 12:07:50 (500 s)'})
self.assertEqual(datetime.datetime(2012, 5, 3, 12, 7, 50), getattr(desc, end_attr))
self.assertEqual(500, getattr(desc, interval_attr))
test_entries = (
'',
'2012-05-03 ',
'2012-05-03',
'2012-05-03 12:07:60 (500 s)',
'2012-05-03 12:07:50 (500s)',
'2012-05-03 12:07:50 (500 s',
'2012-05-03 12:07:50 (500 )',
)
for entry in test_entries:
desc = expect_invalid_attr(self, {'entry-stats-end': entry})
self.assertEqual(None, desc.entry_stats_end)
self.assertEqual(None, desc.entry_stats_interval)
def test_timestamp_interval_and_value_lines(self):
"""
Uses valid and invalid data to tests lines of the form...
"" YYYY-MM-DD HH:MM:SS (NSEC s) NUM,NUM,NUM,NUM,NUM...
"""
for keyword in ('read-history', 'write-history', 'dirreq-read-history', 'dirreq-write-history'):
base_attr = keyword.replace('-', '_').replace('dirreq', 'dir')
end_attr = base_attr + '_end'
interval_attr = base_attr + '_interval'
values_attr = base_attr + '_values'
desc = RelayExtraInfoDescriptor.create({keyword: '2012-05-03 12:07:50 (500 s) 50,11,5'})
self.assertEqual(datetime.datetime(2012, 5, 3, 12, 7, 50), getattr(desc, end_attr))
self.assertEqual(500, getattr(desc, interval_attr))
self.assertEqual([50, 11, 5], getattr(desc, values_attr))
for test_value in ('', ' '):
desc = RelayExtraInfoDescriptor.create({'write-history': '2012-05-03 12:07:50 (500 s)%s' % test_value})
self.assertEqual(datetime.datetime(2012, 5, 3, 12, 7, 50), desc.write_history_end)
self.assertEqual(500, desc.write_history_interval)
self.assertEqual([], desc.write_history_values)
test_entries = (
'',
'2012-05-03',
'2012-05-03 12:07:60 (500 s)',
'2012-05-03 12:07:50 (500s)',
'2012-05-03 12:07:50 (500 s',
'2012-05-03 12:07:50 (500 s)11',
)
for entry in test_entries:
desc = expect_invalid_attr(self, {'write-history': entry})
self.assertEqual(None, desc.write_history_end)
self.assertEqual(None, desc.write_history_interval)
self.assertEqual(None, desc.write_history_values)
def test_port_mapping_lines(self):
"""
Uses valid and invalid data to tests lines of the form...
"" port=N,port=N,...
"""
for keyword in ('exit-kibibytes-written', 'exit-kibibytes-read', 'exit-streams-opened'):
attr = keyword.replace('-', '_')
test_entries = (
('', {}),
('443=100,other=111', {443: 100, 'other': 111}),
('80=115533759,443=1777,995=690', {80: 115533759, 443: 1777, 995: 690}),
)
for test_value, expected_value in test_entries:
desc = RelayExtraInfoDescriptor.create({keyword: test_value})
self.assertEqual(expected_value, getattr(desc, attr))
test_entries = (
'8000000=115533759',
'-80=115533759',
'80=-115533759',
'=115533759',
'80=',
'80,115533759',
)
for entry in test_entries:
expect_invalid_attr(self, {keyword: entry}, attr)
def test_hidden_service_stats_end(self):
"""
Exercise the hidserv-stats-end, which should be a simple date.
"""
desc = RelayExtraInfoDescriptor.create({'hidserv-stats-end': '2012-05-03 12:07:50'})
self.assertEqual(datetime.datetime(2012, 5, 3, 12, 7, 50), desc.hs_stats_end)
test_entries = (
'',
'2012',
'2012-05',
'2012-05-03',
'2012-05-03 12',
'2012-05-03 12:07',
'2012-05-03 12:07:-50',
)
for entry in test_entries:
expect_invalid_attr(self, {'hidserv-stats-end': entry}, 'hs_stats_end')
def test_hidden_service_stats(self):
"""
Check the 'hidserv-rend-relayed-cells' and 'hidserv-dir-onions-seen', which
share the same format.
"""
attributes = (
('hidserv-rend-relayed-cells', 'hs_rend_cells', 'hs_rend_cells_attr'),
('hidserv-dir-onions-seen', 'hs_dir_onions_seen', 'hs_dir_onions_seen_attr'),
)
test_entries = (
'',
'hello',
' key=value',
'40 key',
'40 key value',
'40 key key=value',
)
for keyword, stat_attr, extra_attr in attributes:
# just the numeric stat (no extra attributes)
desc = RelayExtraInfoDescriptor.create({keyword: '345'})
self.assertEqual(345, getattr(desc, stat_attr))
self.assertEqual({}, getattr(desc, extra_attr))
# values can be negative (#15276)
desc = RelayExtraInfoDescriptor.create({keyword: '-345'})
self.assertEqual(-345, getattr(desc, stat_attr))
self.assertEqual({}, getattr(desc, extra_attr))
# with extra attributes
desc = RelayExtraInfoDescriptor.create({keyword: '345 spiffy=true snowmen=neat'})
self.assertEqual(345, getattr(desc, stat_attr))
self.assertEqual({'spiffy': 'true', 'snowmen': 'neat'}, getattr(desc, extra_attr))
for entry in test_entries:
expect_invalid_attr(self, {keyword: entry}, stat_attr)
expect_invalid_attr(self, {keyword: entry}, extra_attr, {})
def test_padding_counts(self):
"""
Check the 'hidserv-dir-onions-seen' lines.
"""
desc = RelayExtraInfoDescriptor.create({'padding-counts': '2017-05-17 11:02:58 (86400 s) bin-size=10000 write-drop=0 write-pad=10000 write-total=10000 read-drop=0 read-pad=10000 read-total=3780000 enabled-read-pad=0 enabled-read-total=0 enabled-write-pad=0 enabled-write-total=0 max-chanpad-timers=0 non-numeric=test'})
self.assertEqual({
'bin-size': 10000,
'write-drop': 0,
'write-pad': 10000,
'write-total': 10000,
'read-drop': 0,
'read-pad': 10000,
'read-total': 3780000,
'enabled-read-pad': 0,
'enabled-read-total': 0,
'enabled-write-pad': 0,
'enabled-write-total': 0,
'max-chanpad-timers': 0,
'non-numeric': 'test', # presently all values are ints but the spec allows for anything
}, desc.padding_counts)
self.assertEqual(datetime.datetime(2017, 5, 17, 11, 2, 58), desc.padding_counts_end)
self.assertEqual(86400, desc.padding_counts_interval)
test_entries = (
'',
'2012-05-03',
'2012-05-03 12:07:60 (500 s)',
'2012-05-03 12:07:50 (500 s',
'2012-05-03 12:07:50 (500s)',
'2012-05-03 12:07:50 (500 s)bin-size=10',
'2012-05-03 12:07:50 (500 s) bin-size',
'2012-05-03 12:07:50 (500 s) bin-size=',
)
for entry in test_entries:
desc = expect_invalid_attr(self, {'padding-counts': entry})
self.assertEqual({}, desc.padding_counts)
self.assertEqual(None, desc.padding_counts_end)
self.assertEqual(None, desc.padding_counts_interval)
def test_locale_mapping_lines(self):
"""
Uses valid and invalid data to tests lines of the form...
"" CC=N,CC=N,...
"""
for keyword in ('dirreq-v2-ips', 'dirreq-v3-ips', 'dirreq-v2-reqs', 'dirreq-v3-reqs', 'geoip-client-origins', 'entry-ips', 'bridge-ips'):
attr = keyword.replace('-', '_').replace('dirreq', 'dir').replace('reqs', 'requests')
test_entries = (
('', {}),
('uk=5,de=3,jp=2', {'uk': 5, 'de': 3, 'jp': 2}),
)
for test_value, expected_value in test_entries:
desc = RelayExtraInfoDescriptor.create({keyword: test_value})
self.assertEqual(expected_value, getattr(desc, attr))
test_entries = (
'uk=-4',
'uki=4',
'uk:4',
'uk=4.de=3',
)
for entry in test_entries:
expect_invalid_attr(self, {keyword: entry}, attr)
def test_minimal_bridge_descriptor(self):
"""
Basic sanity check that we can parse a descriptor with minimal attributes.
"""
desc = BridgeExtraInfoDescriptor.create()
self.assertEqual('ec2bridgereaac65a3', desc.nickname)
self.assertEqual([], desc.get_unrecognized_lines())
# check that we don't have crypto fields
self.assertRaises(AttributeError, getattr, desc, 'signature')
def test_bridge_ip_versions_line(self):
"""
Parses the 'bridge-ip-versions' line, which only appears in bridges.
"""
desc = BridgeExtraInfoDescriptor.create({'bridge-ip-versions': 'v4=16,v6=40'})
self.assertEqual({'v4': 16, 'v6': 40}, desc.ip_versions)
desc = BridgeExtraInfoDescriptor.create({'bridge-ip-versions': ''})
self.assertEqual({}, desc.ip_versions)
desc_text = BridgeExtraInfoDescriptor.content({'bridge-ip-versions': 'v4=24.5'})
self.assertRaises(ValueError, RelayExtraInfoDescriptor, desc_text, True)
def test_bridge_ip_transports_line(self):
"""
Parses the 'bridge-ip-transports' line, which only appears in bridges.
"""
desc = BridgeExtraInfoDescriptor.create({'bridge-ip-transports': '=16,=40'})
self.assertEqual({'': 16, '': 40}, desc.ip_transports)
desc = BridgeExtraInfoDescriptor.create({'bridge-ip-transports': ''})
self.assertEqual({}, desc.ip_transports)
desc_text = BridgeExtraInfoDescriptor.content({'bridge-ip-transports': '=24.5'})
self.assertRaises(ValueError, RelayExtraInfoDescriptor, desc_text, True)
def test_transport_line(self):
"""
Basic exercise for both a bridge and relay's transport entry.
"""
desc = BridgeExtraInfoDescriptor.create({'transport': 'obfs3'})
self.assertEqual({'obfs3': (None, None, None)}, desc.transport)
self.assertEqual([], desc.get_unrecognized_lines())
desc = RelayExtraInfoDescriptor.create({'transport': 'obfs2 83.212.96.201:33570'})
self.assertEqual({'obfs2': ('83.212.96.201', 33570, [])}, desc.transport)
self.assertEqual([], desc.get_unrecognized_lines())
# multiple transport lines
desc = BridgeExtraInfoDescriptor.create({'transport': 'obfs3\ntransport obfs4'})
self.assertEqual({'obfs3': (None, None, None), 'obfs4': (None, None, None)}, desc.transport)
self.assertEqual([], desc.get_unrecognized_lines())
stem-1.6.0/test/unit/descriptor/tordnsel.py 0000664 0001750 0001750 00000005667 13115423200 021535 0 ustar atagar atagar 0000000 0000000 """
Unit tests for stem.descriptor.tordnsel.
"""
import io
import unittest
import datetime
from stem.util.tor_tools import is_valid_fingerprint
from stem.descriptor.tordnsel import TorDNSEL, _parse_file
TEST_DESC = b"""\
@type tordnsel 1.0
Downloaded 2013-08-19 04:02:03
ExitNode 003A71137D959748C8157C4A76ECA639CEF5E33E
Published 2013-08-19 02:13:53
LastStatus 2013-08-19 03:02:47
ExitAddress 66.223.170.168 2013-08-19 03:18:51
ExitNode 00FF300624FECA7F40515C8D854EE925332580D6
Published 2013-08-18 07:02:14
LastStatus 2013-08-18 09:02:58
ExitAddress 82.252.181.153 2013-08-18 08:03:01
ExitAddress 82.252.181.154 2013-08-18 08:03:02
ExitAddress 82.252.181.155 2013-08-18 08:03:03
ExitNode 030B22437D99B2DB2908B747B6962EAD13AB4039
Published 2013-08-18 12:44:20
LastStatus 2013-08-18 13:02:57
ExitAddress 46.10.211.205 2013-08-18 13:18:48
"""
MALFORMED_ENTRY_1 = b"""\
ExitNode 030B22437D99B2DB2908B747B6962EAD13AB4038
Published Today!
LastStatus 2013-08-18 13:02:57
ExitAddress 46.10.211.205 2013-08-18 13:18:48
"""
MALFORMED_ENTRY_2 = b"""\
@type tordnsel 1.0
ExitNode 030B22437D99B2DB2908B747B6962EAD13AB4038
Published Today!
LastStatus 2013-08-18 13:02:57
ExitAddress 46.10.211.205 2013-08-18 Never
"""
class TestTorDNSELDescriptor(unittest.TestCase):
def test_parse_file(self):
"""
Try parsing a document via the _parse_file() function.
"""
# parse file and assert values
descriptors = list(_parse_file(io.BytesIO(TEST_DESC)))
self.assertEqual(3, len(descriptors))
self.assertTrue(isinstance(descriptors[0], TorDNSEL))
desc = descriptors[1]
self.assertTrue(is_valid_fingerprint(desc.fingerprint))
self.assertEqual('00FF300624FECA7F40515C8D854EE925332580D6', desc.fingerprint)
self.assertEqual(datetime.datetime(2013, 8, 18, 7, 2, 14), desc.published)
self.assertEqual(datetime.datetime(2013, 8, 18, 9, 2, 58), desc.last_status)
self.assertEqual(3, len(desc.exit_addresses))
exit = desc.exit_addresses[0]
self.assertEqual('82.252.181.153', exit[0])
self.assertEqual(datetime.datetime(2013, 8, 18, 8, 3, 1), exit[1])
# block content raises value error
extra = b'ExtraContent goes here\n'
descriptors = _parse_file(io.BytesIO(TEST_DESC + extra), validate = True)
self.assertRaises(ValueError, list, descriptors)
# malformed fingerprint raises value errors
extra = b'ExitNode 030B22437D99B2DB2908B747B6'
self.assertRaises(ValueError, list, _parse_file(io.BytesIO(TEST_DESC + extra), validate = True))
# malformed date raises value errors
self.assertRaises(ValueError, list, _parse_file(io.BytesIO(TEST_DESC + MALFORMED_ENTRY_1), validate = True))
# skip exit address if malformed date and validate is False
desc = next(_parse_file(io.BytesIO(MALFORMED_ENTRY_2), validate=False))
self.assertTrue(is_valid_fingerprint(desc.fingerprint))
self.assertEqual('030B22437D99B2DB2908B747B6962EAD13AB4038', desc.fingerprint)
self.assertEqual(0, len(desc.exit_addresses))
stem-1.6.0/test/unit/descriptor/data/ 0000775 0001750 0001750 00000000000 13177674754 020262 5 ustar atagar atagar 0000000 0000000 stem-1.6.0/test/unit/descriptor/data/metrics_server_desc_multiple 0000664 0001750 0001750 00000005314 13115423200 026117 0 ustar atagar atagar 0000000 0000000 @type server-descriptor 1.0
router anonion 31.54.58.167 443 0 0
platform Tor 0.2.3.22-rc on Windows XP
opt protocols Link 1 2 Circuit 1
published 2012-09-17 07:28:01
opt fingerprint 9A5E C5BB 8665 17E5 3962 AF4D 3E77 6536 694B 069E
uptime 0
bandwidth 8388608 8388608 442368
opt extra-info-digest 0DED759EDA005BFD735E91D3E2DBF22D2D685F12
onion-key
-----BEGIN RSA PUBLIC KEY-----
MIGJAoGBAM+vu//ysOgcbCwri0RnunH8xNwswnTPbbusad7im2lXJuPjMbTFlkcn
3yPxbL1aD3p/PHPfLKOOPcFDVlCma/N8tJ6CEeJn6pZcrvgsU/d1EASQyrhpXFgL
oH/+zfg4ir52dZp4gS03P16i9m4HB4YTewo62cIuZoZKq1smReMzAgMBAAE=
-----END RSA PUBLIC KEY-----
signing-key
-----BEGIN RSA PUBLIC KEY-----
MIGJAoGBALSrtq1TqL5TImtctKm/5CvZHb54n5JpkmD8jtmdajgpHF0eaSaaw/Qw
IKaoQn17etuGzbeXF1vgphv2T4xyIm04MiLOszbLGXK1Fsa5uAO+qs1bIy6mLpwg
XrYhyuddYyw1s4U5ZNBNK/0rlwo7hoIZjxcej0AvTGewFx+Rv6UlAgMBAAE=
-----END RSA PUBLIC KEY-----
opt hidden-service-dir
contact anonion at nym dot hush dot com
reject 0.0.0.0/8:*
reject 169.254.0.0/16:*
reject 127.0.0.0/8:*
reject 192.168.0.0/16:*
reject 10.0.0.0/8:*
reject 172.16.0.0/12:*
reject 31.54.58.167:*
accept *:53
accept *:80
accept *:443
accept *:3128
accept *:8080
accept *:8000
accept *:50
accept *:51
accept *:389
accept *:636
accept *:2123
accept *:2152
accept *:11370
accept *:11371
accept *:2301
accept *:2381
accept *:6518
accept *:9100
accept *:1433
accept *:1434
accept *:3389
accept *:5901
reject *:*
router-signature
-----BEGIN SIGNATURE-----
XzcWkD6QV6CHtcdKuM6mVGGl+m9JsmLtYhpPMxRANxbRLMLaI1+XkO58QS0zvl6f
0vhmifJhJSu+FV+mOkg/aCsPyleSMd8vLOjCzhVv0yCzcn252ujsjGc0HrmyPE1R
p2bQE2u2SpgLKw6oylyr6qLcZkGIWDYhnnyZTg2lXm8=
-----END SIGNATURE-----
router Unnamed 122.60.235.157 9001 0 0
platform Tor 0.2.2.37 (git-fce6eb1c44e87bc2) on Darwin x86_64
opt protocols Link 1 2 Circuit 1
published 2012-09-17 14:57:28
opt fingerprint 5366 F1D1 9875 9F88 94EA 6E5F F768 C667 F59A FD24
uptime 542717
bandwidth 32768 65536 58012
opt extra-info-digest 33C8C462BFA5A9C6E825A0A717BD63072AB68E59
onion-key
-----BEGIN RSA PUBLIC KEY-----
MIGJAoGBAKCt4oloDEzaHKzuljXGIJujbTbQfl/XZPjc/84eWp8Ka2Vmpa9DL3cV
+bO3wttgA6ZtkGUB6d6AHcfOoRT7tP/wBeQSHSDxh9OmKzGKZiHB76HNxVny8aJd
ngVPgMmolXajdnzCIAIRLdUW6SHvIinyeghLuVSwLZU+eEN5XSXrAgMBAAE=
-----END RSA PUBLIC KEY-----
signing-key
-----BEGIN RSA PUBLIC KEY-----
MIGJAoGBAJ5avJflNjXZjGukC0aACUeTMHsQEHsQKCFPwXFVBCX6gDmrfivqT+EB
efT8XTktk44EFJbCAWj65kuj+aoXBfUvrr21at4WAEJ33BgmitwCrzwkKWVX/wLM
+NMIGObvs88HYyaTsoyZ/TToLE5nPQJj77bNyabHgNvYEXyFxooJAgMBAAE=
-----END RSA PUBLIC KEY-----
opt hidden-service-dir
reject *:*
router-signature
-----BEGIN SIGNATURE-----
m0Q/dr4HvyGShKG8DdKyabcTO4lZtGMXNGX+TEM1D43+5mw4D5UgiIdaK9a2tMQA
sBGFCymv3ZHpmPRtOhSMRafwcZDYXeCSdvZXmfGzpyIRrBde3uRIJj97eqA+oOHd
5TlnK2Z0tF+M1bUD0xYHOde5a/lAaiQaw5+mley6i6M=
-----END SIGNATURE-----
stem-1.6.0/test/unit/descriptor/data/cached-consensus 0000664 0001750 0001750 00000006377 13124757510 023427 0 ustar atagar atagar 0000000 0000000 network-status-version 3
vote-status consensus
consensus-method 26
valid-after 2017-05-25 04:46:30
fresh-until 2017-05-25 04:46:40
valid-until 2017-05-25 04:46:50
voting-delay 2 2
client-versions
server-versions
known-flags Authority Exit Fast Guard HSDir NoEdConsensus Running Stable V2Dir Valid
recommended-client-protocols Cons=1-2 Desc=1-2 DirCache=1 HSDir=1 HSIntro=3 HSRend=1 Link=4 LinkAuth=1 Microdesc=1-2 Relay=2
recommended-relay-protocols Cons=1-2 Desc=1-2 DirCache=1 HSDir=1 HSIntro=3 HSRend=1 Link=4 LinkAuth=1 Microdesc=1-2 Relay=2
required-client-protocols Cons=1-2 Desc=1-2 DirCache=1 HSDir=1 HSIntro=3 HSRend=1 Link=4 LinkAuth=1 Microdesc=1-2 Relay=2
required-relay-protocols Cons=1 Desc=1 DirCache=1 HSDir=1 HSIntro=3 HSRend=1 Link=3-4 LinkAuth=1 Microdesc=1 Relay=1-2
dir-source test001a 596CD48D61FDA4E868F4AA10FF559917BE3B1A35 127.0.0.1 127.0.0.1 7001 5001
contact auth1@test.test
vote-digest 2E7177224BBA39B505F7608FF376C07884CF926F
dir-source test000a BCB380A633592C218757BEE11E630511A485658A 127.0.0.1 127.0.0.1 7000 5000
contact auth0@test.test
vote-digest 5DD41617166FFB82882A117EEFDA0353A2794DC5
r test002r NIIl+DyFR5ay3WNk5lyxibM71pY UzQp+EE8G0YCKtNlZVy+3h5tv0Q 2017-05-25 04:46:11 127.0.0.1 5002 7002
s Exit Fast Guard HSDir Running Stable V2Dir Valid
v Tor 0.3.0.7
pr Cons=1-2 Desc=1-2 DirCache=1 HSDir=1-2 HSIntro=3-4 HSRend=1-2 Link=1-4 LinkAuth=1,3 Microdesc=1-2 Relay=1-2
w Bandwidth=0 Unmeasured=1
p accept 1-65535
r test001a qgzRpIKSW809FnL4tntRtWgOiwo x8yR5mi/DBbLg46qwGQ96Dno+nc 2017-05-25 04:46:12 127.0.0.1 5001 7001
s Authority Exit Fast Guard HSDir Running V2Dir Valid
v Tor 0.3.0.7
pr Cons=1-2 Desc=1-2 DirCache=1 HSDir=1-2 HSIntro=3-4 HSRend=1-2 Link=1-4 LinkAuth=1,3 Microdesc=1-2 Relay=1-2
w Bandwidth=0 Unmeasured=1
p reject 1-65535
r test000a 3nJC+LvtNmx6kw23x1WE90pyIj4 Hg3NyPqDZoRQN8hVI5Vi6B+pofw 2017-05-25 04:46:12 127.0.0.1 5000 7000
s Authority Exit Fast Guard HSDir Running Stable V2Dir Valid
v Tor 0.3.0.7
pr Cons=1-2 Desc=1-2 DirCache=1 HSDir=1-2 HSIntro=3-4 HSRend=1-2 Link=1-4 LinkAuth=1,3 Microdesc=1-2 Relay=1-2
w Bandwidth=0 Unmeasured=1
p reject 1-65535
directory-footer
bandwidth-weights Wbd=3333 Wbe=0 Wbg=0 Wbm=10000 Wdb=10000 Web=10000 Wed=3333 Wee=10000 Weg=3333 Wem=10000 Wgb=10000 Wgd=3333 Wgg=10000 Wgm=10000 Wmb=10000 Wmd=3333 Wme=0 Wmg=0 Wmm=10000
directory-signature 596CD48D61FDA4E868F4AA10FF559917BE3B1A35 9FBF54D6A62364320308A615BF4CF6B27B254FAD
-----BEGIN SIGNATURE-----
Ho0rLojfLHs9cSPFxe6znuGuFU8BvRr6gnH1gULTjUZO0NSQvo5N628KFeAsq+pT
ElieQeV6UfwnYN1U2tomhBYv3+/p1xBxYS5oTDAITxLUYvH4pLYz09VutwFlFFtU
r/satajuOMST0M3wCCBC4Ru5o5FSklwJTPJ/tWRXDCEHv/N5ZUUkpnNdn+7tFSZ9
eFrPxPcQvB05BESo7C4/+ZnZVO/wduObSYu04eWwTEog2gkSWmsztKoXpx1QGrtG
sNL22Ws9ySGDO/ykFFyxkcuyB5A8oPyedR7DrJUfCUYyB8o+XLNwODkCFxlmtFOj
ci356fosgLiM1sVqCUkNdA==
-----END SIGNATURE-----
directory-signature BCB380A633592C218757BEE11E630511A485658A 9CA027E05B0CE1500D90DA13FFDA8EDDCD40A734
-----BEGIN SIGNATURE-----
uiAt8Ir27pYFX5fNKiVZDoa6ELVEtg/E3YeYHAnlSSRzpacLMMTN/HhF//Zvv8Zj
FKT95v77xKvE6b8s7JjB3ep6coiW4tkLqjDiONG6iDRKBmy6D+RZgf1NMxl3gWaZ
ShINORJMW9nglnBbysP7egPiX49w1igVZQLM1C2ppphK6uO5EGcK6nDJF4LVDJ7B
Fvt2yhY+gsiG3oSrhsP0snQnFfvEeUFO/r2gRVJ1FoMXUttaOCtmj268xS08eZ0m
MS+u6gHEM1dYkwpA+LzE9G4akPRhvRjMDaF0RMuLQ7pY5v44uE5OX5n/GKWRgzVZ
DH+ubl6BuqpQxYQXaHZ5iw==
-----END SIGNATURE-----
stem-1.6.0/test/unit/descriptor/data/extrainfo_relay_descriptor 0000664 0001750 0001750 00000002451 13115423200 025602 0 ustar atagar atagar 0000000 0000000 @type extra-info 1.0
extra-info NINJA B2289C3EAB83ECD6EB916A2F481A02E6B76A0A48
published 2012-05-05 17:03:50
write-history 2012-05-05 17:02:45 (900 s) 1082368,19456,50176,272384,485376,1850368,1132544,1790976,2459648,4091904,6310912,13701120,3209216,3871744,7873536,5440512,7287808,10561536,9979904,11247616,11982848,7590912,10611712,20728832,38534144,6839296,3173376,16678912
read-history 2012-05-05 17:02:45 (900 s) 3309568,9216,41984,27648,123904,2004992,364544,576512,1607680,3808256,4672512,12783616,2938880,2562048,7348224,3574784,6488064,10954752,9359360,4438016,6286336,6438912,4502528,10720256,38165504,1524736,2336768,8186880
dirreq-write-history 2012-05-05 17:02:45 (900 s) 0,0,0,227328,349184,382976,738304,1171456,850944,657408,1675264,987136,702464,1335296,587776,1941504,893952,533504,695296,6828032,6326272,1287168,6310912,10085376,1048576,5372928,894976,8610816
dirreq-read-history 2012-05-05 17:02:45 (900 s) 0,0,0,0,33792,27648,48128,46080,60416,51200,63488,64512,45056,27648,37888,48128,57344,34816,46080,50176,37888,51200,25600,33792,39936,32768,28672,30720
router-signature
-----BEGIN SIGNATURE-----
K5FSywk7qvw/boA4DQcqkls6Ize5vcBYfhQ8JnOeRQC9+uDxbnpm3qaYN9jZ8myj
k0d2aofcVbHr4fPQOSST0LXDrhFl5Fqo5um296zpJGvRUeO6S44U/EfJAGShtqWw
7LZqklu+gVvhMKREpchVqlAwXkWR44VENm24Hs+mT3M=
-----END SIGNATURE-----
stem-1.6.0/test/unit/descriptor/data/hidden_service_stealth_auth 0000664 0001750 0001750 00000006361 13115423200 025675 0 ustar atagar atagar 0000000 0000000 @type hidden-service-descriptor 1.0
rendezvous-service-descriptor ubf3xeibzlfil6s4larq6y5peup2z3oj
version 2
permanent-key
-----BEGIN RSA PUBLIC KEY-----
MIGJAoGBAL1f7GdEObH+xMhf4GsaTCtfVH7ZpanegC65jn0/Kz9wlkpF+SQdIvTu
Ha2iZB34GDT2PvTy98chSxz+E3Kv2h45pQWbrwLN3Fj4qa+klclIXWcIa7GT4Pct
YZzAvHIh9t9EAe6ejYu8I+h4yL6QNAA2bYOi1d66+qCNCAFBgAqpAgMBAAE=
-----END RSA PUBLIC KEY-----
secret-id-part jczvydhzetbpdiylj3d5nsnjvaigs7xm
publication-time 2015-02-24 20:00:00
protocol-versions 2,3
introduction-points
-----BEGIN MESSAGE-----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-----END MESSAGE-----
signature
-----BEGIN SIGNATURE-----
c8HgXcZesCwAzgDlE3kRYsq059yCIE7MH7r2jBHqJVYPRrtm/HF/mTUykwFPzwsY
ulcuoNlPfgGMKS8qBL4kFVZ9uR2Y6P4zLchoVS6wjL+cNYOQfeQs3sNZkiIrOjbb
590tr1/yrt0qUtITGhUGhBZVs9gvkuqaThTIXleEseI=
-----END SIGNATURE-----
stem-1.6.0/test/unit/descriptor/data/descriptor_archive.tar 0000664 0001750 0001750 00000050000 13115423200 024606 0 ustar atagar atagar 0000000 0000000 descriptor_archive/0/2/02c311d3d789f3f55c0880b5c85f3c196343552c 0000644 0001750 0001750 00000004615 11755476646 021637 0 ustar atagar atagar @type server-descriptor 1.0
router Amunet1 199.48.147.35 443 0 80
platform Tor 0.2.2.34 (git-f0e1ee98af443107) on Linux x86_64
opt protocols Link 1 2 Circuit 1
published 2012-03-02 09:06:14
opt fingerprint B6D8 3EC2 D9E1 8B0A 7A33 428F 8CFA 9C53 6769 E209
uptime 2370398
bandwidth 104857600 209715200 8610541
opt extra-info-digest F1A0DE598AAD783548C6185909585FB9CDF736FE
onion-key
-----BEGIN RSA PUBLIC KEY-----
MIGJAoGBALEN3N09XeXVQgfQxku+swowfQiUoeX22HxneJYdHWBxgpY40Vke+Fa8
lDr2Xw2PVHChgmUl4xEXF2NPt6UD03RDZHfHVMKRYpnpJmJBaI58rJkw7DjHgDuP
FSlbXDhQMWbFT8bvbhqaaTMvlfQx1cnqIhc+ZAREdeTjlJysqYndAgMBAAE=
-----END RSA PUBLIC KEY-----
signing-key
-----BEGIN RSA PUBLIC KEY-----
MIGJAoGBANOGfEY3n/HmoyVAbgPC1OURB9PXR/nUQPdbeAVrDA17FXbw98OF7otR
9nWfi1vPVn8H0ODXrn7YEaqxYDjSMvacchNCKC4vFxgkpdVEzSsiYBLYsxGXaDys
4FOPQAix2EZaEKon4tuUMQAHSjLcjH5VBkixh4WXj9C4h1l9YMmnAgMBAAE=
-----END RSA PUBLIC KEY-----
family $0CE3CFB1E9CC47B63EA8869813BF6FAB7D4540C1 $1FD187E8F69A9B74C9202DC16A25B9E7744AB9F6 $74FB5EFA6A46DE4060431D515DC9A790E6AD9A7C $77001D8DA9BF445B0F81AA427A675F570D222E6A $A7569A83B5706AB1B1A9CB52EFF7D2D32E4553EB $D2F37F46182C23AB747787FD657E680B34EAF892 $E0BD57A11F00041A9789577C53A1B784473669E4 $E5E3E9A472EAF7BE9682B86E92305DB4C71048EF
opt hidden-service-dir
contact tor-admin on formlessnetworking of net
reject 0.0.0.0/8:*
reject 169.254.0.0/16:*
reject 127.0.0.0/8:*
reject 192.168.0.0/16:*
reject 10.0.0.0/8:*
reject 172.16.0.0/12:*
reject 199.48.147.35:*
accept *:20-23
accept *:43
accept *:53
accept *:79-81
accept *:88
accept *:110
accept *:143
accept *:194
accept *:443
accept *:464-465
accept *:543-544
accept *:563
accept *:587
accept *:706
accept *:749
accept *:873
accept *:902-904
accept *:981
accept *:989-993
accept *:995
accept *:1194
accept *:1220
accept *:1293
accept *:1500
accept *:1723
accept *:1863
accept *:2082-2083
accept *:2086-2087
accept *:2095-2096
accept *:3389
accept *:3690
accept *:4321
accept *:4643
accept *:5050
accept *:5190
accept *:5222-5223
accept *:5900
accept *:6666-6667
accept *:6679
accept *:6697
accept *:8000
accept *:8008
accept *:8080
accept *:8087-8088
accept *:8443
accept *:8888
accept *:9418
accept *:9999
accept *:10000
accept *:19638
reject *:*
router-signature
-----BEGIN SIGNATURE-----
TolLBBD13jT8USQ2AoZ3O7j73bknqj4WtqENF+akuJh3QKCBIHIUagcRH4q/Xt6y
mNx8A/3ip/sygZwPEX080JFt03rJjF50hK/lpM2zvpn6Fw6lHFh65DV7wSjFfk7Y
cqG4hkUqinotSj413JFhVihJ6bz/gOOmovU1ufpDuJw=
-----END SIGNATURE-----
descriptor_archive/1/b/1bb798cae15e21479db0bc700767eee4733e9d4a 0000644 0001750 0001750 00000004667 11755476655 022307 0 ustar atagar atagar @type server-descriptor 1.0
router Amunet11 199.48.147.45 22 0 80
platform Tor 0.2.2.34 (git-f0e1ee98af443107) on Linux x86_64
opt protocols Link 1 2 Circuit 1
published 2012-03-01 02:58:10
opt fingerprint 1F43 EE37 A067 0301 AD9C B555 D94A FEC2 C89F DE86
uptime 2261883
bandwidth 104857600 209715200 9197333
opt extra-info-digest 93B4C7E9205430DED49FD0BEA30F647BD20DB55D
onion-key
-----BEGIN RSA PUBLIC KEY-----
MIGJAoGBALFhXdB6tJJw5z5kwRhZjYtoysIaWv5GA9mRnz5CaI9g/kH2TZS6/z7p
zEXrtsDd6RzSTRXBdCFbXwvt4ftLqtZj+3ezGaerfyFNNgHp37Wsqol+CYVRpam1
VQTjYMUXGplUbgc4801WJKZ+sH7Kq4V2pkJiAFmNsVWsoToQHu6tAgMBAAE=
-----END RSA PUBLIC KEY-----
signing-key
-----BEGIN RSA PUBLIC KEY-----
MIGJAoGBAO12H34IhpknafbmuKCO7kOmsxhGv86KQffFoFETKMLDduxnfyKH9d6H
AK4+Ries93WxGIZFxTc5BSaGcIfpXTY58kYS0o/OoUBR2nbTzlwrjCcmO0+5x7D5
xrbm9y/Mt/cCm98T4XYQXR45FCdVo7TU0xmrsz0YopoxhhSzy/nxAgMBAAE=
-----END RSA PUBLIC KEY-----
family $0CE3CFB1E9CC47B63EA8869813BF6FAB7D4540C1 $1FD187E8F69A9B74C9202DC16A25B9E7744AB9F6 $74FB5EFA6A46DE4060431D515DC9A790E6AD9A7C $77001D8DA9BF445B0F81AA427A675F570D222E6A $A7569A83B5706AB1B1A9CB52EFF7D2D32E4553EB $B6D83EC2D9E18B0A7A33428F8CFA9C536769E209 $D2F37F46182C23AB747787FD657E680B34EAF892 $E0BD57A11F00041A9789577C53A1B784473669E4 $E5E3E9A472EAF7BE9682B86E92305DB4C71048EF
opt hidden-service-dir
contact tor-admin on formlessnetworking of net
reject 0.0.0.0/8:*
reject 169.254.0.0/16:*
reject 127.0.0.0/8:*
reject 192.168.0.0/16:*
reject 10.0.0.0/8:*
reject 172.16.0.0/12:*
reject 199.48.147.45:*
accept *:20-23
accept *:43
accept *:53
accept *:79-81
accept *:88
accept *:110
accept *:143
accept *:194
accept *:443
accept *:464-465
accept *:543-544
accept *:563
accept *:587
accept *:706
accept *:749
accept *:873
accept *:902-904
accept *:981
accept *:989-993
accept *:995
accept *:1194
accept *:1220
accept *:1293
accept *:1500
accept *:1723
accept *:1863
accept *:2082-2083
accept *:2086-2087
accept *:2095-2096
accept *:3389
accept *:3690
accept *:4321
accept *:4643
accept *:5050
accept *:5190
accept *:5222-5223
accept *:5900
accept *:6666-6667
accept *:6679
accept *:6697
accept *:8000
accept *:8008
accept *:8080
accept *:8087-8088
accept *:8443
accept *:8888
accept *:9418
accept *:9999
accept *:10000
accept *:19638
reject *:*
router-signature
-----BEGIN SIGNATURE-----
q+N3s+00x5WNzPjU/bOVDBOoZZVGiMExMW+gBmqgzHxJQs3lLshoEEf8eNOuTcfr
OTu/sT4pMO106QtmrQfyE1npAVzm75AINnN5tzj0MsfnvusSyUxIjHHAAyb2M9Mg
j4QHz7OlqNndBAVvdfQVydSefSKKUV+eGUJpeeA0Pls=
-----END SIGNATURE-----
descriptor_archive/1/b/1ef75fef564180d8b3f72c6f8635ff0cd855f92c 0000644 0001750 0001750 00000004616 11755476662 022331 0 ustar atagar atagar @type server-descriptor 1.0
router Amunet3 199.48.147.37 443 0 80
platform Tor 0.2.2.34 (git-f0e1ee98af443107) on Linux x86_64
opt protocols Link 1 2 Circuit 1
published 2012-03-01 02:58:38
opt fingerprint E0BD 57A1 1F00 041A 9789 577C 53A1 B784 4736 69E4
uptime 2261941
bandwidth 104857600 209715200 11605015
opt extra-info-digest D4397EC97CD5187EB08A5FFBE6E1A4BC267A389F
onion-key
-----BEGIN RSA PUBLIC KEY-----
MIGJAoGBAKuPBv5zCgw2y6qBW+Nv5ra4C74l3kleGoSMamXcs4+uu0ibybi8pgxm
bq3RXukufp0ZcH+bHDRnCWuqJ7tXdeyD/mEH5rN87OwK9B8gZ5jGqFG65YlzXC+y
hRDvbuZfaEpd9Ka8AnsgKK4k4goq80nkGr+kPG3aAoVjYNoceM7lAgMBAAE=
-----END RSA PUBLIC KEY-----
signing-key
-----BEGIN RSA PUBLIC KEY-----
MIGJAoGBAMNpCKOPaXVYt4NYsVfGRl0zdknlaf/gsl85HErpJMsFYr8VeBw9e46w
4WF6brxKZqbDlyukBAjv8BOD1KIeg9f9EfVY6UuhZbSrDUxfkEDmMIFs2Fcx67hy
4P+blGoxb+n0XfekSbyPhUzXz6EnTqAbSEYQM1Zke4tvZGRA6wm9AgMBAAE=
-----END RSA PUBLIC KEY-----
family $0CE3CFB1E9CC47B63EA8869813BF6FAB7D4540C1 $1FD187E8F69A9B74C9202DC16A25B9E7744AB9F6 $74FB5EFA6A46DE4060431D515DC9A790E6AD9A7C $77001D8DA9BF445B0F81AA427A675F570D222E6A $A7569A83B5706AB1B1A9CB52EFF7D2D32E4553EB $B6D83EC2D9E18B0A7A33428F8CFA9C536769E209 $D2F37F46182C23AB747787FD657E680B34EAF892 $E5E3E9A472EAF7BE9682B86E92305DB4C71048EF
opt hidden-service-dir
contact tor-admin on formlessnetworking of net
reject 0.0.0.0/8:*
reject 169.254.0.0/16:*
reject 127.0.0.0/8:*
reject 192.168.0.0/16:*
reject 10.0.0.0/8:*
reject 172.16.0.0/12:*
reject 199.48.147.37:*
accept *:20-23
accept *:43
accept *:53
accept *:79-81
accept *:88
accept *:110
accept *:143
accept *:194
accept *:443
accept *:464-465
accept *:543-544
accept *:563
accept *:587
accept *:706
accept *:749
accept *:873
accept *:902-904
accept *:981
accept *:989-993
accept *:995
accept *:1194
accept *:1220
accept *:1293
accept *:1500
accept *:1723
accept *:1863
accept *:2082-2083
accept *:2086-2087
accept *:2095-2096
accept *:3389
accept *:3690
accept *:4321
accept *:4643
accept *:5050
accept *:5190
accept *:5222-5223
accept *:5900
accept *:6666-6667
accept *:6679
accept *:6697
accept *:8000
accept *:8008
accept *:8080
accept *:8087-8088
accept *:8443
accept *:8888
accept *:9418
accept *:9999
accept *:10000
accept *:19638
reject *:*
router-signature
-----BEGIN SIGNATURE-----
rvoIDm+hzveUtq7TAXz1fVnz5AZfms+rN1o6Ju+guHvdgCRao7iuHIZD+eR2eBUU
+oh+T8KLzUA+llQquGGP3YNBdVOTuRR7lWmvjoalmLgxu5phhdYW6+mM4uhUlHHj
qxZ72rvQ2GyMJiAGCHNLCCcX605RiEtbgkMDNG+bgz4=
-----END SIGNATURE-----
descriptor_archive/0/2/ 0000755 0001750 0001750 00000000000 11755476646 014542 5 ustar atagar atagar descriptor_archive/1/b/ 0000755 0001750 0001750 00000000000 11755476662 014621 5 ustar atagar atagar descriptor_archive/0/ 0000755 0001750 0001750 00000000000 11727534307 014365 5 ustar atagar atagar descriptor_archive/1/ 0000755 0001750 0001750 00000000000 11727534336 014370 5 ustar atagar atagar descriptor_archive/ 0000755 0001750 0001750 00000000000 11727534336 014230 5 ustar atagar atagar stem-1.6.0/test/unit/descriptor/data/cached-consensus-v2 0000664 0001750 0001750 00000005443 13115423200 023727 0 ustar atagar atagar 0000000 0000000 @type network-status-2 1.0
network-status-version 2
dir-source 18.244.0.114 18.244.0.114 80
fingerprint 719BE45DE224B607C53707D0E2143E2D423E74CF
contact arma at mit dot edu
published 2005-12-16 00:13:46
dir-options Names Versions
client-versions 0.0.9rc2,0.0.9rc3,0.0.9rc4-cvs,0.0.9rc4,0.0.9rc5-cvs,0.0.9rc5,0.0.9rc6-cvs,0.0.9rc6,0.0.9rc7-cvs,0.0.9rc7,0.0.9,0.0.9.1,0.0.9.2,0.0.9.3,0.0.9.4,0.0.9.5,0.0.9.6,0.0.9.7,0.0.9.8,0.0.9.9,0.0.9.10,0.1.0.0-alpha-cvs,0.1.0.1-rc,0.1.0.1-rc-cvs,0.1.0.2-rc,0.1.0.2-rc-cvs,0.1.0.3-rc,0.1.0.3-rc-cvs,0.1.0.4-rc,0.1.0.4-rc-cvs,0.1.0.5-rc,0.1.0.5-rc-cvs,0.1.0.6-rc,0.1.0.6-rc-cvs,0.1.0.7-rc,0.1.0.7-rc-cvs,0.1.0.8-rc,0.1.0.8-rc-cvs,0.1.0.9-rc,0.1.0.10,0.1.0.11,0.1.0.12,0.1.0.13,0.1.0.14,0.1.0.15,0.1.0.16,0.1.1.0-alpha-cvs,0.1.1.1-alpha,0.1.1.1-alpha-cvs,0.1.1.2-alpha,0.1.1.2-alpha-cvs,0.1.1.3-alpha,0.1.1.3-alpha-cvs,0.1.1.4-alpha,0.1.1.4-alpha-cvs,0.1.1.5-alpha,0.1.1.5-alpha-cvs,0.1.1.6-alpha,0.1.1.6-alpha-cvs,0.1.1.7-alpha,0.1.1.7-alpha-cvs,0.1.1.8-alpha,0.1.1.8-alpha-cvs,0.1.1.9-alpha,0.1.1.9-alpha-cvs,0.1.1.10-alpha,0.1.1.10-alpha-cvs
server-versions 0.0.9rc2,0.0.9rc3,0.0.9rc4-cvs,0.0.9rc4,0.0.9rc5-cvs,0.0.9rc5,0.0.9rc6-cvs,0.0.9rc6,0.0.9rc7-cvs,0.0.9rc7,0.0.9,0.0.9.1,0.0.9.2,0.0.9.3,0.0.9.4,0.0.9.5,0.0.9.6,0.0.9.7,0.0.9.8,0.0.9.9,0.0.9.10,0.1.0.0-alpha-cvs,0.1.0.1-rc,0.1.0.1-rc-cvs,0.1.0.2-rc,0.1.0.2-rc-cvs,0.1.0.3-rc,0.1.0.3-rc-cvs,0.1.0.4-rc,0.1.0.4-rc-cvs,0.1.0.5-rc,0.1.0.5-rc-cvs,0.1.0.6-rc,0.1.0.6-rc-cvs,0.1.0.7-rc,0.1.0.7-rc-cvs,0.1.0.8-rc,0.1.0.8-rc-cvs,0.1.0.9-rc,0.1.0.10,0.1.0.11,0.1.0.12,0.1.0.13,0.1.0.14,0.1.0.15,0.1.0.16,0.1.1.0-alpha-cvs,0.1.1.1-alpha,0.1.1.1-alpha-cvs,0.1.1.2-alpha,0.1.1.2-alpha-cvs,0.1.1.3-alpha,0.1.1.3-alpha-cvs,0.1.1.4-alpha,0.1.1.4-alpha-cvs,0.1.1.5-alpha,0.1.1.5-alpha-cvs,0.1.1.6-alpha,0.1.1.6-alpha-cvs,0.1.1.7-alpha,0.1.1.7-alpha-cvs,0.1.1.8-alpha,0.1.1.8-alpha-cvs,0.1.1.9-alpha,0.1.1.9-alpha-cvs,0.1.1.10-alpha,0.1.1.10-alpha-cvs
dir-signing-key
-----BEGIN RSA PUBLIC KEY-----
MIGJAoGBAOcrht/y5rkaahfX7sMe2qnpqoPibsjTSJaDvsUtaNP/Bq0MgNDGOR48
rtwfqTRff275Edkp/UYw3G3vSgKCJr76/bqOHCmkiZrnPV1zxNfrK18gNw2Cxre0
nTA+fD8JQqpPtb8b0SnG9kwy75eS//sRu7TErie2PzGMxrf9LH0LAgMBAAE=
-----END RSA PUBLIC KEY-----
r moria2 cZvkXeIktgfFNwfQ4hQ+LUI+dM8 t/Pwl1uHiJ3RKF/Vehsbthf2VDI 2005-12-15 06:57:18 18.244.0.114 443 80
s Authority Fast Named Running Valid V2Dir
r stnv CSi6RnBWxKaJ/uTvXXFIK2KJw9U ItGn7UGZvaftbEFu7NdpwY4fKlo 2005-12-15 16:24:42 84.16.236.173 9001 0
s Named Valid
r nggrplz CehYL/Dm+F4rjkHA3AucncRuaWg swLCsByU85jj7ziTlSawZR+CTdY 2005-12-15 23:25:50 194.109.109.109 9001 0
s Fast Stable Running Valid
directory-signature moria2
-----BEGIN SIGNATURE-----
2nXCxVje3wzn6HrIFRNMc0nc48AhMVpHZyPwRKGXkuYfTQG55uvwQDaFgJHud4RT
27QhWltau3K1evhnzhKcpbTXwkVv1TBYJSzL6rEeAn8cQ7ZiCyqf4EJCaNcem3d2
TpQQk3nNQF8z6UIvdlvP+DnJV4izWVkQEZgUZgIVM0E=
-----END SIGNATURE-----
stem-1.6.0/test/unit/descriptor/data/server_descriptor_with_ed25519 0000664 0001750 0001750 00000005424 13115423200 026031 0 ustar atagar atagar 0000000 0000000 @type server-descriptor 1.0
router destiny 94.242.246.23 9001 0 443
identity-ed25519
-----BEGIN ED25519 CERT-----
AQQABhtZAaW2GoBED1IjY3A6f6GNqBEl5A83fD2Za9upGke51JGqAQAgBABnprVR
ptIr43bWPo2fIzo3uOywfoMrryprpbm4HhCkZMaO064LP+1KNuLvlc8sGG8lTjx1
g4k3ELuWYgHYWU5rAia7nl4gUfBZOEfHAfKES7l3d63dBEjEX98Ljhdp2w4=
-----END ED25519 CERT-----
master-key-ed25519 Z6a1UabSK+N21j6NnyM6N7jssH6DK68qa6W5uB4QpGQ
or-address [2a01:608:ffff:ff07::1:23]:9003
platform Tor 0.2.7.2-alpha-dev on Linux
protocols Link 1 2 Circuit 1
published 2015-08-22 15:21:45
fingerprint F65E 0196 C94D FFF4 8AFB F2F5 F9E3 E19A AE58 3FD0
uptime 1362680
bandwidth 149715200 1048576000 51867731
extra-info-digest 44E9B679AF0B4EB09296985BAF4066AE9CA5BB93 r+roMxhsjd1GPpn5knQoBvtE9Rhsv8zQHCqiYL6u2CA
onion-key
-----BEGIN RSA PUBLIC KEY-----
MIGJAoGBAKpPOeBPFBZhH32k0CmIVsXMi4mbbkpEAYpZD0Z3/zLc9k05qAvhE55h
+LXqG6C6k23JnR7H1a4EtFU0UQVWxUa4xUL9pi/0tj3Zsu842Z18K3sL8hYWDw6x
b6afVdSKIcY6guG5fevmobUd/6437oSwM7IeXrWy28s0PtWKHhQzAgMBAAE=
-----END RSA PUBLIC KEY-----
signing-key
-----BEGIN RSA PUBLIC KEY-----
MIGJAoGBAOUS7xm+1d/FAk7VHx2SaYzjYoGpNaCHHWXlmDz2+iWEqcDRjjnVFekV
sfAPysNnB0a/lHdrqzyKjCkzAoeut5Ts3bj6eMrF3psFian2IqdlqsFaAcBov7fo
J6ipwr8lP72LOMHlB2AwP3BEWtHZX7nmARV7ekbPs21R06lEhzLLAgMBAAE=
-----END RSA PUBLIC KEY-----
onion-key-crosscert
-----BEGIN CROSSCERT-----
iW8BqwH5VKqZaiMgPcuHIQFpiQnRsd2b1zc+PXVN3AFT0cQx6J4rZhIdxiqHeNqj
fVEoi4+iHkbksGABZKlB/x7Kv2Kvbj3ZH46m22KEASkRL+i9EhCYdf3Ju7czIi/7
U/jQTwhn7+o8LCLsLhw3aV/v/sXEtbxePhMbCMHI7hE=
-----END CROSSCERT-----
ntor-onion-key-crosscert 0
-----BEGIN ED25519 CERT-----
AQoABhtwAWemtVGm0ivjdtY+jZ8jOje47LB+gyuvKmulubgeEKRkAHj4IPqm+osx
vbKfvRHeZ0uaghFPZr76UVPYwuK4N+VcW75yq2vuFSsFTCJqamPB3PIdSz6rbx4U
4F3iroztLAQ=
-----END ED25519 CERT-----
family $379FB450010D17078B3766C2273303C358C3A442 $3EB46C1D8D8B1C0BBCB6E4F08301EF68B7F5308D $B0279A521375F3CB2AE210BDBFC645FDD2E1973A $EC116BCB80565A408CE67F8EC3FE3B0B02C3A065
hidden-service-dir
contact 0x02225522 Frenn vun der Enn (FVDE)
ntor-onion-key JCj8BOqk0Khfp1hfoJaDbSTzNgeA/u2pSAXnaR3vhl0=
reject 0.0.0.0/8:*
reject 169.254.0.0/16:*
reject 127.0.0.0/8:*
reject 192.168.0.0/16:*
reject 10.0.0.0/8:*
reject 172.16.0.0/12:*
reject 94.242.246.23:*
reject *:25
reject *:587
reject *:465
reject 176.67.160.187:*
reject 185.35.77.160:*
reject 185.35.77.250:*
reject *:10000
reject *:14464
reject 94.100.180.202:*
reject 217.69.139.215:*
reject 217.69.140.233:*
accept *:*
ipv6-policy reject 25,465,587,10000,14464
router-sig-ed25519 w+cKNZTlL7vz/4WgYdFUblzJy3VdTw0mfFK4N3SPFCt20fNKt9SgiZ5V/2ai3kgGsc6oCsyUesSiYtPcTXMLCw
router-signature
-----BEGIN SIGNATURE-----
y72z1dZOYxVQVLRMvEJOn9lOFxBsjojpwiYxw+3vWFHnhkOdGqolxJ6gTLhiIXNu
ckBPqxjbpFbmt6qgk0oeivwyLo9o4nZT737d3tx1EuBmxo+gqzNtukXWzJzZFIj5
xE0eo9e/zKPSCF/LK6zv0FSefdBpnEkYYFuGN0BCrZo=
-----END SIGNATURE-----
stem-1.6.0/test/unit/descriptor/data/metrics_consensus 0000664 0001750 0001750 00000014537 13115423200 023727 0 ustar atagar atagar 0000000 0000000 @type network-status-consensus-3 1.0
network-status-version 3
vote-status consensus
consensus-method 12
valid-after 2012-07-12 10:00:00
fresh-until 2012-07-12 11:00:00
valid-until 2012-07-12 13:00:00
voting-delay 300 300
client-versions 0.2.2.35,0.2.2.36,0.2.2.37,0.2.3.10-alpha,0.2.3.11-alpha,0.2.3.12-alpha,0.2.3.13-alpha,0.2.3.14-alpha,0.2.3.15-alpha,0.2.3.16-alpha,0.2.3.17-beta,0.2.3.18-rc,0.2.3.19-rc
server-versions 0.2.2.35,0.2.2.36,0.2.2.37,0.2.3.10-alpha,0.2.3.11-alpha,0.2.3.12-alpha,0.2.3.13-alpha,0.2.3.14-alpha,0.2.3.15-alpha,0.2.3.16-alpha,0.2.3.17-beta,0.2.3.18-rc,0.2.3.19-rc
known-flags Authority BadExit Exit Fast Guard HSDir Named Running Stable Unnamed V2Dir Valid
params CircuitPriorityHalflifeMsec=30000 bwauthpid=1
dir-source tor26 14C131DFC5C6F93646BE72FA1401C02A8DF2E8B4 86.59.21.38 86.59.21.38 80 443
contact Peter Palfrader
vote-digest 0B6D1E9A300B895AA2D0B427F92917B6995C3C1C
dir-source turtles 27B6B5996C426270A5C95488AA5BCEB6BCC86956 76.73.17.194 76.73.17.194 9030 9090
contact Mike Perry
vote-digest 904B1974B9879D02B4ADFB81D7E9B4E07D768A5A
dir-source maatuska 49015F787433103580E3B66A1707A00E60F2D15B 171.25.193.9 171.25.193.9 443 80
contact 4096R/23291265 Linus Nordberg
vote-digest A8839355BAC373320B8CEDD0A0A09DAAA1637E3A
dir-source dannenberg 585769C78764D58426B8B52B6651A5A71137189A dannenberg.ccc.de 193.23.244.244 80 443
contact Andreas Lehner
vote-digest 416B73C49E717B0A5D61A4F634DCCF94611802E7
dir-source urras 80550987E1D626E3EBA5E5E75A458DE0626D088C 208.83.223.34 208.83.223.34 443 80
contact 4096R/E012B42D Jacob Appelbaum
vote-digest 08B1F8E4910F136E7FB7DFD52ABB2A9EDE939F0B
dir-source moria1 D586D18309DED4CD6D57C18FDB97EFA96D330566 128.31.0.34 128.31.0.34 9131 9101
contact 1024D/28988BF5 arma mit edu
vote-digest 5006931FB78F7AE42B602697591DBA82AACEF533
dir-source dizum E8A9C45EDE6D711294FADF8E7951F4DE6CA56B58 194.109.206.212 194.109.206.212 80 443
contact 1024R/8D56913D Alex de Joode
vote-digest 3F1F1E071EC5F54115CB8EA9723E30A9386AB8CA
dir-source gabelmoo ED03BB616EB2F60BEC80151114BB25CEF515B226 212.112.245.170 212.112.245.170 80 443
contact 4096R/C5AA446D Sebastian Hahn
vote-digest DF2EC9AD207831DED1D01BB889A9C4478DE2CFB9
r sumkledi ABPSI4nNUNC3hKPkBhyzHozozrU 8mCr8Sl7RF4ENU4jb0FZFA/3do8 2012-07-12 04:01:55 178.218.213.229 80 0
s Exit Fast Named Running Valid
v Tor 0.2.2.35
w Bandwidth=38
p accept 80,443
r Unnamed AEXri4INxBAZeyi0wvJZoC58nZs 9t4U465paxGASh0x5Tds8a8YiKo 2012-07-12 04:48:09 79.139.135.90 443 22
s Fast HSDir Running V2Dir Valid
v Tor 0.2.2.37
w Bandwidth=35
p reject 1-65535
r ANONIONROUTER AHhuQ8zFQJdT8l42Axxc6m6kNwI uI7+jQ/T3kFVnl7H7TYE/7WJxi4 2012-07-12 04:40:31 93.128.55.236 24051 24052
s Fast Named Running V2Dir Valid
v Tor 0.2.2.37
w Bandwidth=108
p reject 1-65535
r ph3x AMLCoWrttR1eX7fWFo/GazQ9gi8 ZJJnmKK6+9B2KOUSIPV49+Vprxs 2012-07-11 19:44:22 86.59.119.83 443 80
s Fast Guard HSDir Named Running Stable V2Dir Valid
v Tor 0.2.3.18-rc
w Bandwidth=55300
p reject 1-65535
r nargothrond ANi/r5RGhUxfZ3simlDXFrf2O68 DsP6REKOns/vAUYNp3rfkCOSJFM 2012-07-11 18:25:37 173.11.83.10 9001 0
s Fast Guard Named Running Stable Valid
v Tor 0.2.3.18-rc
w Bandwidth=543
p reject 1-65535
r default AN1sc6ymJ4WcSJ95VITqL0B5wDQ I9HQ2zph5Nuvf4FKANoKDf5vPV8 2012-07-11 18:48:22 82.243.60.52 443 9030
s Fast Running V2Dir Valid
v Tor 0.2.2.35
w Bandwidth=92
p reject 1-65535
r catfesh AOTNBUkB8Lob/wiz7h9gtuDoT2Q 0Ycp54MgG+Ns+oEd3BIubFJdGGw 2012-07-12 08:26:51 80.177.151.82 9001 9030
s Fast HSDir Running V2Dir Valid
v Tor 0.2.2.37
w Bandwidth=61
p reject 1-65535
directory-footer
bandwidth-weights Wbd=3335 Wbe=0 Wbg=3536 Wbm=10000 Wdb=10000 Web=10000 Wed=3329 Wee=10000 Weg=3329 Wem=10000 Wgb=10000 Wgd=3335 Wgg=6464 Wgm=6464 Wmb=10000 Wmd=3335 Wme=0 Wmg=3536 Wmm=10000
directory-signature 14C131DFC5C6F93646BE72FA1401C02A8DF2E8B4 BF112F1C6D5543CFD0A32215ACABD4197B5279AD
-----BEGIN SIGNATURE-----
HFXB4497LzESysYJ/4jJY83E5vLjhv+igIxD9LU6lf6ftkGeF+lNmIAIEKaMts8H
mfWcW0b+jsrXcJoCxV5IrwCDF3u1aC3diwZY6yiG186pwWbOwE41188XI2DeYPwE
I/TJmV928na7RLZe2mGHCAW3VQOvV+QkCfj05VZ8CsY=
-----END SIGNATURE-----
directory-signature 27B6B5996C426270A5C95488AA5BCEB6BCC86956 D5C30C15BB3F1DA27669C2D88439939E8F418FCF
-----BEGIN SIGNATURE-----
VAL+VWqcJiJtTZjFDz5/rS4WLfh8dOSnU2HYUb1ZgqM8PR1rFsoxpvaK9USrtkx9
Byctu/flD3YOqGg+GpYQwU8w9tm7BGelD+dqg97DkJXmlPaXe/Z0nKW1UnCN9m93
svyWCAqglEzxlK4H7ZfMlQbkMu7EFjXGzrn1gRVGOwg=
-----END SIGNATURE-----
directory-signature 49015F787433103580E3B66A1707A00E60F2D15B 1C915B9493589F97BAC764D1885A34BFC18C7E26
-----BEGIN SIGNATURE-----
fHAC5vdqotMtTVIxfqoNrlob2jAi3PP/urvsVA0xmaOzgYtJFIjY2iEWrrU4fRwe
0M1vyCw+oztBrPKYukedkefE9ly/R30KVW2ezo5WpOO4y6oZpelb/jRKFoSRfbyB
WdKsHSe2xlXPA0ySu1klpuMOZiQ8wgxh4x3oLGXnL5Q=
-----END SIGNATURE-----
directory-signature 585769C78764D58426B8B52B6651A5A71137189A 499D7CE5A1356045D629F43271EBF600D6F2CC9C
-----BEGIN SIGNATURE-----
IDOUDykw+tdCyyVmPSGUDahIeEEPMWxarEoH2gPuyExDqZkUc0ah6Eh736rVSD5Z
R4nCjDNTQNr5byDfJk6cMDN9A/5P8uz421pnmLfs9SasLUjTdJt921jxJnSvSBeF
hSZPNi5wl++Uw3j2zeclOXvAkkAEGi9Pi5Zf6QNlWFI=
-----END SIGNATURE-----
directory-signature 80550987E1D626E3EBA5E5E75A458DE0626D088C 2B9B419BB44728A5BE01651D6D1553FD14B6CFFB
-----BEGIN SIGNATURE-----
D2wVGni7cYHyXNqt9RvW/CUd8r7TgkfEp9OAJKojUyweiGMJOMEqDBE01e4Ov9Pd
O9D46fjxWYGE9fN72xvD8CGoNcQgTtLpvypEfB96tKM3JYr5j4MCsdcOrQBkKGp7
qf1Qfiw7aXahk8IfbgvmAvROlAMAxln7nVE0qenQWu4=
-----END SIGNATURE-----
directory-signature D586D18309DED4CD6D57C18FDB97EFA96D330566 8F0DEA35D1732D867FB94F5130364927DBCCBB8E
-----BEGIN SIGNATURE-----
cmrV1VUfCo9Smlc8BUblkBuSFqJdQkX/gd3ROOnpdRfogbsylq6xA7srCBGp1Z39
To5Vk71AI0PIy031S6gKfOLgn9E5Bl0Agr60diFxjNn0ejR49MKJTjoDI+DmBlv4
do+Bej+D8afl27LNH/QIYyzSkOl0eXSGtOEEuCQg/3A=
-----END SIGNATURE-----
directory-signature E8A9C45EDE6D711294FADF8E7951F4DE6CA56B58 9BE9A4CF520B6880EB42C5702BC521F03A6CF0FC
-----BEGIN SIGNATURE-----
UVXzEFkkjCpszLmoqQxAxSU83IS+fqrkIC4DCQZCEjRcXEvx3c56HUyTsew5WTFR
XANCJn+V3DaxYLuL6L8xW7r9xOQNU970nGwocuJckxyDcLHloL8E226vIAn6mLmt
a1Z6y8NzaQpv4fhdqhT7ETJo+chmf8bSX8qLLmaCIac=
-----END SIGNATURE-----
directory-signature ED03BB616EB2F60BEC80151114BB25CEF515B226 845CF1D0B370CA443A8579D18E7987E7E532F639
-----BEGIN SIGNATURE-----
DILsRCrtn6rDbNo3DF+L1/VVAd+V86PdZKg3Q9QooqVOGgU/7HrspV/K4lFbWcTT
Zm+quRQfuKmB4xljwXpeRlABQR5eainlZBtrTFg056/dDrJqYXSwV/C391tAIDZs
2TANs/4uLi94q6Ov+zE9zYUiF8jwnyXl/q/jKOYM8bE=
-----END SIGNATURE-----
stem-1.6.0/test/unit/descriptor/data/bridge_descriptor_with_ed25519 0000664 0001750 0001750 00000001330 13115423200 025747 0 ustar atagar atagar 0000000 0000000 @type bridge-server-descriptor 1.1
router ChandlerObfs11 10.162.85.172 443 0 0
or-address [fd9f:2e19:3bcf::3d:b3f9]:443
master-key-ed25519 lgIuiAJCoXPRwWoHgG4ZAoKtmrv47aPr4AsbmESj8AA
platform Tor 0.2.7.1-alpha-dev on Linux
protocols Link 1 2 Circuit 1
published 2015-08-20 20:09:42
fingerprint 6789 12AB D739 8DF8 EFC8 FA2B C7DE F610 7103 60C4
uptime 2693146
bandwidth 1073741824 1073741824 779171
extra-info-digest 5229E98EAB41A32E83159FA45BED21B5B405BF3B lTSVvW/NMR2HsLaJwhndqTULAtsaaSilmvm/orV9y/s
hidden-service-dir
contact somebody
ntor-onion-key bVvxUCi8drAVRkFPuFQ4DYBsV1m2M+GpHOUReOopXEk=
reject *:*
router-digest-sha256 OB/fqLD8lYmjti09R+xXH/D4S2qlizxdZqtudnsunxE
router-digest 402AC6E2BB371923E637A1D23C2D8EA55D6EB7D5
stem-1.6.0/test/unit/descriptor/data/unparseable/ 0000775 0001750 0001750 00000000000 13177674754 022563 5 ustar atagar atagar 0000000 0000000 stem-1.6.0/test/unit/descriptor/data/unparseable/extrainfo_nonascii_v3_reqs 0000664 0001750 0001750 00000003424 13124757510 030015 0 ustar atagar atagar 0000000 0000000 extra-info newton C871C91489886D5E2E94C13EA1A5FDC4B6DC5204
identity-ed25519
-----BEGIN ED25519 CERT-----
AQQABjBoAS6cmIIt3t0HjlInkuk+asDf7yAuTXhg20Gdy4uesKH3AQAgBAC6lLwz
7+yzoMFGDKic6l7kOjyGlV3H01GWtErUWy0PIquP5kMVHnrvdhsBwX0zwSA19Bo+
tdKPIKrMV+89QBGX2KSa7RRXqIdnGBnGdodglrvMFPGgO/LYHOb9YogFJgA=
-----END ED25519 CERT-----
published 2016-03-26 07:47:53
write-history 2016-03-26 05:42:08 (14400 s) 682447872,1737454592,1207077888,1278699520,1157439488,635725824
read-history 2016-03-26 05:42:08 (14400 s) 672482304,1680056320,1198174208,1233503232,1105783808,620540928
dirreq-write-history 2016-03-26 05:42:08 (14400 s) 1960960,46080,2144256,218112,737280,3273728
dirreq-read-history 2016-03-26 05:42:08 (14400 s) 322560,13312,323584,8192,46080,440320
geoip-db-digest 6346E26E2BC96F8511588CE2695E9B0339A75D32
geoip6-db-digest 43CCB43DBC653D8CC16396A882C5F116A6004F0C
dirreq-stats-end 2016-03-25 19:53:29 (86400 s)
dirreq-v3-ips us=8
dirreq-v3-reqs Sÿ=4026597208,Sÿ=4026597208,Sÿ=4026597208,Sÿ=4026597208,Sÿ=4026597208,Sÿ=4026597208,¥þ=4026591624,6=4026537520,6=4026537520,6=4026537520,us=8
dirreq-v3-resp ok=8,not-enough-sigs=0,unavailable=0,not-found=0,not-modified=0,busy=0
dirreq-v3-direct-dl complete=0,timeout=0,running=0
dirreq-v3-tunneled-dl complete=8,timeout=4,running=0
hidserv-stats-end 2016-03-25 19:53:29 (86400 s)
hidserv-rend-relayed-cells 5238 delta_f=2048 epsilon=0.30 bin_size=1024
hidserv-dir-onions-seen -21 delta_f=8 epsilon=0.30 bin_size=8
router-sig-ed25519 TeDQDiRfI/k31H+fxciE8q02/ddm/qIi4H7wpQ9A8wRwWBoFUBdwrjZu+pACiglomOuc/I2uSt0++/pmZulZDg
router-signature
-----BEGIN SIGNATURE-----
OVkz0CKUwWSXjhUMEsYATzcfT+D24QR8w6IjUtb6Mcz5P5CMggqmSFhL6SzUFXWS
JwipCWcd2/1NsJ7/JLyXKcG0Ak6FPNP3arweah8EwWkVo7rvscagI+u+Uq2FqtO/
OTNjnriDWTZdSA9FOcQueBZi7Qf7xwA0LEjtadtCjUI=
-----END SIGNATURE-----
stem-1.6.0/test/unit/descriptor/data/unparseable/cached-microdesc-consensus_with_carriage_returns 0000664 0001750 0001750 00000020477 13124757510 034345 0 ustar atagar atagar 0000000 0000000 network-status-version 3 microdesc
vote-status consensus
consensus-method 20
valid-after 2015-09-15 18:00:00
fresh-until 2015-09-15 19:00:00
valid-until 2015-09-15 21:00:00
voting-delay 300 300
client-versions 0.2.4.23,0.2.4.24,0.2.4.25,0.2.4.26,0.2.4.27,0.2.5.8-rc,0.2.5.9-rc,0.2.5.10,0.2.5.11,0.2.5.12,0.2.6.5-rc,0.2.6.6,0.2.6.7,0.2.6.8,0.2.6.9,0.2.6.10,0.2.7.1-alpha,0.2.7.2-alpha
server-versions 0.2.4.23,0.2.4.24,0.2.4.25,0.2.4.26,0.2.4.27,0.2.5.8-rc,0.2.5.9-rc,0.2.5.10,0.2.5.11,0.2.5.12,0.2.6.5-rc,0.2.6.6,0.2.6.7,0.2.6.8,0.2.6.9,0.2.6.10,0.2.7.1-alpha,0.2.7.2-alpha
known-flags Authority BadExit Exit Fast Guard HSDir Running Stable V2Dir Valid
params CircuitPriorityHalflifeMsec=30000 NumDirectoryGuards=3 NumEntryGuards=1 NumNTorsPerTAP=100 Support022HiddenServices=0 UseNTorHandshake=1 UseOptimisticData=1 bwauthpid=1 cbttestfreq=1000 pb_disablepct=0 usecreatefast=0
dir-source tor26 14C131DFC5C6F93646BE72FA1401C02A8DF2E8B4 86.59.21.38 86.59.21.38 80 443
contact Peter Palfrader
vote-digest 7DD2661BBBA3E600CB9D641CFFF27D14D77EDCCE
dir-source longclaw 23D15D965BC35114467363C165C4F724B64B4F66 longclaw.riseup.net 199.254.238.52 80 443
contact Riseup Networks - 1nNzekuHGGzBYRzyjfjFEfeisNvxkn4RT
vote-digest 2EBB0C5EFEFE51ECE8C630A45F607201491D7E09
dir-source maatuska 49015F787433103580E3B66A1707A00E60F2D15B 171.25.193.9 171.25.193.9 443 80
contact 4096R/23291265 Linus Nordberg
vote-digest 7FC1487C8D7C810C6FA8037AE6EC81ACECC408B8
dir-source dannenberg 585769C78764D58426B8B52B6651A5A71137189A dannenberg.torauth.de 193.23.244.244 80 443
contact Andreas Lehner
vote-digest 32F82FE133ADAAED686A7360297C56B327994799
dir-source urras 80550987E1D626E3EBA5E5E75A458DE0626D088C 208.83.223.34 208.83.223.34 443 80
contact 4096R/D255D3F5C868227F Jacob Appelbaum
vote-digest 86348CCEC68457D5C1777978D1043B211FA44010
dir-source moria1 D586D18309DED4CD6D57C18FDB97EFA96D330566 128.31.0.34 128.31.0.34 9131 9101
contact 1024D/28988BF5 arma mit edu
vote-digest 9D18B15C2C039CB0B18B51496F8ACBDA2836DE19
dir-source dizum E8A9C45EDE6D711294FADF8E7951F4DE6CA56B58 194.109.206.212 194.109.206.212 80 443
contact 1024R/8D56913D Alex de Joode
vote-digest 5473986DC071B8840F9E8C72AED3251B71A8244F
dir-source gabelmoo ED03BB616EB2F60BEC80151114BB25CEF515B226 131.188.40.189 131.188.40.189 80 443
contact 4096R/261C5FBE77285F88FB0C343266C8C2D7C5AA446D Sebastian Hahn - 12NbRAjAG5U3LLWETSF7fSTcdaz32Mu5CN
vote-digest 6EF25161284DB1AD19411EBF52E96927DFD66F0C
dir-source Faravahar EFCBE720AB3A82B99F9E953CD5BF50F7EEFC7B97 154.35.175.225 154.35.175.225 80 443
contact 0x0B47D56D Sina Rabbani (inf0)
vote-digest 76466BEF6525FCEE0B9FDDB205B527CBB89FAB17
r PDrelay1 AAFJ5u9xAqrKlpDW6N0pMhJLlKs 2015-09-15 04:53:47 95.215.44.189 8080 0
m iH2s4cVPTmThmmx1phnjDd6oGpHAEP7FDK38AFYRV74
s Fast Running Stable Valid
v Tor 0.2.7.2-alpha-dev
w Bandwidth=456
r seele AAoQ1DAR6kkoo19hBAX5K0QztNw 2015-09-15 04:43:45 73.15.150.172 9001 0
m LqTE9J4jxtMVm2IPDxmUKYyrzajcjqwYqLkX6JNOEpY
s Fast Running Stable Valid
v Tor 0.2.6.10
w Bandwidth=15
r TorNinurtaName AA8YrCza5McQugiY3J4h5y4BF9g 2015-09-15 17:06:16 151.236.6.198 443 80
m YxghdOEPO/uPv0N1GZV+6gCuYR5NZPaDseU45R/Yyns
s Fast HSDir Running Stable V2Dir Valid
v Tor 0.2.6.10
w Bandwidth=1750
r CalyxInstitute14 ABG9JIWtRdmE7EFZyI/AZuXjMA4 2015-09-15 16:12:03 162.247.72.201 443 80
m 6PnpSoAVS1oaJCqs4uk8y706JSZ6rdN8uUM78Oohgo0
s Exit Fast Guard HSDir Running Stable V2Dir Valid
v Tor 0.2.6.10
w Bandwidth=11400
directory-footer
bandwidth-weights Wbd=0 Wbe=0 Wbg=3944 Wbm=10000 Wdb=10000 Web=10000 Wed=10000 Wee=10000 Weg=10000 Wem=10000 Wgb=10000 Wgd=0 Wgg=6056 Wgm=6056 Wmb=10000 Wmd=0 Wme=0 Wmg=3944 Wmm=10000
directory-signature sha256 14C131DFC5C6F93646BE72FA1401C02A8DF2E8B4 0B49FD2F55D02B630E7A500E34FD5B6F98FDA9D2
-----BEGIN SIGNATURE-----
OYThM95E2Pcj4RWZeND9+llOUlyHLwGtHqF+n92xKTsZdc7ogigEosdqVEB1GaeJ
D/GWSESN9VLEiiw5VKBG4UVvZUaFVRUnZSJVS4gNgckH5LD0VUJb0C/tIeBHJ7ea
cTOwsb0vHau/W8hkAciEWLfjmAtcWutdT6lljSJ65NWyZynDPHTmtKnsB65kKT+2
p5W9GBxnMUH+Pnt2JkFqyKAsE8GgppMuk4O+AX+BtQgzK4K+pTcKFko6e/NmrBh3
W6AV/fR9/PdSUNYb6+uH/LsUhVePFVbke44u6bBN39LkvxWErQdd3yA91lUdqwz8
zR/uAngvj05Bt1zmH9eG1Kd02dgL4PqNmTI0VKZjWamf4k/xMmecU0xfrHLv52Rw
/hync6FsEIrfI+B942sjIEGfv+T6UuIMNoMvkwrby6nw6WL7lAoJJq5pyBYLzlFj
xLW6e567FFjqf4siHpGCzWCHoXUU+NmygDSakh0orgGoHdVW6JcKbs0QieUyUu+X
-----END SIGNATURE-----
directory-signature sha256 23D15D965BC35114467363C165C4F724B64B4F66 3C12B8EE0B3DC3AEDD8CD27CCB02C564281BE765
-----BEGIN SIGNATURE-----
doESbeqw4jQagxP8o0Yr6VVUdB2Hnmct4F5sH1pBntPYOqIeT3GbYuFT1TdYr9SG
xSpI5+aRcbSQrKryvF+qSgOJS4131YuCmL7zlwhQrQcFtltyRS8UTopubrLbvAJ1
njJt05lM8NWg6NN3uZ4Zy4L/qzn9qZB9l8WbxKZJnxott6+Rp1H19tsl77ENB4GJ
Bfhc9C46LOKUfmV5IB0f+0nFOO3PDhbRFEcDw5EEGPx6xLk+EH9YHvP98VIY/YPi
vtYN9G5G2PplvqG4hyIhGAYy/hm3ZTHf9eIsKvsBgHadBeFCupA/l6tf36nK94Ts
d68QhqPo8QhrjM5FTddGOA==
-----END SIGNATURE-----
directory-signature sha256 49015F787433103580E3B66A1707A00E60F2D15B 2467B90267EEEDDD614694F16A523B0E6EBF6FAA
-----BEGIN SIGNATURE-----
NVXfCo512TGvfHr+9XB7nVTDMRurSlwrz/vHfXjSzmJ/6dbIK6PA98lBgvX3i83N
2AZoUcIc5wasYjUleRrP4k2jn5sBArCr3g64FsZ4/RJMLg2pWxEw4xDY2DLjKpyZ
BfndyOG5KSEtIszXw0szS0kkTyz7oI76L1vu016Mh35YjaeqK0Vu+P2gxJtKxNyt
pLPZwTWVQfjqLAebtXD2Bi5Csty7TSAhsNe9KE5pUB7+DyzvbamuJzyhUFbuOgii
Y1nguoknHVgHnrlVGNaF1T3x2QFb3SR5Q4v8p2u1j0zqktkYTZ693gHYzkjWuyGk
W/MyhtG1cE7knxu/no+HBw==
-----END SIGNATURE-----
directory-signature sha256 585769C78764D58426B8B52B6651A5A71137189A 02958C9BE542EEA43130E54FE6634B6E874B196D
-----BEGIN SIGNATURE-----
XAZPIaIQSTj+8QWZm5dAtiQz2CnEeuM7WMcJikol7CL53n1ewG6k6vYgtFPCJ5uh
EDGTM4eojUB0VXNpc+jeOv207Y5z2r6tjAknr1eMxPX65z2BT4WkeBZLnc68RRrM
LUAe2IbOVeaqTnQmPAtSejO8xxIkJhfZAssrxdLtvagCpkcBYwAbHiVtYWv/G+r0
pyqVzvxIaEoEFShe77bJqfjOnlLOgcTsxdmU3qcDad/5k8ewXfLVcqR8YsjoNF9D
9xbHyqkBZs0EfcNoDhqWsbuq184zMjlSH0Q3QElK/0ZoQQ1y6vlSicKM9rl8vxmf
hRx2hnKyx+yhBT4fpL22ew==
-----END SIGNATURE-----
directory-signature sha256 80550987E1D626E3EBA5E5E75A458DE0626D088C 7C5D0700D9C266B7D3F93E7C904A62FEC6B30A60
-----BEGIN SIGNATURE-----
WwrdpjcjuzxmV+E1ULuuFo98nMiN0iMw6MLAs7+kuOdjbW+ayKzizZvnDPjlMv1p
2cJM7qAwnD6aSxzn1wpc0ecdaVae1cMYqEnP3BxFFY9Xh4dxu8JdlNhB7W3rlIva
lptekvZQnRBb2J4ULws4455AP6oNTCO9x3UpGNd5tbc=
-----END SIGNATURE-----
directory-signature sha256 D586D18309DED4CD6D57C18FDB97EFA96D330566 F1E67374A96F51A0BB4C8C24748200885EFF8645
-----BEGIN SIGNATURE-----
fgn1RZSa2xtYrOiG9YUtQdPl9RMZ8YQsxImg7D53AoXrctC8Ul48CNnIz/JWdIts
qcczwUtSSixuEDD5gqBcFn0Fi7S1E2F8VcmCUAh7AMBtVSn5vUKkmaQcSy+zG0N+
ospb0wQYbJ2DcsVTqL9z4TLpNB09BLN0kOzS64MJAqH9thE/1GHGNeXRFHupYgTO
PERdyFvFEAmS9XnSxSRitgf6ptG5sAlFbzQrueKmnlrVe51gJBTEZNgVb1wFTjEw
7nHTvTz9c0AQfgW5if1nIh2RdQ9AeOo3FxCbFMeT53QzHiEZWSDsCZebE/EHf/lz
od6P497tWLK6TIxctbWAXw==
-----END SIGNATURE-----
directory-signature sha256 E8A9C45EDE6D711294FADF8E7951F4DE6CA56B58 292252D59020B903943C025D96134575E1245ADF
-----BEGIN SIGNATURE-----
LzZynAMcx4EWSAqaXRaL2iHCET9T+T8e15kDiPyefxTc5U00Ko6ASKJPpmaHHHAI
SsYQm54TauFX7AOb7Q+9Fx8ujxA0AR85DglLXftAicM27L48E4d9E3qFtzi+0ZHs
At0Wp9odW7ZeFcBNHWFGB/KfqOwHYkukRvqR3vBlKG8nvQ7cC+9o9aXhl4CLoA8X
ViigiEINXCC1BFibg/XA/XZqDB7uxoeazririKp0qZTTZPp8sLSQBnrSvA3OL1I5
c0m4xogooiG+YhGBC7N+MR+hDA9nyV+njVABpy/89/6Zy+y4iydqqO0qSRWXio9W
3T36ECUvEQ9l+FONnfk0cQ==
-----END SIGNATURE-----
directory-signature sha256 ED03BB616EB2F60BEC80151114BB25CEF515B226 5E04DFE1E5E0852F56E524B7C81D1E5FAFDBA650
-----BEGIN SIGNATURE-----
UtcSi7Qb7CijqBhpMsFeqlhRxMTOGqldmdiDCp8ZLJFOCQGIHA9m9c62mlTIleDH
iz/LdCn7RdGm7VoX7+jd3FfU86dajnyREDcwvvTHZ8eIUx6Bz+Q7zmv6yRBctmNL
hqYcK0WHxmELYxwICljLPeu6QOaRE+4Ku1YbNoEFL/YJ4GmgAPODxxy35N+t3uRr
MzWK7N+Ssdo0cRvz47cMBZqRQOKzn3a5/KMnRcBmZbhmJbhi5O9C3tZVA+XFa3fF
jRGbtUir/OE23WmykdXKGmsymXX3b/io+w6UQjBUVzGHQtJLszMTKNE24eUnVOFD
9Yc8aj5LgGkmJbNxyiF0mQ==
-----END SIGNATURE-----
directory-signature sha256 EFCBE720AB3A82B99F9E953CD5BF50F7EEFC7B97 F22B7C6FB4E6DA30A3C63D265A1D4AB374CB34E3
-----BEGIN SIGNATURE-----
uh/7AVwA+T8EWm9GgQxYzPPBibvb2/FP5Ny6p9x95oJRWjWeKEM77hnojJ540N6u
IyyIJTUB5JgUrsN2BXEnyUqZu0+OWB9hYxFIzVjwUxtuL2uaPeBfXqv5iJNEqG9w
Gl1ubnFUbVZXM83e61ClgwaswhvVPzfgirqpmD+L9m/DaZj+EmzZtoquqaBNtv1g
qU/yZgFG4AFApjvSaP6kkttZ8EYTVtGMq6muIxLeBDlVRP2dmC+R5FwGmsbj92is
uxaCO4raz5BM6yyDS44vzJwFePOyQhiYNV52g8dod/xtrhZOlWQtCbX3jXxv4ofV
nfX9MJA9VJ5WbLSpwU1p/w==
-----END SIGNATURE-----
stem-1.6.0/test/unit/descriptor/data/unparseable/vote 0000664 0001750 0001750 00000010774 13124757510 023454 0 ustar atagar atagar 0000000 0000000 network-status-version 3
vote-status vote
consensus-methods 1 2 3 4 5 6 7 8 9 10 11 12
published 2012-07-11 23:50:01
valid-after 2012-07-12 00:00:00
fresh-until 2012-07-12 01:00:00
valid-until 2012-07-12 03:00:00
voting-delay 300 300
known-flags Authority BadExit Exit Fast Guard HSDir Running Stable V2Dir Valid
params CircuitPriorityHalflifeMsec=30000 bwauthpid=1
dir-source turtles 27B6B5996C426270A5C95488AA5BCEB6BCC86956 76.73.17.194 76.73.17.194 9030 9090
contact Mike Perry
dir-key-certificate-version 3
fingerprint 27B6B5996C426270A5C95488AA5BCEB6BCC86956
dir-key-published 2011-11-28 21:51:04
dir-key-expires 2012-11-28 21:51:04
dir-identity-key
-----BEGIN RSA PUBLIC KEY-----
MIIBigKCAYEA6uSmsoxj2MiJ3qyZq0qYXlRoG8o82SNqg+22m+t1c7MlQOZWPJYn
XeMcBCt8xrTeIt2ZI+Q/Kt2QJSeD9WZRevTKk/kn5Tg2+xXPogalUU47y5tUohGz
+Q8+CxtRSXpDxBHL2P8rLHvGrI69wbNHGoQkce/7gJy9vw5Ie2qzbyXk1NG6V8Fb
pr6A885vHo6TbhUnolz2Wqt/kN+UorjLkN2H3fV+iGcQFv42SyHYGDLa0WwL3PJJ
r/veu36S3VaHBrfhutfioi+d3d4Ya0bKwiWi5Lm2CHuuRTgMpHLU9vlci8Hunuxq
HsULe2oMsr4VEic7sW5SPC5Obpx6hStHdNv1GxoSEm3/vIuPM8pINpU5ZYAyH9yO
Ef22ZHeiVMMKmpV9TtFyiFqvlI6GpQn3mNbsQqF1y3XCA3Q4vlRAkpgJVUSvTxFP
2bNDobOyVCpCM/rwxU1+RCNY5MFJ/+oktUY+0ydvTen3gFdZdgNqCYjKPLfBNm9m
RGL7jZunMUNvAgMBAAE=
-----END RSA PUBLIC KEY-----
dir-signing-key
-----BEGIN RSA PUBLIC KEY-----
MIGJAoGBAJ5itcJRYNEM3Qf1OVWLRkwjqf84oXPc2ZusaJ5zOe7TVvBMra9GNyc0
NM9y6zVkHCAePAjr4KbW/8P1olA6FUE2LV9bozaU1jFf6K8B2OELKs5FUEW+n+ic
GM0x6MhngyXonWOcKt5Gj+mAu5lrno9tpNbPkz2Utr/Pi0nsDhWlAgMBAAE=
-----END RSA PUBLIC KEY-----
dir-key-crosscert
-----BEGIN ID SIGNATURE-----
RHYImGTwg36wmEdAn7qaRg2sAfql7ZCtPIL/O3lU5OIdXXp0tNn/K00Bamqohjk+
Tz4FKsKXGDlbGv67PQcZPOK6NF0GRkNh4pk89prrDO4XwtEn7rkHHdBH6/qQ7IRG
GdDZHtZ1a69oFZvPWD3hUaB50xeIe7GoKdKIfdNNJ+8=
-----END ID SIGNATURE-----
dir-key-certification
-----BEGIN SIGNATURE-----
fasWOGyUZ3iMCYpDfJ+0JcMiTH25sXPWzvlHorEOyOMbaMqRYpZU4GHzt1jLgdl6
AAoR6KdamsLg5VE8xzst48a4UFuzHFlklZ5O8om2rcvDd5DhSnWWYZnYJecqB+bo
dNisPmaIVSAWb29U8BpNRj4GMC9KAgGYUj8aE/KtutAeEekFfFEHTfWZ2fFp4j3m
9rY8FWraqyiF+Emq1T8pAAgMQ+79R3oZxq0TXS42Z4Anhms735ccauKhI3pDKjbl
tD5vAzIHOyjAOXj7a6jY/GrnaBNuJ4qe/4Hf9UmzK/jKKwG95BPJtPTT4LoFwEB0
KG2OUeQUNoCck4nDpsZwFqPlrWCHcHfTV2iDYFV1HQWDTtZz/qf+GtB8NXsq+I1w
brADmvReM2BD6p/13h0QURCI5hq7ZYlIKcKrBa0jn1d9cduULl7vgKsRCJDls/ID
emBZ6pUxMpBmV0v+PrA3v9w4DlE7GHAq61FF/zju2kpqj6MInbEvI/E+e438sWsL
-----END SIGNATURE-----
r sumkledi ABPSI4nNUNC3hKPkBhyzHozozrU B5n4BiALAF8B5AqafxohyYiuj7E 2012-07-11 04:22:53 178.218.213.229 80 0
s Exit Valid
opt v Tor 0.2.2.35
w Bandwidth=51 Measured=36
p accept 80,443
m 8,9,10,11,12 sha256=g1vx9si329muxV3tquWIXXySNOIwRGMeAESKs/v4DWs
r Unnamed AEXri4INxBAZeyi0wvJZoC58nZs csTseFzwBV0RLsEdlyxDw6jTZ1o 2012-07-11 10:47:26 79.139.135.90 443 22
s Fast HSDir Running V2Dir Valid
opt v Tor 0.2.2.37
w Bandwidth=92 Measured=15
p reject 1-65535
m 8,9,10,11,12 sha256=iZfmvEGdBG/qc9KYZUh4JsWEHbn9Bw2jy5i0AtCoRB0
r default AFU4pMWKyq+eTPuBO0D9W179kQQ OZzEaq9N5+VX5yxzi051zqyEcPk 2012-07-11 08:17:21 2.90.115.167 443 9030
s V2Dir Valid
opt v Tor 0.2.3.15-alpha
w Bandwidth=53
p reject 1-65535
m 8,9,10,11,12 sha256=m/RouK3TqoaYBBHCxgmzMPuGGCIEr0ufSTB1i85zicM
r satoshi11 AFzRyEo3Ibdko7vl4rReoU3BDfM rWaYhhU9Kym4sXAVe+uE99VGpJs 2012-07-11 08:10:01 80.218.153.44 443 9030
s V2Dir Valid
opt v Tor 0.2.2.35
w Bandwidth=196 Measured=113
p reject 1-65535
m 8,9,10,11,12 sha256=yxuOPz7IraIzzmU/qeZRJHOJrutNmvPwDwj2AmsHZSI
r JapanAnon AGw/p8P246zRPQ3ZsQx9+pM8I3s FpQ4fP9FE2j4AnpZTcPiUbaIjwQ 2012-07-11 15:55:42 220.0.231.71 443 9030
s Exit V2Dir Valid
opt v Tor 0.2.2.37
w Bandwidth=41 Measured=5
p accept 110,143,443,706,993,995,1863,5050,5190,5222-5223,6660-6669,6697,7000-7001,8300,8888
m 8,9,10,11,12 sha256=fdV6McsFl7ZaX8YJjRCchKa7B7ImTr6++AE3e7zCkK8
r ANONIONROUTER AHhuQ8zFQJdT8l42Axxc6m6kNwI UUUhUJVXZ5b+8Lizh1ghVkUTGo0 2012-07-11 20:13:16 93.128.114.184 24051 24052
s Fast Running V2Dir Valid
opt v Tor 0.2.2.37
w Bandwidth=196 Measured=100
p reject 1-65535
m 8,9,10,11,12 sha256=ooi27oMS4TBXes4FY4JyULgZYZcFzAyvB1JicaQ8zxs
r pornosteffi AJrkZLNAIMRi7J3Q5os1iBJTM38 tV2vC76eZNwVpSFO8+r9lCqJSVw 2012-07-11 11:00:29 88.78.83.210 443 0
s Fast Running Valid
opt v Tor 0.2.2.35
w Bandwidth=32 Measured=14
p reject 1-65535
m 8,9,10,11,12 sha256=JiARdiiTbey4aLkt4x1DUgEU3oaD2oDB2dtP7SGl3EU
directory-footer
directory-signature 27B6B5996C426270A5C95488AA5BCEB6BCC86956 D5C30C15BB3F1DA27669C2D88439939E8F418FCF
-----BEGIN SIGNATURE-----
fskXN84wB3mXfo+yKGSt0AcDaaPuU3NwMR3ROxWgLN0KjAaVi2eV9PkPCsQkcgw3
JZ/1HL9sHyZfo6bwaC6YSM9PNiiY6L7rnGpS7UkHiFI+M96VCMorvjm5YPs3FioJ
DnN5aFtYKiTc19qIC7Nmo+afPdDEf0MlJvEOP5EWl3w=
-----END SIGNATURE-----
stem-1.6.0/test/unit/descriptor/data/unparseable/tiny.png 0000664 0001750 0001750 00000000274 13124757510 024237 0 ustar atagar atagar 0000000 0000000 ‰PNG
IHDR
PXê sRGB ®Î é pHYs šœ tIMEÜ )ô¿a tEXtComment Created with GIMPW )IDATÓc``````øÏÀðŸ“ÍÄ€0B2Âô¡± èf²v ÿ¡qƒ IEND®B`‚ stem-1.6.0/test/unit/descriptor/data/unparseable/new_metrics_type 0000664 0001750 0001750 00000000125 13124757510 026044 0 ustar atagar atagar 0000000 0000000 @type non-existant-type 1.0
valid metrics header, but a type we shouldn't recognize
stem-1.6.0/test/unit/descriptor/data/unparseable/riddle 0000664 0001750 0001750 00000001067 13124757510 023735 0 ustar atagar atagar 0000000 0000000 Riddle by Damian Johnson (May, 2009)
Curtains raise, they take the stage,
mute actors that never age.
The clouds are cotton, the floor is pine,
the souls bound up in fine twine.
Crowds will cheer, the players dance,
flowing scene to scene as in a trance.
The world is perfect, they never whine,
for there's not a single will, save mine.
The play has ended, we take a bow,
but the viewers are the actors now.
When freed from decision, of thought and blame,
we'll walk to another drum just the same.
answer:
http://www.atagar.com/riddles/answer10.php
stem-1.6.0/test/unit/descriptor/data/descriptor_archive.tar.gz 0000664 0001750 0001750 00000005472 13115423200 025242 0 ustar atagar atagar 0000000 0000000 ‹ Ó}¶O íZYÓâ¸Ùík~…/ú"ŠF’µNUª>¯l/ûò7)Û`¼°ýúÈ=5i¿™îLϤ§çKŇ,éÑæGztŽÁóÓMž³8ù»“lváÕo‚&j´Q!ôTq¨!À9pɆ“@Ý@AU¬‚6ï¾@‚b\|CF@ù» ¦¼ƒ2‡`F)¦ï ‚TeïðUÿ‡ÈÓÌIå“9['ù²Ý¯•ÿ—âÿ²ÇÙWR?¹úIÃûçbPàPKâ<óE;å‘ŸA
ñó³*Q0V pP; ,ˆ““2“ÕÀ$_*Vþ²
³F |èû‚;´†€ýU‰#å%Œò»rçôï×âs¦œ“8‹7ñ1-Š
Tb„É&3Öι{ Óï)@Ô j ˆ ýþT=£Ÿœ“0Êš\Q-)¦° Âu )LSU#n+Ü°5EDU(£B±µüœ…'_A*ªà5׉¼[èe;Ì £ ÈŽƒÉ+N! ~ìÖ¿g‰Ó£ nxáÖO3ņ0-"¸¦™Œ«sƒBN„[†i3•ÚV-ŽÂ8j üGQ@·Z2™jÊh®¿t ¥g>ÔúVW‹[ºöb
ÔK¹oƒñý×Ó[| Æá<ö—µï‘ß]yíWý¾=¯0X üºíðÚÑLÐò†F‹¶±ÛžæG|·–6Œ2:7:1×í ½è÷&«stºÓ!<é nÌÜ··f>ªÙÓ£»4wãþ«kϸ{uwÇ™õ¯G9¸‰.ݦ¾Ö&–çÏöÇî#½¬"OÛöuM³þöÓì¬ùÙ¹¥á6’žûM·a0lÖJšíSüXhîvdÀá|¢‹ÑrÒŒæã‘çúÚ"15Èì¥{|h³8›ÔDô„ð:ZD¼
†æ2‰ØÊr.÷•¹Ÿö¯Îf³=_íûöpöÖsš†+ýe•Þ[KÇ|¤5lGc-¼#kíX½8ÂY>ïµötÿ²Ù·ÉB?„÷ ~]î…wð(VýSôu·!pNáñ¡¼†¥¶-a˜éTµ4ΩàPÕmjk:31ÁÀ€Ê{h›3‹ÛThBgØ Ó€TCDckº°©òža['–Q
SÓ€¹ M‰i `QÍ”†´d2$›Ü”
Ú Ø jFL£ŒØ„!$Í•÷#²_®ê2“j:Ô¡& ˶™‰LY˜ÕÒ•÷&²UfËàΑT9Ìg¶I ³(ºŠ-Íæ)ï- ›„iÚÅi ”‡aLnT
êŒc,·
––ÄR-¡a†d]¦[‚r¤sj ¤bêØ`Ŷµì;tzž 5ŠØn|¹K“Ú&Ž2g“)2Â5 ïFE@*‚×ÑOSänqr‹R‰E¦j‰¿÷¥5øðñÕä?þðs¤â"øc6¤¥|Ä>c,ÐHù/?×0+l2Eå&J±WfË5ëË)þð#
¤~JâÒ5)]3ÑàðS’óOׂR¢Ü ¸Ôr¹SÜÀ””úÂjƒà’9¡å‘pV
¥¥Q±R PC€R‹¢<ÁECˆ²¹ å)•G*Ï•«AÊe¬|/!/ÏŽòãm-²X9K™%JSTU^š£J(» Á7wµ|Ó )YX®GävlȲ¹(Ï„J4䛕³˜(§D©Œƒre™âåSÆYC~”
Þ,
ÎËeÃrJ¢tÁ›^ RÉ^ï?Kÿ#ýh…“å‰_>&¦Ö@›Í'ÖOQt _tÝ„ê~ÆçÓ1Òâµ:d{¦º‡è²Ç¯ÙÅØuçwwê¸gèvgîl7“6¾4—}ÔNƒ;ךjxn¦íú6²–rÖ];jÒÝÛìzÍ㹞×sDí=¶í %æ‚ݦ{;8°UmsiáÝa~ £8›î1T»önîºÔ}6·Ãá)¾Îa œÍ¼{+ÿ2?ÿy¿äÿ°é6¡ë2Á7Ž‰dÔž Ü<%e¾ïˈ¬úÂÃÎWõñ«üŸ²OüŸÉÿe8¯øÿwÁ×óÿ7 ¡?‰ÿC y¤Èøñ þm©J,KeŠ(S€*%Ç1"5Ö»P¶bZœþ“ÿ#ÉSdlÿ÷ü_@!¾úþ/Ô‚€H."5‚*•€‰…mÝÒT`SÉéLL9ó÷ð{·ôtšu»7ò$‡Ûd·Þ¯²ø‘vœ×+iiâ4‰žÄp:bÛ<´Ñl=¥Í';מÖ2ÉRÓ£“çt6Yêža»ËÛ5ÃAörÉÖûºê?[ŽŸ{0ضÏ*{M/ñ±n¬“³s‚µÅx¶_õçËÖù8w·Ì|íöÖõ´Íz¼@çC7ÔìÓ ]¼¦ñ, ·sšýqüQ[ÅÝù9{Ê{Æ †§ô¾k]9íƒÀŽmkÖ뿘^~‚G¯-<Ú®i=\Ÿ„~*Ô×{«³¶ï³
ѧNkÓ ÎËÙŠðÃj
âæ0žë¹³çñ–ìÍiêäÎLR»'îI<šý¬¹1N‚Ïðr5^N0±
o³Ù ÜOIú«ø ßw»éóÑŒîÿëü¿Ðâ…/”x!Ä ^ÈðB…"¼Ðà…¯” ¥p¥*¥P)…7ûR ¨i €;y ~‡ÿ¥œ«ü_¡B…
*T¨P¡B…
*T¨P¡B…
*T¨P¡B…
*T¨P¡Â¯á Z©Üš P stem-1.6.0/test/unit/descriptor/data/bridge_extrainfo_descriptor_with_ed25519 0000664 0001750 0001750 00000002433 13115423200 030033 0 ustar atagar atagar 0000000 0000000 @type bridge-extra-info 1.3
extra-info Unnamed B8AB331047F1C1637EFE07FB1B94CCC0FE0ABFFA
master-key-ed25519 VigmhxML9uw8CT1XeGqZ8KLMhKk6AOKnChQt24usBbI
published 2015-08-21 16:08:15
write-history 2015-08-21 12:51:16 (14400 s) 2371584,40206336,45142016,8745984,6049792,1072128
read-history 2015-08-21 12:51:16 (14400 s) 5175296,43838464,50509824,13580288,8732672,4001792
dirreq-write-history 2015-08-21 12:51:16 (14400 s) 1630208,565248,29696,28672,1993728,581632
dirreq-read-history 2015-08-21 12:51:16 (14400 s) 1024,3072,5120,4096,285696,11264
geoip-db-digest 6882B8663F74C23E26E3C2274C24CAB2E82D67A2
geoip6-db-digest F063BD5247EB9829E6B9E586393D7036656DAF44
dirreq-stats-end 2015-08-21 12:51:16 (86400 s)
dirreq-v3-ips ie=8,in=8,kz=8,nl=8,qa=8
dirreq-v3-reqs ie=8,in=8,kz=8,nl=8,qa=8
dirreq-v3-resp ok=8,not-enough-sigs=0,unavailable=0,not-found=0,not-modified=0,busy=0
dirreq-v3-direct-dl complete=0,timeout=0,running=0
dirreq-v3-tunneled-dl complete=4,timeout=4,running=0
transport scramblesuit
transport obfs3
transport obfs4
bridge-stats-end 2015-08-21 12:51:21 (86400 s)
bridge-ips ie=8,in=8,kz=8,nl=8,qa=8
bridge-ip-versions v4=8,v6=0
bridge-ip-transports =8,obfs3=8,obfs4=8
router-digest-sha256 7DSOQz9eGgjDX6GT7qcrVViK8yqJD4aoEnuhdAgYtgA
router-digest 3DBE6840376F3EC277002396832788DB2FB38393
stem-1.6.0/test/unit/descriptor/data/metrics_cert 0000664 0001750 0001750 00000003202 13115423200 022627 0 ustar atagar atagar 0000000 0000000 @type dir-key-certificate-3 1.0
dir-key-certificate-version 3
fingerprint 14C131DFC5C6F93646BE72FA1401C02A8DF2E8B4
dir-key-published 2008-05-09 21:13:26
dir-key-expires 2009-05-09 21:13:26
dir-identity-key
-----BEGIN RSA PUBLIC KEY-----
MIIBigKCAYEA7cZXvDRxfjDYtr9/9UsQ852+6cmHMr8VVh8GkLwbq3RzqjkULwQ2
R9mFvG4FnqMcMKXi62rYYA3fZL1afhT804cpvyp/D3dPM8QxW88fafFAgIFP4LiD
0JYjnF8cva5qZ0nzlWnMXLb32IXSvsGSE2FRyAV0YN9a6k967LSgCfUnZ+IKMezW
1vhL9YK4QIfsDowgtVsavg63GzGmA7JvZmn77+/J5wKz11vGr7Wttf8XABbH2taX
O9j/KGBOX2OKhoF3mXfZSmUO2dV9NMwtkJ7zD///Ny6sfApWV6kVP4O9TdG3bAsl
+fHCoCKgF/jAAWzh6VckQTOPzQZaH5aMWfXrDlzFWg17MjonI+bBTD2Ex2pHczzJ
bN7coDMRH2SuOXv8wFf27KdUxZ/GcrXSRGzlRLygxqlripUanjVGN2JvrVQVr0kz
pjNjiZl2z8ZyZ5d4zQuBi074JPGgx62xAstP37v1mPw14sIWfLgY16ewYuS5bCxV
lyS28jsPht9VAgMBAAE=
-----END RSA PUBLIC KEY-----
dir-signing-key
-----BEGIN RSA PUBLIC KEY-----
MIGJAoGBAOeE3Qr1Km97gTgiB3io0EU0fqHW2ESMXVHeQuNDtCWBa0XSCEG6gx4B
ZkkHjfVWqGQ7TmmzjYP9L9uCgtoKfhSvJA2w9NUMtMl8sgZmF4lcGpXXvGY9a566
Bn+3wP0lMhb/I8CPVPX+NWEjgl1noZxo1C59SO/iALGQOpxRYgmbAgMBAAE=
-----END RSA PUBLIC KEY-----
dir-key-certification
-----BEGIN SIGNATURE-----
asvWwaMq34OfHoWUhAwh4+JDOuEUZJVIHQnedOYfQH8asS2QvW3Ma93OhrwVOC6b
FyKmTJmJsl0MJGiC7tcEOlL6knsKE4CsuIw/PEcu2Rnm+R9zWxQuMYiHvGQMoDxl
giOhLLs4LlzAAJlbfbd3hjF4STVAtTwmxYuIjb1Mq/JfAsx/wH3TLXgVZwj32w9s
zUd9KZwwLzFiiHpC+U7zh6+wRsZfo2tlpmcaP1dTSINgVbdzPJ/DOUlx9nwTCBsE
AQpUx2DpAikwrpw0zDqpQvYulcQlNLWFN/y/PkmiK8mIJk0OBMiQA7JgqWamnnk4
PwqaGv483LkBF+25JFGJmnUVve3RMc+s61+2kBcjfUMed4QaHkeCMHqlRqpfQVkk
RY22NXCwrJvSMEwiy7acC8FGysqwHRyE356+Rw6TB43g3Tno9KaHEK7MHXjSHwNs
GM9hAsAMRX9Ogqhq5UjDNqEsvDKuyVeyh7unSZEOip9Zr6K/+7VsVPNb8vfBRBjo
-----END SIGNATURE-----
stem-1.6.0/test/unit/descriptor/data/extrainfo_descriptor_with_ed25519 0000664 0001750 0001750 00000002424 13115423200 026517 0 ustar atagar atagar 0000000 0000000 @type extra-info 1.0
extra-info silverfoxden 4970B1DC3DBC8D82D7F1E43FF44B28DBF4765A4E
identity-ed25519
-----BEGIN ED25519 CERT-----
AQQABhz0AQFcf5tGWLvPvr1sktoezBB95j6tAWSECa3Eo2ZuBtRNAQAgBABFAwSN
GcRlGIte4I1giLvQSTcXefT93rvx2PZ8wEDewxWdy6tzcLouPfE3Beu/eUyg8ntt
YuVlzi50WXzGlGnPmeounGLo0EDHTGzcLucFWpe0g/0ia6UDqgQiAySMBwI=
-----END ED25519 CERT-----
published 2015-08-22 19:21:12
write-history 2015-08-22 19:20:44 (14400 s) 14409728,23076864,7756800,6234112,7446528,12290048
read-history 2015-08-22 19:20:44 (14400 s) 20449280,23888896,9099264,7185408,8880128,13230080
geoip-db-digest 6882B8663F74C23E26E3C2274C24CAB2E82D67A2
geoip6-db-digest F063BD5247EB9829E6B9E586393D7036656DAF44
dirreq-stats-end 2015-08-22 11:58:30 (86400 s)
dirreq-v3-ips
dirreq-v3-reqs
dirreq-v3-resp ok=0,not-enough-sigs=0,unavailable=0,not-found=0,not-modified=0,busy=0
dirreq-v3-direct-dl complete=0,timeout=0,running=0
dirreq-v3-tunneled-dl complete=0,timeout=0,running=0
router-sig-ed25519 g6Zg7Er8K7C1etmt7p20INE1ExIvMRPvhwt6sjbLqEK+EtQq8hT+86hQ1xu7cnz6bHee+Zhhmcc4JamV4eiMAw
router-signature
-----BEGIN SIGNATURE-----
R7kNaIWZrg3n3FWFBRMlEK2cbnha7gUIs8ToksLe+SF0dgoZiLyV3GKrnzdE/K6D
qdiOMN7eK04MOZVlgxkA5ayi61FTYVveK1HrDbJ+sEUwsviVGdif6kk/9DXOiyIJ
7wP/tofgHj/aCbFZb1PGU0zrEVLa72hVJ6cCW8w/t1s=
-----END SIGNATURE-----
stem-1.6.0/test/unit/descriptor/data/cached-certs 0000664 0001750 0001750 00000010650 13124757510 022514 0 ustar atagar atagar 0000000 0000000 dir-key-certificate-version 3
dir-address 127.0.0.1:7000
fingerprint BCB380A633592C218757BEE11E630511A485658A
dir-key-published 2017-05-25 04:45:52
dir-key-expires 2018-05-25 04:45:52
dir-identity-key
-----BEGIN RSA PUBLIC KEY-----
MIIBigKCAYEAxfTHG1b3Sxe8n3JQ/nIk4+1/chj7+jAyLLK+WrEBiP1vnDxTXMuo
x26ntWEjOaxjtKB12k5wMQW94/KvE754Gn98uQRFBHqLkrS4hUnn4/MqiBQVd2y3
UtE6KDSRhJZ5LfFH+dCKwu5+695PyJp/pfCUSOyPj0HQbFOnAOqdHPok8dtdfsy0
LaI7ycpzqAalzgrlwFP5KwwLtL+VapUGN4QOZlIXgL4W5e7OAG42lZhHt0b7/zdt
oIegZM1y8tK2l75ijqsvbetddQcFlnVaYzNwlQAUIZuxJOGfnPfTo+WrjCgrK2ur
ed5NiQMrEbZn5uCUscs+xLlKl4uKW0XXo1EIL45yBrVbmlP6V3/9diTHk64W9+m8
2G4ToDyH8J7LvnYPsmD0cCaQEceebxYVlmmwgqdORH/ixbeGF7JalTwtWBQYo2r0
VZAqjRwxR9dri6m1MIpzmzWmrbXghZ1IzJEL1rpB0okA/bE8AUGRx61eKnbI415O
PmO06JMpvkxxAgMBAAE=
-----END RSA PUBLIC KEY-----
dir-signing-key
-----BEGIN RSA PUBLIC KEY-----
MIIBCgKCAQEAvzugxJl1gc7BgXarBO5IWejNZC30U1xVjZ/myQTzxtiKkPU0agQh
sPqn4vVsaW6ZnWjJ2pSOq0/jg8WgFyGHGQ9cG8tv2TlpObeb/tI7iANxWx+MXJAh
/CnFDBQ1ifKntJrs2IcRKMivfobqaHAL3Pz93noLWOTQunWjZ8D6kovYvUXe+yUQ
tZEROrmXJx7ZIIJF6BNKYBTc+iEkYtkWlJVs0my7yP/bbS075QyBsr6CfT+O2yU4
mgIg43QuqcFRbjyUvGI/gap06QNlB6yj8pqeE5rWo++5EpEvMK76fK6ymYuTN2SN
Oil+Fo7qgG8UP/fv0GelSz6Tk7pBoeHJlQIDAQAB
-----END RSA PUBLIC KEY-----
dir-key-crosscert
-----BEGIN ID SIGNATURE-----
Oz+rvXDzlxLgQSb3nS5/4hrHVWgGCy0OnuNmFsyw8bi2eBst5Yj79dQ+D25giZke
81FRGIFU4eS6dshB+pJ+z0hc9ozlRTYh/qevY6l6o0amvuhHyk/cQXrh8oYU9Ihe
XQ1yVItvxC24HENsoGIGbr5uxc85FOcNs+R9qTLYA/56TjvAU4WUje3nTZE1awml
lj/Y6DM7ruMF6UoYJZPTklukZ+XHZg4Z2eE55e/oIaD7bfU/lFWU/alMyTV/J5oT
sxaD2XBLBScYiKypUmgrZ50W4ZqsXaYk76ClrudZnDbce+FuugVxok+jKYGjMu75
2es2ucuik7iuO7QPdPIXfg==
-----END ID SIGNATURE-----
dir-key-certification
-----BEGIN SIGNATURE-----
I86FTQ5ZyCZUzm19HVAQWByrrRgUmddoRBfNiCj0iTGN3kdIq9OfuNLhWAqz71xP
8Nn0Vun8Uj3/vBq/odIFpnngL3mKI6OEKcNDr0D5hEV9Yjrxe8msMoaUZT+LHzUW
1q3pzxfMx6EmlSilMhuzSsa4YEbXMZzMqASKANSJHo2fzUkzQOpPw2SlWSTIgyqw
wAOB6QOvFfP3c0NTwxXrYE/iT+r90wZBuzS+v7r9B94alNAkE1KZQKnq2QTTIznP
iF9LWMsZcMHCjoTxszK4jF4MRMN/S4Xl8yQo0/z6FoqBz4RIXzFtJoG/rbXdKfkE
nJK9iEhaZbS1IN0o+uIGtvOm2rQSu9gS8merurr5GDSK3szjesPVJuF00mCNgOx4
hAYPN9N8HAL4zGE/l1UM7BGg3L84A0RMpDxnpXePd9mlHLhl4UV2lrkkf8S9Z6fX
PPc3r7zKlL/jEGHwz+C7kE88HIvkVnKLLn//40b6HxitHSOCkZ1vtp8YyXae6xnU
-----END SIGNATURE-----
dir-key-certificate-version 3
dir-address 127.0.0.1:7001
fingerprint 596CD48D61FDA4E868F4AA10FF559917BE3B1A35
dir-key-published 2017-05-25 04:45:58
dir-key-expires 2018-05-25 04:45:58
dir-identity-key
-----BEGIN RSA PUBLIC KEY-----
MIIBigKCAYEAu+wP/sAA3tcKI5ICHUTs4uwsqSPNcFDalL7VR9/N4dsgsNd5t+4Z
4v1lc/RovxYC0ojLqe9WE+SsB0cpSRBGA4xSQMOKj3zR1gIO7LQmv2IxYruRlkNo
CxJglbFQOF7gnOOAALygyPl7T5y6BfAeqI9Y51JeHqrgL+7pxAGJ1hNCux4bsAFx
MwNxydBeGS3/yJFp+xJiZl6ocmi9oAmJ4OZmrwKCFTit2Yq5jgbHDkY0OZR6ul8b
xCJRKBSl7jGUhLi1MlW0oGQauKnJ3C/N5rP1icvPJbgP5aZVLqSXFFEGTbjDyFiP
AjlyCozL/A7evAwo1JtxbtBNVCmzUUItP5kd4+YQnYvmH8fRp17JMxLwWLNe0hSx
suljZDdxgCWruTQz8EC73LcExkPQxTb+FUQ3EDm0uGi2A1PUR8+Xtc7fejwov6PN
XtrB+VSn8ne1oA6nI2SS6aNpn1MgAdahvfkTn1c9h2UEhTAeGacvmPLS0YRDdGrs
0ZvQF6Y6694tAgMBAAE=
-----END RSA PUBLIC KEY-----
dir-signing-key
-----BEGIN RSA PUBLIC KEY-----
MIIBCgKCAQEA19hY+t1GAsR08rQeqMy8/0XkBx6Ho3WN1XAmHvwkWgnIzamgXJge
THuTw/uDonGXn69NBpQWb9wVyCQ5gssjJCC4OX4EjeZaaxhtZCph3BxA0xHDMYzu
0j/zlXEpQ3Y/05ZbXcJC/VO9QVywwg3QTiTVRjhyD514UeeOxHHJ8JAm5x3puabt
FinwLi3pZBzGisTcfxfpTcZETG47mxzrRTk1KLOU0dvp0UZAdfYQfoecBrWpowCG
dt+kuCK+aUVPi+VbJXK4DzhyaU1nFxHCEEDEfAI7jSt0bdvnTTkVZuoE6JvzIsPn
18qLqG64dgiTs/zutg1Je+NRG3fw5bjg3QIDAQAB
-----END RSA PUBLIC KEY-----
dir-key-crosscert
-----BEGIN ID SIGNATURE-----
A8uI+g1fqMDwfRe7mILD9uDZXgjWc2PaZHElp21wfC5z/fO7EZHf+oBpMfnFZlpW
EgbdIWoxIWAeFiunpUEaGrNGztfXXzmCGJOCkYJS0z6QnbdTPxfARIcQL96NRJ5O
xA0xjTzoR57LKnwHSAdq9ZIjMWyJM7yf/PnD4GCU+v+0O3DzhCPt2vE7QVx6h8oU
Zkmx2GIoRv1K17B0mYJsMFnJse3aLkZdQoFRpicfWwKHtkpGB0dkuGw+OAdcx5vv
Qwb05YiQeAJF3UtPNEcCDR4v5Keia+qQeuJcta9aK2Za/n8LCaB8JrOtDrkMH7EV
DuuXUlxdZG65y9QR3jo5Ng==
-----END ID SIGNATURE-----
dir-key-certification
-----BEGIN SIGNATURE-----
l9Wa0CUIndYdX3nvMEZPoQX8jWosfNo5lTvA1r1JndNBhpr4D6rR9MmpNiaOzuM/
rcVCMwmekmPVVx2vU168PNX/1yhE0vGEfeRDpiYVXUvboPe2MC9XtUQtQEpmqPrh
EnsfqOhUoxe6uemJszEtqUzHFvcSEUIJN+RX1YG/xGUYsNy5wBZpAMcKiEq0J3c/
eCrmKs7o4HL/yPtPGdylsMiIhxLmzB1ZjSOq6OpaMPsiafIG+lu0w3G1JAZftCFQ
x+SnFdaxBjeSPlXA8YpIf4SAOx0lSjlcGc+cVUtJcQ2pH01z5s8kMLd7Rei6/Sk7
xWuiMAqmvG+McfG0C9jhkTp8r6O34zgRTq9sVeZNW/4bn/Nt8vPE8IX9StmGSOju
XA1DuwMEqH1/b5RN5qxWZlvcguEF4CPOh2KNz4M7gsPyc/57eKuvLUSGDtryG0KQ
0FgHa31RRfaO6rIKZ2z2ksHe+bHJi8SM6S9R1KFtudJX4drqTw+Q5q0JRPsKBcGu
-----END SIGNATURE-----
stem-1.6.0/test/unit/descriptor/data/bridge_descriptor 0000664 0001750 0001750 00000000673 13115423200 023647 0 ustar atagar atagar 0000000 0000000 @type bridge-server-descriptor 1.0
router Unnamed 10.18.111.71 9001 0 0
platform Tor 0.2.0.26-rc (r14597) on Linux i686
opt protocols Link 1 2 Circuit 1
published 2008-05-20 19:45:00
opt fingerprint 4ED5 7358 2B16 ACDA F6E4 2AA0 44A0 38F8 3A7F 6333
uptime 204
bandwidth 3220480 6441984 59408
opt extra-info-digest BB1F13AA431421BEA29B840A2E33BB1C31C2990B
opt caches-extra-info
reject *:*
router-digest 00F1CD29AD308A59A9AB5A88B49ECB46E0F215FD
stem-1.6.0/test/unit/descriptor/data/old_descriptor 0000664 0001750 0001750 00000005574 13115423200 023176 0 ustar atagar atagar 0000000 0000000 @type server-descriptor 1.0
router krypton 212.37.39.59 8000 0 0
platform Tor 0.1.0.14 on FreeBSD i386
published 2005-12-16 18:01:03
opt fingerprint 3E2F 63E2 356F 5231 8B53 6A12 B644 5373 808A 5D6C
uptime 64820
bandwidth 102400 10485760 0
onion-key
-----BEGIN RSA PUBLIC KEY-----
MIGJAoGBAOewVPvehUE/Iy06e/NmUyzwBdkL89DP3q+I68hJJsxQgd1Fqm2CVN4E
X0l3U14e3yyihr8xz1qmvQenWyKMx6B5ZjHrRAk774nTXzqqZMbcEKGnoWKTAgfC
SrZYD4YdO2vPIA3OIBLBvj6HlyZWPVulQANpETK1TOACKeqs6vlhAgMBAAE=
-----END RSA PUBLIC KEY-----
signing-key
-----BEGIN RSA PUBLIC KEY-----
MIGJAoGBAJjsGNwSkG7xCzWEPTr2NBrC4k2Bx0SnTv8RfgUwqRg8rLss5CoZw7BV
GL3g6PNe13rWcu7rYg27mT81T4cehrl0omnx4FrhDPmnJY4d+yjUiLKujTYaijyZ
8ll4Mr1Ua3M2tTa+79sA8rXAg3zMf+BtTfIcK4avm+csipZ75r9BAgMBAAE=
-----END RSA PUBLIC KEY-----
opt write-history 2005-12-16 18:00:48 (900 s) 81,8848,8927,8927,83,8848,8931,8929,81,8846,8929,8931,81,8848,8929,8927,81,8846,8929,8929,83,8848,8931,8927,9544,23145,118733,12471330,23681225,32974322,36669050,50028191,60119352,43959405,104125876,93764839,67886465,56660787,69614721,49677518,72758978,69080350,68451562,56135957,66072248,44186182,63136414,78723340,84085493,73800911,61322609,54493047,40058835,35991325,33933884,43033805,30004913,31375439,29870384,39901793,24405790,46428634,32855040,31738054,32096150,34571772,47317095,43861120,1725009,2709813,3632379,7206137,4376659,3499688,2148089,2420819,3039400,3271931,2661625,2387027,943794,138137,167325,152659,120259,119828,120342,116812,118734,117279,116769,114764,115673,117709,117201,110668
opt read-history 2005-12-16 18:00:48 (900 s) 20774,489973,510022,511163,20949,490665,509936,510266,20919,490429,512036,508640,20666,485937,506582,505071,20662,484684,507452,506131,20565,485822,505385,505766,28300,499433,627237,12392493,20716078,25654673,25415889,39581836,49991512,31545049,96363762,80390334,60930455,45885095,57137777,42643192,59698768,54573481,58379825,45862920,58781990,33448161,53507694,73363721,70825862,61283831,49325261,44674036,28451429,25009272,22895835,34914097,21103340,19156546,21131703,33036587,18445151,30464430,21857164,27329112,22507170,29536769,37525461,42026081,1778746,3200903,4137862,7712377,4397719,3980947,2650315,2440799,3522111,3774977,3165517,2407670,1427206,644034,672441,173113,609713,630447,632529,136977,611086,629716,629248,135385,607471,627380,625011,131334
opt hibernating 1
reject 169.254.0.0/255.255.0.0:*
reject 127.0.0.0/255.0.0.0:*
reject 192.168.0.0/255.255.0.0:*
reject 10.0.0.0/255.0.0.0:*
reject 172.16.0.0/255.240.0.0:*
accept *:20-22
accept *:53
accept *:79-81
accept *:110
accept *:143
accept *:443
accept *:706
accept *:873
accept *:993
accept *:995
accept *:6660-6669
accept *:8008
accept *:8080
accept *:8888
reject *:*
router-signature
-----BEGIN SIGNATURE-----
mHTlJGu2d2ZZgXfoI0CZBiLMCKbHox2n+Q3OGcivLj0kcYfJ/7/jk4o5ABRgyOHM
zJ7FnC2wSg19MB8jeAvKkxdd1hp0OZQp+tCRq/7p11+6E0qvJcio+RwdeZAb0dQf
suUOPIU/lHzfmraZMO3ovK4VjiWKQ7PgE1vAH7sTyZA=
-----END SIGNATURE-----
stem-1.6.0/test/unit/descriptor/data/hidden_service_duckduckgo 0000664 0001750 0001750 00000006325 13115423200 025333 0 ustar atagar atagar 0000000 0000000 @type hidden-service-descriptor 1.0
rendezvous-service-descriptor y3olqqblqw2gbh6phimfuiroechjjafa
version 2
permanent-key
-----BEGIN RSA PUBLIC KEY-----
MIGJAoGBAJ/SzzgrXPxTlFrKVhXh3buCWv2QfcNgncUpDpKouLn3AtPH5Ocys0jE
aZSKdvaiQ62md2gOwj4x61cFNdi05tdQjS+2thHKEm/KsB9BGLSLBNJYY356bupg
I5gQozM65ENelfxYlysBjJ52xSDBd8C4f/p9umdzaaaCmzXG/nhzAgMBAAE=
-----END RSA PUBLIC KEY-----
secret-id-part e24kgecavwsznj7gpbktqsiwgvngsf4e
publication-time 2015-02-23 20:00:00
protocol-versions 2,3
introduction-points
-----BEGIN MESSAGE-----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-----END MESSAGE-----
signature
-----BEGIN SIGNATURE-----
VKMmsDIUUFOrpqvcQroIZjDZTKxqNs88a4M9Te8cR/ZvS7H2nffv6iQs0tom5X4D
4Dy4iZiy+pwYxdHfaOxmdpgMCRvgPb34MExWr5YemH0QuGtnlp5Wxr8GYaAQVuZX
cZjQLW0juUYCbgIGdxVEBnlEt2rgBSM9+1oR7EAfV1U=
-----END SIGNATURE-----
stem-1.6.0/test/unit/descriptor/data/metrics_vote 0000664 0001750 0001750 00000010020 13115423200 022643 0 ustar atagar atagar 0000000 0000000 @type network-status-vote-3 1.0
network-status-version 3
vote-status vote
consensus-methods 1 2 3 4 5 6 7 8 9 10 11 12
published 2012-07-11 23:50:01
valid-after 2012-07-12 00:00:00
fresh-until 2012-07-12 01:00:00
valid-until 2012-07-12 03:00:00
voting-delay 300 300
client-versions 0.2.2.35,0.2.2.36,0.2.2.37,0.2.3.10-alpha,0.2.3.11-alpha,0.2.3.12-alpha,0.2.3.13-alpha,0.2.3.14-alpha,0.2.3.15-alpha,0.2.3.16-alpha,0.2.3.17-beta,0.2.3.18-rc,0.2.3.19-rc
server-versions 0.2.2.35,0.2.2.36,0.2.2.37,0.2.3.10-alpha,0.2.3.11-alpha,0.2.3.12-alpha,0.2.3.13-alpha,0.2.3.14-alpha,0.2.3.15-alpha,0.2.3.16-alpha,0.2.3.17-beta,0.2.3.18-rc,0.2.3.19-rc
known-flags Authority BadExit Exit Fast Guard HSDir Named Running Stable Unnamed V2Dir Valid
params CircuitPriorityHalflifeMsec=30000 bwauthpid=1
dir-source tor26 14C131DFC5C6F93646BE72FA1401C02A8DF2E8B4 86.59.21.38 86.59.21.38 80 443
contact Peter Palfrader
dir-key-certificate-version 3
fingerprint 14C131DFC5C6F93646BE72FA1401C02A8DF2E8B4
dir-key-published 2012-04-29 21:21:25
dir-key-expires 2013-05-29 21:21:25
dir-identity-key
-----BEGIN RSA PUBLIC KEY-----
MIIBigKCAYEA7cZXvDRxfjDYtr9/9UsQ852+6cmHMr8VVh8GkLwbq3RzqjkULwQ2
R9mFvG4FnqMcMKXi62rYYA3fZL1afhT804cpvyp/D3dPM8QxW88fafFAgIFP4LiD
0JYjnF8cva5qZ0nzlWnMXLb32IXSvsGSE2FRyAV0YN9a6k967LSgCfUnZ+IKMezW
1vhL9YK4QIfsDowgtVsavg63GzGmA7JvZmn77+/J5wKz11vGr7Wttf8XABbH2taX
O9j/KGBOX2OKhoF3mXfZSmUO2dV9NMwtkJ7zD///Ny6sfApWV6kVP4O9TdG3bAsl
+fHCoCKgF/jAAWzh6VckQTOPzQZaH5aMWfXrDlzFWg17MjonI+bBTD2Ex2pHczzJ
bN7coDMRH2SuOXv8wFf27KdUxZ/GcrXSRGzlRLygxqlripUanjVGN2JvrVQVr0kz
pjNjiZl2z8ZyZ5d4zQuBi074JPGgx62xAstP37v1mPw14sIWfLgY16ewYuS5bCxV
lyS28jsPht9VAgMBAAE=
-----END RSA PUBLIC KEY-----
dir-signing-key
-----BEGIN RSA PUBLIC KEY-----
MIGJAoGBANROlyEQEWJ20RC+DogV0Ww8mrUw9viscZ7eqAkyhDZKIt++2kVXszUI
Zd2NoWG025f3np4zlTuIkz2PShn1yAYmKBlRcwbexgR6dXBToL3Zxe1Mezig/UuL
kX75imfneBiLdtCRzaZs/Fa5cwd3msUNPVsq5Zmk0R7rCmBqiLDbAgMBAAE=
-----END RSA PUBLIC KEY-----
dir-key-crosscert
-----BEGIN ID SIGNATURE-----
UuK7wNT0weVelnsMYgoj2apYzr5pJqaI7pM+IzWiSGq1NipqMDEwZqx0WVWR/izB
kLQm1mxU0+84QxAtNNmwNo5uHXR1h2fZJQ2yHf8JLIjIEsaOeOfvDLkn9IyHwmIA
OBPgHmAetivVUYc8lqejBO5l4xg8BpG7KK16yjTDflc=
-----END ID SIGNATURE-----
dir-key-certification
-----BEGIN SIGNATURE-----
t5PLDPgT2TJiM8fNmqXkXY0rK6u5LZEtMNqQ4BCQCrvUN87BPBpF4U0GptqVjmdK
aKS0v6BMRBbSQhyro42jv8iaP8X57V39rJAEbQsWJVNnhBmgLPxY9LYS/he8dUPZ
0LuNjNuBaekvUoPr6iunHGYUjVMZa3aOf+SeUxdS4ZudlozegDyBrkMeEVH/7DC/
dx/VsqR5hIZ8/e+u3XQcSIYCmBbJxPNeOWNERi4npbyY0Iy2AJ1eJyX2onUsk2Qq
jnMxPtuCSDAWEebChwtKTTV6EAnZzYcCZLxNLXcd4Tvfm2EgSw8xKtiDn+eABpcv
7FaKEkuUBGLe+sN3jt3K05qOAOvVtCi0hSO/94+DO7PiXFxmb6Om6vEbKiGxagH2
3jE6rNpJJsO0TspO3KTD7fpXJU7gtXIurcQwziXUGchK84aNFjdX/G1ra5M5kMHf
hJt6p7rCqPyEVOwW+DIGVfucLfjtJu/h7XuWw9/htrE0TNx0Hah8V2+7Ok5XA10N
-----END SIGNATURE-----
r sumkledi ABPSI4nNUNC3hKPkBhyzHozozrU B5n4BiALAF8B5AqafxohyYiuj7E 2012-07-11 04:22:53 178.218.213.229 80 0
s Exit Named Valid
opt v Tor 0.2.2.35
w Bandwidth=51
p accept 80,443
m 8,9,10,11,12 sha256=g1vx9si329muxV3tquWIXXySNOIwRGMeAESKs/v4DWs
r Unnamed AEXri4INxBAZeyi0wvJZoC58nZs csTseFzwBV0RLsEdlyxDw6jTZ1o 2012-07-11 10:47:26 79.139.135.90 443 22
s Fast HSDir Running V2Dir Valid
opt v Tor 0.2.2.37
w Bandwidth=92
p reject 1-65535
m 8,9,10,11,12 sha256=iZfmvEGdBG/qc9KYZUh4JsWEHbn9Bw2jy5i0AtCoRB0
r default AFU4pMWKyq+eTPuBO0D9W179kQQ OZzEaq9N5+VX5yxzi051zqyEcPk 2012-07-11 08:17:21 2.90.115.167 443 9030
s V2Dir Valid
opt v Tor 0.2.3.15-alpha
w Bandwidth=53
p reject 1-65535
m 8,9,10,11,12 sha256=m/RouK3TqoaYBBHCxgmzMPuGGCIEr0ufSTB1i85zicM
r satoshi11 AFzRyEo3Ibdko7vl4rReoU3BDfM rWaYhhU9Kym4sXAVe+uE99VGpJs 2012-07-11 08:10:01 80.218.153.44 443 9030
s V2Dir Valid
opt v Tor 0.2.2.35
w Bandwidth=196
p reject 1-65535
m 8,9,10,11,12 sha256=yxuOPz7IraIzzmU/qeZRJHOJrutNmvPwDwj2AmsHZSI
directory-footer
directory-signature 14C131DFC5C6F93646BE72FA1401C02A8DF2E8B4 BF112F1C6D5543CFD0A32215ACABD4197B5279AD
-----BEGIN SIGNATURE-----
02UCTf06pLYkuLgUSR+L0vHOJ7gUyidKscg88q8TWUAiP57x27o+BlZdEMSu/ArT
yBOz+0ZOWggb04maA2cwJQQEK2LkzxzBijmfoC6RhQx3wS8llhyOMaoR6rkobE1D
oLqVZPDNPX87DkhmQfgBM2I3vYQX13YJwZc0jNCEGpU=
-----END SIGNATURE-----
stem-1.6.0/test/unit/descriptor/data/non-ascii_descriptor 0000664 0001750 0001750 00000002300 13115423200 024260 0 ustar atagar atagar 0000000 0000000 @type server-descriptor 1.0
router Coruscant 88.182.161.122 9001 0 9030
platform Tor 0.2.3.25 on Linux
opt protocols Link 1 2 Circuit 1
published 2013-05-18 11:16:19
opt fingerprint 0B98 2154 5C48 E496 AEED 9ECC 0DB5 06C4 9FF8 158D
uptime 259738
bandwidth 102400 204800 122818
opt extra-info-digest 56403D838DE152421CD401B8E57DAD4483A3D56B
onion-key
-----BEGIN RSA PUBLIC KEY-----
MIGJAoGBAK+rjPilZJVzvWn6slOpak4eUab+VXiGNkRAIKgGAqbpex7lNMcZeXbu
8uYhiDUdjRaHQUbBjLaj6nAjtlHUl3NCbIpo2p03KEcxfAGi3k6dUMBJ7aIYb8lL
SDK95huLBpyyNPikeDIiTKS1HNtmrai/iVtUiJS2I4fs3lP1TxevAgMBAAE=
-----END RSA PUBLIC KEY-----
signing-key
-----BEGIN RSA PUBLIC KEY-----
MIGJAoGBANGDDMHoCtTeL4UTEGip4T+37jd4lEjBgla7lgL8W1gtVTX/uMMo+HGE
m1sD/FgBI3w8w7zpZlJgYeB/94YPUrw11iAEYAooJVmGDmel2g6CFofDs7KmrzqR
1FQDIWeY9sQd4+L+jWMquqcA3FyzuZz28gi56hIombjkfr0RwCsNAgMBAAE=
-----END RSA PUBLIC KEY-----
opt hidden-service-dir
contact 1024D/04D2E818 Lénaïc Huard
reject *:*
router-signature
-----BEGIN SIGNATURE-----
hk4jKRtI0LbjYWdGhjTuev9Hk9AilyBmBtK9nfpBPyamQZDZVirEUuP7PdtxM2U9
EdCg+KnkrLoKoxh18YumBD2HvwHa2J1VZtezWkwxGB+HPkECTU/byl+dn6ZRncY7
r0IrVeGUnlK/UaWpswx6amH7FEKXmBZYHxTxyuwwybQ=
-----END SIGNATURE-----
stem-1.6.0/test/unit/descriptor/data/cached-microdescs 0000664 0001750 0001750 00000002014 13115423200 023504 0 ustar atagar atagar 0000000 0000000 @last-listed 2013-02-24 00:18:36
onion-key
-----BEGIN RSA PUBLIC KEY-----
MIGJAoGBAMhPQtZPaxP3ukybV5LfofKQr20/ljpRk0e9IlGWWMSTkfVvBcHsa6IM
H2KE6s4uuPHp7FqhakXAzJbODobnPHY8l1E4efyrqMQZXEQk2IMhgSNtG6YqUrVF
CxdSKSSy0mmcBe2TOyQsahlGZ9Pudxfnrey7KcfqnArEOqNH09RpAgMBAAE=
-----END RSA PUBLIC KEY-----
@last-listed 2013-02-24 00:18:37
onion-key
-----BEGIN RSA PUBLIC KEY-----
MIGJAoGBALCOxZdpMI2WO496njSQ2M7b4IgAGATqpJmH3So7lXOa25sK6o7JipgP
qQE83K/t/xsMIpxQ/hHkft3G78HkeXXFc9lVUzH0HmHwYEu0M+PMVULSkG36MfEl
7WeSZzaG+Tlnh9OySAzVyTsv1ZJsTQFHH9V8wuM0GOMo9X8DFC+NAgMBAAE=
-----END RSA PUBLIC KEY-----
ntor-onion-key r5572HzD+PMPBbXlZwBhsm6YEbxnYgis8vhZ1jmdI2k=
family $6141629FA0D15A6AEAEF3A1BEB76E64C767B3174
@last-listed 2013-02-24 00:18:36
onion-key
-----BEGIN RSA PUBLIC KEY-----
MIGJAoGBAOWFQHxO+5kGuhwPUX5jB7wJCrTbSU0fZwolNV1t9UaDdjGDvIjIhdit
y2sMbyd9K8lbQO7x9rQjNst5ZicuaSOs854XQddSjm++vMdjYbOcVMqnKGSztvpd
w/1LVWFfhcBnsGi4JMGbmP+KUZG9A8kI9deSyJhfi35jA7UepiHHAgMBAAE=
-----END RSA PUBLIC KEY-----
a [2001:6b0:7:125::242]:9001
p accept 80,443
stem-1.6.0/test/unit/descriptor/data/descriptor_archive.tar.bz2 0000664 0001750 0001750 00000006430 13115423200 025312 0 ustar atagar atagar 0000000 0000000 BZh91AY&SY”öšò Ø…è d{ÿòÿÿðÿÿÿð €` Žš •"¶vî3M6„jˆÄÐÉ£ÔÈÄÓF‘´hÁL4dÊ( 5Iê6¢m1OF†O@˜É“DbzM#@ dÄÐdÉ„Ó d4€Ó&† MŠõSjž žSA¦LO4=M¨=M00ƒÇdÄÐdÉ„Ó d4€Ó&† M†Õ ÐÔÂi¦ 4ÓГÔÚ
yO&¦'¡ ²KÍ~‘Ü,Frˆ?òL‘Ii"4ŽIi\d¹HÔ’Ò@NŠ&9·$×µñ$£AzI‰Î“’XoôÆ%û»óáÙ¾Tef:Œ…æBÄr ˆF£)à DF4˜`ä0”xÔ8Œˆañ£É† HA @kûR{ê1}#o¯×ëšê,ªYŽ OöˆþLhJ!„Ç%óÿÒ\I,i,Ed§yì;ÉÖåK•¢@•±§¬ø¢ø"~Ä‘$cXÆ0û/Üa ª¡]fxﾄªÎÛ ©…Äðué6¶ÊêhlÒ$m?qÉ ˆ°I‡ 0ü fñãÌ Ñ”Ôd=É!¢@•{x?‰¿ï߇^üý^|òþsíáÝüøäýä»g‚@Žã؆0ba"å9ÑAÐi& @ã8Îã HüœG!æs Ž²¤NXv5!£
†!¨ngÉRObNzbÎÁ*;å”òÅýú¯ûmòŸ_† ¢Ó.ž’rI`\4à 0j3aô )F/ăˆˆ|$ÄÁ()IF²R18œ˜ù—þ÷[’DÊD’¸bd§Û¡_I ¬Ž+”f(ŸƒLƒæW—¢‘ž¡Óž.#‰0•+Oæd†££‘[_êò#´Åaö+%¶ÊLMçîŠn®}±õô5†nW _¸¼XFŠÖcy*תø çÃ>« â"Ü’i2„㈠'$¬¯\#`ĺ‘uNyYÝˤiQR/LDN’Lµ%2P*)u餤„D74ÙKÏ+VÒñ…+!XâJS7[V/|™Gm÷Ûϯú¿e4Wf!•™H4‘šQjœÒND“Ž¡ƒ † a^s-Pœ° aªÂqÆ*ƨ±G§RJH†¢uüãEdi夤¥†xÏ9§£_׳Ê|uÕ½z6M±ÍAÄœ4œq!7®†ÄêF5‰5aœÌFQÏ„íPZ‡g"Ssá\„jG±H¥µ´‚ñ œl)Ç Pä
0hVdŒÇ‚SÝ>,qx冂ڷ_7Æ»¸ ÁÄyL
ŒŸ¤ð8†NßsHN>}zSŠˆÍ#EªB&8”€ò5²B2¤Ë!8åÀk”šáÕ ô¯ÙLGJ;GÜzà†²eh«"õTŽ|dl#.ß›WPôHá ër›ˆšäæüÌŸ¶]Q¨zsmýOu lnŒøEZIi#Æl•&l4’¸®QŠ¦'ž¢¢†F6RªQVçFôðÅ…»Xµ5PXô²Ž/$šG³Äˆµ1&”§ Œ&ÔŽJÈËË \ÔRŽe÷ÑÃB<û‘ƒ¾ýqûw÷ðwsôûì¢ó7Š7ôa‚P-8Gš
f³WqKœ@Ü?jÅ)|éÅcä¤y»µ ˆ›ÏûåÅ…T4oî%QˆÇБóÃ_»fŸ¯.îÿÄlI[½"[ÊÉ6.#¬d¾L'Xó cç"#a¢FÒJf xÛï›wäâýµY9…‰4¨"—ëeô ç˜4#.NŒ/x¦;<9&J¾:ŒE\ð J>6QÛ–hîõyîç¿·éÕ†þMÓ÷çj1é]& OrŸã¨Î2Sã9Å yÔk5¡Î%:Æ‘ÜѲ÷ÛôÚZLN%ðË«x–úýž]É }<{@ë½´[²¤Î¹d!ÊW@€ox`a ŽQJ N [²‹08z…9E‚Á%öß k‹r_—šÍ4÷}æÛ=Öyüêh† ¦ÁH‡u© 7ì܇X›£íÆünBì©1±C¡kÇ4ÜHnÔ_SãåéØë&àOäB ð9á "Ʊ\Ñ¡ù«š3 ‡~vö>÷3䑲:õÈé4oŸWïRD)ï·Tß ãeL™ªŸÂùiLÅ0!T,‚ú´áߥ¢t½ix¨Æ}YýQ.ëÐpZ§ÓÓÜjH)Bd ®î™_~É×±MP0•‰M”7V)˜†Hëç_J5«… ›|üS§~R í»®ÅÆ––ßyÛ{.ö¸¤r»ºc»wÚ^· ¥¼ >ØYcÈoï³Qæ“Ãlª{JѳØÁâ±Þ¨ÛsðµæzÐ¥ï:yžÒ©OM±ÜØB*Û>æû8*æFu}ó·1Áå°áL‚!§žêaé;Kò<ü
vÆ)ª ü[i¬Í™w¹a?då*N¹‰fy°z»>ô(ãí#üùï↶å<
GDZzw~¸–ŽŒA•´&Ñ'DyãtôøLþîû|µ•Êí]^²XÍt—‡óõ½›fOÃve–ð,"+H‹äM#«V>ÖS®Fç‚¢ ™GØéGZÅ(‘S² »²o;9xÒJd—Ý%Æ’ü¤¬+:½ÇÎþºóù䓯mój:”ZúQö&6ÁÌTßͯ_…ï"¯‚¦Óeǯ8äç©j€°éê@„ªfT–ùx¢0Kä D‘I)±Äžk«}|Ô E»¸»ØhÌ%ˆP>ÉOøòΊބ‘ 3Œ Øqh`XÐÀDX²áÒJií«wj³]Bíµi‚± ½v›ošˆ]Ä,@„»ÊÆ;N¤kŒQæQ/©¥Ó5[N.'ˆæ8éáESåO¥×ÃE x ;ñNaG„ÜÐ ŽÅ¯Œ:ï{œAܱgÑòµd*“•:ˆ® ˆcÿ
Èn`ÇLµ'c£•ÿ£Ø¤š+]•û8 # =,ó…¥q„„y§ëRáVEOUب‰Ã|¤Hïó8F '‘¸´Ølí<òp*Äâ¢/‡ /£-
¨ù–O³’U
¹ÃhÆ+7¶î†•f \ ¨8N!5ÍkK~lÒÞÜâØRü:°P&NWà ñZ‡Ï—]Ý#j¿ ®'öû¹gGoéñ¿l=¹¹ ûô=(Ì= nÁ涤jŒ¡q ><â\ðÃk¤Ž¹{fÈéÝì÷>½½\ßèï·RåhI¢œaáa @ˆÄB°Ð|‰ú\< Ì´.(æ»ý6sG—ÏÕ{KnA©,HÊZѨóÏÝðòãíÙ|É,üjIVf.IvvÎ%óy:c*‡3‘
½ f97é4Yðkëö‘ÄÀ(…¡=zPD° „‚ÄE²qDe (“ F!+©cǤ8y‹‚2WËWbéØ·øXr¤•©.L¨qð/6Ì4Ö1%onŽƒ7|ã2Ÿá׿Ã}Óye~Cï.=žUYœ_óÉžqDŠŠBÿˆŠ%žÎ¾±ŽL*É›E/é"/„Èñ÷)bVàÛ;ëì ›+ƒ „ݱof·ÓŒâ,úcÅ®»œ¬³&g;p^aìjd£p¼‘ hFë%§ä*›› ¦ØÌb¤èXéË’Ís3XÏ'Xº+ù9e}
ú _ñw$S… Oi¯ stem-1.6.0/test/unit/descriptor/data/negative_uptime 0000664 0001750 0001750 00000006156 13115423200 023344 0 ustar atagar atagar 0000000 0000000 @type server-descriptor 1.0
router TipTor 62.99.247.83 9001 0 9030
platform Tor 0.1.1.25 on Darwin Power Macintosh
published 2006-12-18 22:42:40
opt fingerprint 1379 62D4 931D BF08 A24E 8432 88B8 A155 D6D2 AEDD
uptime -31081285
bandwidth 102400 153600 124131
onion-key
-----BEGIN RSA PUBLIC KEY-----
MIGJAoGBAOAG0OI7xLpz3gAkJoJdRzKYOvOZ7PL5dQQZJGw+pXVUnXfchwTXLm5o
rAoYolziFjUU+EDaDXCHq1MrQBNbT1kQHqv+OcVjTwuameNVOCgPTIDOxiXfxxoO
zDAEQ91gzcDIBZdV9V64KV8Oz4+NYK3zrGDkIg00pAQjNuwvmZqlAgMBAAE=
-----END RSA PUBLIC KEY-----
signing-key
-----BEGIN RSA PUBLIC KEY-----
MIGJAoGBAKjCkU3eAwbW9ZU42B1l+Itqy4yKoQpRjt6N42mfNFfKZ8Ywd789/jiK
J31QYBhW3JBn1ZFkRwpfKYlbOm0XS2CjlqHuT0Ycp9iphtCIHADIM+3shaSKAIwA
8/wQ2GN9zYiTneUNWRJN5sDja+oU7XfkRI46cpV1Y1lVJyEoKQWpAgMBAAE=
-----END RSA PUBLIC KEY-----
opt write-history 2006-12-18 22:36:20 (900 s) 85896196,91917257,89966503,91506428,91213104,88921400,91039183,91716023,91147326,86173405,88624130,87211145,90976203,91765274,91904016,92475836,91436900,91811938,86244782,91228827,91939844,89829330,89107239,89019495,88925780,91247327,90406742,91088221,91065780,91770795,91408136,89981571,88663478,91555300,91664187,91916304,92079918,87826691,87836934,91162457,91904383,91508890,90270067,91314943,91856008,84648838,86133485,81010341,78078954,85039584,91951911,91327645,92042781,87120087,76812012,87759151,91627062,91881873,91965911,91523086,86332304,86299595,90915708,89321373,91093137,91654532,91836129,91819440,92049427,92014514,89481483,91098381,88852717,91601581,89729803,91256453,89604862,91881660,91942891,91769572,91896895,92224718,91431715,91762404,91709273,92046002,91866341,91561459,91673622,91700186,91659511,92402879,90926431,87060230,91076389,89573325
opt read-history 2006-12-18 22:36:20 (900 s) 69091643,77959428,74322746,75132861,74637737,68249949,73224421,72744339,73893094,69049631,71480325,68334060,72775510,79560093,78273066,75799097,76810596,78186192,67593073,75998559,77654399,70612520,74383546,74734217,74966593,75402221,80000519,80112418,79005070,80831698,76082779,73232671,71056247,75135941,71903141,78060009,79742551,70250313,66205769,78319432,73988994,74372922,71546410,73545171,74220510,63051559,66646384,68538308,59360208,63812166,75673274,72347320,76357687,66600939,56487705,70648976,70968064,74698003,75944759,74122368,67485399,63305556,68515366,71145401,69625041,68993028,71537081,75025172,75155755,70871549,69489568,74027234,72162369,74396503,76005043,72708060,70567406,73291632,75536033,73865170,69322880,73918987,72020474,76681275,76604577,77208720,75252120,75305805,76861569,77278013,77057424,76937746,72642470,65754315,70138397,73236479
contact rbr@tip-informatik.at
reject 0.0.0.0/8:*
reject 169.254.0.0/16:*
reject 127.0.0.0/8:*
reject 192.168.0.0/16:*
reject 10.0.0.0/8:*
reject 172.16.0.0/12:*
reject *:25
reject *:119
reject *:135-139
reject *:445
reject *:465
reject *:587
reject *:1214
reject *:4661-4666
reject *:6346-6429
reject *:6699
reject *:6881-6999
accept *:*
router-signature
-----BEGIN SIGNATURE-----
XAy56NzQm+LGMnaxBZC0ulmyZxoTNTFxZN0834V/hrfBdEOwMuBZMSsS613OfRK1
3K/StL29NdLChHt71XCPyxsnbzguBE0Pma6cX4aSNa1WJO4wpc1WipmWdmuVKXHD
RoxIVSJU3qwfjzSbwJiNSLPs4mmQFecsVmG94cZSITY=
-----END SIGNATURE-----
stem-1.6.0/test/unit/descriptor/data/cr_in_contact_line 0000664 0001750 0001750 00000010326 13115423200 023765 0 ustar atagar atagar 0000000 0000000 @type server-descriptor 1.0
router pogonip 75.5.248.48 9001 0 0
platform Tor 0.1.2.17 on Darwin i386
published 2007-09-03 10:15:53
opt fingerprint 6DAB D62B C65D 4E6F E620 2931 57FC 7696 8DAB 9C9B
uptime 5423
bandwidth 98304 196608 0
onion-key
-----BEGIN RSA PUBLIC KEY-----
MIGJAoGBAO6pORBI9rGRCPSb2lLwzl2630eFMlBXLgLtwQvYLY2s58cWpKjhI+ZF
Q43+0e50pgC//JyS3Zac4O7MA5+BUfMvNOzKUdSIIGc6QjwST/larbDy14k9XalQ
+G8rdnKb7gDNLrHjxhw5tC0JSTSTXI08bNsFeN1MoY8sFBjRlyDxAgMBAAE=
-----END RSA PUBLIC KEY-----
signing-key
-----BEGIN RSA PUBLIC KEY-----
MIGJAoGBALL0zokdBKjVcZA1P0K2jWK7afkvmB2bpRAdx5x1KRPZtB0mRxyjvgwL
Tp0z3jLwhB4gzYY4LmS8p5RBH53gv4GsNW1rPSr99q4wjWyEY5AfjOdJZtFo/nhP
881leOraicfcXmqrgtfbXZ0Jj+G9Ko216yEv4vBN/UV87kZHb/4tAgMBAAE=
-----END RSA PUBLIC KEY-----
opt write-history 2007-09-03 10:01:27 (900 s) 471040,874496,354304,0,0,0,0,0,0,0,0,60416,1160192,2017280,3396608,1585152,5990400,5469184,10896384,20568064,23362560,43372544,36531200,43439104,47890432,54303744,38624256,40414208,26827776,0,0,0,0,50176,611328,3126272,2952192,33792,28672
opt read-history 2007-09-03 10:01:27 (900 s) 6890496,2631680,2260992,0,0,0,0,0,0,0,0,1096704,1856512,1133568,1038336,1390592,3272704,2115584,6868992,13585408,13746176,30726144,25562112,28556288,36113408,35810304,25213952,30357504,13510656,0,0,0,0,964608,568320,966656,1991680,17408,140288
opt hibernating 1
contact jie1 at pacbell dot net -----BEGIN PGP PUBLIC KEY BLOCK-----
Version: GnuPG v1 dot 4 dot 7 (Darwin)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=Xaw3
-----END PGP PUBLIC KEY BLOCK-----
reject 0.0.0.0/8:*
reject 169.254.0.0/16:*
reject 127.0.0.0/8:*
reject 192.168.0.0/16:*
reject 10.0.0.0/8:*
reject 172.16.0.0/12:*
reject *:25
reject *:119
reject *:135-139
reject *:445
reject *:465
reject *:563
reject *:587
reject *:1214
reject *:4661-4666
reject *:6346-6429
reject *:6699
reject *:6881-6999
accept *:*
router-signature
-----BEGIN SIGNATURE-----
PrL8cocQcTTmQp0wy0dxlFOczGv8s2/hZzAafOhjdM0QqLMLh9FW/4RqH0jcDz+P
t1QU3xIF3JV1fsW0rx4vFYKXG7WrLrrQp3gGuJvrXO+132UAsrs7eJKk3yxEi2lq
FNY26XGZqTDPY4WPl08/JgXXfckgFFg76E4Jcl5/tY8=
-----END SIGNATURE-----
stem-1.6.0/test/unit/descriptor/data/bridge_network_status 0000664 0001750 0001750 00000001322 13115423200 024555 0 ustar atagar atagar 0000000 0000000 @type bridge-network-status 1.0
published 2012-06-01 04:07:04
r Unnamed ABSiBVJ42z6w5Z6nAXQUFq8YVVg FI74aFuNJZZQrgln0f+OaocMd0M 2012-05-31 15:57:00 10.97.236.247 443 0
s Valid
w Bandwidth=55
p reject 1-65535
r TolFuin AFn9TveYjdtZEsgh7QsWp3qC5kU 1Sw8RPx2Tq/w+VHL+pZipiJUG5k 2012-05-31 18:12:39 10.99.47.37 80 0
s Fast Guard Running Stable Valid
w Bandwidth=32
p reject 1-65535
r sidvic AGzeXR+V8NSBE3wTE4m7gBYbjWM 7enyDQ20UjliwCPN2JmTl6zrCdM 2012-05-31 22:56:12 10.145.17.182 80 0
s Fast Guard Running Stable Valid
w Bandwidth=56
p reject 1-65535
r AntoniusBlock ANk5reA3WwTV62ZpyMo+NWtrvAw gEgv8I1E4LWrs394Xx/cRYQUL5A 2012-05-31 17:21:20 10.95.68.0 443 0
s Fast Guard Running Stable Valid
w Bandwidth=55
p reject 1-65535
stem-1.6.0/test/unit/descriptor/data/example_descriptor 0000664 0001750 0001750 00000002754 13115423200 024050 0 ustar atagar atagar 0000000 0000000 @type server-descriptor 1.0
router caerSidi 71.35.133.197 9001 0 0
platform Tor 0.2.1.30 on Linux x86_64
opt protocols Link 1 2 Circuit 1
published 2012-03-01 17:15:27
opt fingerprint A756 9A83 B570 6AB1 B1A9 CB52 EFF7 D2D3 2E45 53EB
uptime 588217
bandwidth 153600 256000 104590
opt extra-info-digest D225B728768D7EA4B5587C13A7A9D22EBBEE6E66
onion-key
-----BEGIN RSA PUBLIC KEY-----
MIGJAoGBAJv5IIWQ+WDWYUdyA/0L8qbIkEVH/cwryZWoIaPAzINfrw1WfNZGtBmg
skFtXhOHHqTRN4GPPrZsAIUOQGzQtGb66IQgT4tO/pj+P6QmSCCdTfhvGfgTCsC+
WPi4Fl2qryzTb3QO5r5x7T8OsG2IBUET1bLQzmtbC560SYR49IvVAgMBAAE=
-----END RSA PUBLIC KEY-----
signing-key
-----BEGIN RSA PUBLIC KEY-----
MIGJAoGBAKwvOXyztVKnuYvpTKt+nS3XIKeO8dVungi8qGoeS+6gkR6lDtGfBTjd
uE9UIkdAl9zi8/1Ic2wsUNHE9jiS0VgeupITGZY8YOyMJJ/xtV1cqgiWhq1dUYaq
51TOtUogtAPgXPh4J+V8HbFFIcCzIh3qCO/xXo+DSHhv7SSif1VpAgMBAAE=
-----END RSA PUBLIC KEY-----
family $0CE3CFB1E9CC47B63EA8869813BF6FAB7D4540C1 $1FD187E8F69A9B74C9202DC16A25B9E7744AB9F6 $74FB5EFA6A46DE4060431D515DC9A790E6AD9A7C $77001D8DA9BF445B0F81AA427A675F570D222E6A $B6D83EC2D9E18B0A7A33428F8CFA9C536769E209 $D2F37F46182C23AB747787FD657E680B34EAF892 $E0BD57A11F00041A9789577C53A1B784473669E4 $E5E3E9A472EAF7BE9682B86E92305DB4C71048EF
opt hidden-service-dir
contact www.atagar.com/contact
reject *:*
router-signature
-----BEGIN SIGNATURE-----
dskLSPz8beUW7bzwDjR6EVNGpyoZde83Ejvau+5F2c6cGnlu91fiZN3suE88iE6e
758b9ldq5eh5mapb8vuuV3uO+0Xsud7IEOqfxdkmk0GKnUX8ouru7DSIUzUL0zqq
Qlx9HNCqCY877ztFRC624ja2ql6A2hBcuoYMbkHjcQ4=
-----END SIGNATURE-----
stem-1.6.0/test/unit/descriptor/data/hidden_service_facebook 0000664 0001750 0001750 00000006331 13115423200 024756 0 ustar atagar atagar 0000000 0000000 @type hidden-service-descriptor 1.0
rendezvous-service-descriptor utjk4arxqg6s6zzo7n6cjnq6ot34udhr
version 2
permanent-key
-----BEGIN RSA PUBLIC KEY-----
MIGKAoGBAL7zXRnwSycHlKSqK+B8PFvy7RhkQ+OytYtxBwOLzhD82oY7zbpjSHY4
BZ+hsnceXVjB+f1mXGjvLY6pnYxuufV4wsMsk7a58aJOqUvZFFI2vXhJtnLICxoZ
AEHWzajz4ULagahB1Vi62loQE84OEcuFBekTvnHca1ZTxwp16aZtAgQvoiLZ
-----END RSA PUBLIC KEY-----
secret-id-part 6355jaerje3bqozopwq2qmpf4iviizdn
publication-time 2014-10-31 23:00:00
protocol-versions 2,3
introduction-points
-----BEGIN MESSAGE-----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-----END MESSAGE-----
signature
-----BEGIN SIGNATURE-----
tFCNLEOFeqeDZOruKt4SBGvJ2Y2lLo29XUzd09FlIalnwb71TKcKSWi1JVB0vDqF
ftGlP4M+nZGh6YGxdEriV0ikFbcW+F4XOpWR5NEPV5cCoQAMd1a8mqivGjM/lQwe
41p+e4XCex2Brsl3o+pSyHy/U+p+xdQkmNPqrHpXVK8=
-----END SIGNATURE-----
stem-1.6.0/test/unit/descriptor/data/extrainfo_bridge_descriptor 0000664 0001750 0001750 00000007077 13115423200 025733 0 ustar atagar atagar 0000000 0000000 @type bridge-extra-info 1.0
extra-info ec2bridgereaac65a3 1EC248422B57D9C0BD751892FE787585407479A4
published 2012-06-08 02:21:27
write-history 2012-06-08 02:10:38 (900 s) 343040,991232,5649408,49548288,24411136,486400,465920,975872,930816,758784,5650432,1844224,4387840,7417856,789504,623616,7376896,3940352,10039296,6054912,2051072,462848,4260864,5298176,500736,717824,714752,1370112,760832,576512,1521664,3986432,724992,615424,7079936,20995072,17465344,2592768,1014784,3082240,11468800,2770944,5660672,7646208,3385344,5404672,1158144,7741440,3275776,5239808,5291008,2197504,6070272,4919296,1180672,2245632,2362368,1641472,6153216,4660224,9184256,1488896,9736192,768000,65536,176128,2268160,3023872,704512,905216,866304,2375680,3688448,5181440,5433344,5259264,8285184,9391104,7015424,7180288,3436544,3713024,4473856,10705920,10529792,3154944,1815552,3443712,4566016,2668544,2688000,2391040,3181568,2749440,3214336,8974336
read-history 2012-06-08 02:10:38 (900 s) 337920,437248,3995648,48726016,24125440,479232,477184,1010688,988160,772096,6388736,776192,3093504,7187456,787456,657408,7360512,3588096,9319424,5211136,2034688,474112,4222976,5154816,490496,1878016,610304,757760,667648,593920,1484800,3638272,1307648,672768,6614016,19262464,14863360,2612224,525312,1494016,11119616,3160064,1986560,5619712,3290112,5457920,1145856,7060480,3262464,5570560,5933056,2245632,4548608,3614720,829440,1765376,2379776,2531328,4306944,4244480,9225216,1054720,9806848,880640,66560,192512,2135040,3038208,830464,804864,941056,2386944,3660800,4835328,6406144,5152768,8714240,9145344,6902784,6781952,3648512,3876864,5474304,9958400,10851328,3322880,2239488,4790272,4343808,2404352,2615296,1551360,3295232,2869248,2924544,4941824
dirreq-write-history 2012-06-08 02:10:38 (900 s) 5120,664576,2419712,578560,3072,5120,5120,3072,11264,5120,54272,1130496,1381376,202752,47104,0,6144,1064960,716800,835584,2048,0,3072,128000,4096,1024,222208,604160,129024,7168,118784,353280,0,0,761856,2236416,2574336,3072,526336,2037760,214016,726016,3592192,2205696,134144,1024,86016,656384,8192,9216,402432,14336,1617920,1436672,445440,481280,7168,1024,1959936,442368,14336,544768,4096,1024,0,4096,1052672,78848,0,223232,51200,5120,5120,1191936,1024,579584,2048,231424,68608,1305600,38912,4096,8192,1433600,5120,4096,330752,574464,382976,225280,940032,1185792,6144,1024,374784,4173824
dirreq-read-history 2012-06-08 02:10:38 (900 s) 0,71680,99328,25600,0,0,0,0,0,0,3072,45056,74752,13312,2048,0,0,69632,18432,39936,0,0,0,8192,0,0,16384,25600,9216,0,7168,8192,0,0,96256,92160,138240,0,18432,128000,0,81920,149504,113664,8192,0,11264,46080,2048,0,25600,0,75776,77824,0,6144,19456,0,58368,14336,0,21504,0,0,0,0,25600,6144,0,0,5120,4096,0,54272,0,23552,0,0,4096,64512,2048,0,0,34816,0,0,6144,8192,10240,0,31744,48128,0,0,10240,236544
geoip-db-digest A27BE984989AB31C50D0861C7106B17A7EEC3756
dirreq-stats-end 2012-06-07 06:33:46 (86400 s)
dirreq-v3-ips
dirreq-v2-ips
dirreq-v3-reqs
dirreq-v2-reqs
dirreq-v3-resp ok=72,not-enough-sigs=0,unavailable=0,not-found=0,not-modified=0,busy=0
dirreq-v2-resp ok=0,unavailable=0,not-found=0,not-modified=0,busy=0
dirreq-v3-direct-dl complete=0,timeout=0,running=0
dirreq-v2-direct-dl complete=0,timeout=0,running=0
dirreq-v3-tunneled-dl complete=68,timeout=4,running=0,min=2626,d1=7795,d2=14369,q1=18695,d3=29117,d4=52562,md=70626,d6=102271,d7=164175,q3=181522,d8=271682,d9=563791,max=32136142
dirreq-v2-tunneled-dl complete=0,timeout=0,running=0
bridge-stats-end 2012-06-07 06:33:53 (86400 s)
bridge-ips cn=16,ir=16,sy=16,us=16,??=8,bn=8,br=8,by=8,cu=8,dk=8,dz=8,es=8,lb=8,ph=8,sd=8,tw=8
router-digest 00A2AECCEAD3FEE033CFE29893387143146728EC
stem-1.6.0/test/unit/descriptor/data/hidden_service_basic_auth 0000664 0001750 0001750 00000007244 13115423200 025313 0 ustar atagar atagar 0000000 0000000 @type hidden-service-descriptor 1.0
rendezvous-service-descriptor yfmvdrkdbyquyqk5vygyeylgj2qmrvrd
version 2
permanent-key
-----BEGIN RSA PUBLIC KEY-----
MIGJAoGBANHC3bZRrlFFlSu22u18wBG57JpvIhglJE+u0ctMwTnw6iyJJqqxgU6U
R1gnXJlorQYDC5eHoM8nbBJu7LvUjYnqINz+En+FlpZhT+eqLk0v83IB4r0Fd6Bg
ypYLygEXUfh0bwHwYfF4mkvl6YOB6I6G5jHC46I3LH15qrdHW40FAgMBAAE=
-----END RSA PUBLIC KEY-----
secret-id-part fluw7z3s5cghuuirq3imh5jjj5ljips6
publication-time 2015-02-24 20:00:00
protocol-versions 2,3
introduction-points
-----BEGIN MESSAGE-----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-----END MESSAGE-----
signature
-----BEGIN SIGNATURE-----
mhGQNtyvf5QqeFrn1SNzdp8wN5bhEH5gxZhST5t4pFxxNCv3//ZgaQ83kIzcwex9
xzgGREFHpTrqVPXXs8nZZgMpmnhWuloAyT1c3HSCvjnbWXX9Y82wPbVV5OYx1CYb
jLides7vbdQuS0UwEkcGMl62Ripwi0pkesgw9ZvJy+k=
-----END SIGNATURE-----
stem-1.6.0/test/unit/descriptor/data/extrainfo_bridge_descriptor_multiple 0000664 0001750 0001750 00000011363 13115423200 027637 0 ustar atagar atagar 0000000 0000000 @type bridge-extra-info 1.2
extra-info default 909B07DB17E21D263C55794AB815BF1DB195FDD9
published 2015-03-20 10:49:48
router-digest 560269C81DEC146D94399FF5E95505A6DE591F3C
@type bridge-extra-info 1.2
extra-info AndreasBaader 7F7798A3CBB0F643B1CFCE3FD4F2B7C553764498
published 2015-03-20 10:52:01
write-history 2015-03-20 10:37:14 (900 s) 7168,24576,89088,14336,9216,9216,215040,62464,5120,10240,4096,10240,7168,45056,79872,7317504,566272,3484672,1227776,19456,92160,9216,11264,176128,17408,58368,46080,7168,10240,15360,8192,17408,115712,8268800,5313536,4535296,4857856,4766720,2446336,4061184,17056768,12321792,9737216,4689920,41984,128000,10240,9216,75776,3697664,8046592,3249152,3329024,15947776,30720,5165056,11705344,10077184,2409472,1417216,944128,3110912,558080,14336,9216,63488,10240,70656,15360,72704,14336,6144,11264,8192,225280,40960,15360,8192,13312,7168,44032,11264,7168,94208,10240,5120,21504,38912,39936,71680,11264,5120,49152,15360,114688,17408
read-history 2015-03-20 10:37:14 (900 s) 8192,26624,896000,26624,12288,12288,2320384,107520,4096,12288,5120,11264,6144,644096,907264,7287808,723968,3475456,1826816,17408,914432,14336,13312,2001920,54272,663552,657408,9216,17408,24576,15360,19456,966656,8250368,5293056,4518912,6098944,5287936,2457600,4047872,17041408,12282880,9706496,4666368,683008,1456128,19456,10240,1010688,3686400,8024064,3246080,5412864,15894528,31744,5157888,12541952,11269120,2410496,1417216,947200,3341312,557056,11264,9216,874496,12288,1241088,16384,935936,13312,6144,11264,11264,2270208,279552,26624,12288,21504,8192,628736,13312,10240,1213440,8192,7168,21504,626688,635904,905216,8192,8192,649216,18432,1274880,40960
dirreq-write-history 2015-03-20 01:52:14 (900 s) 1024,0,0,0,0,0,0,0,0,0,0,0,20480,2048,0,2048,1024,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,29696,2048,5120,2048,0,0,0,0,0,0,0,0,0,0,0,0,0,1024,1024,4096,0,0,613376,1024,0,0,0,1024,0,0,0,0,0,0,7168,2048,0,1024,2048,0,0,21504,4096,2048,0,3072
dirreq-read-history 2015-03-20 01:52:14 (900 s) 0,0,0,0,0,0,0,0,0,0,0,0,2048,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4096,0,2048,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4096,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,3072,0,0,0,0
geoip-db-digest 9EF0A1874377BFB6413ED3F9EB5504B1DB17BE13
geoip6-db-digest 542D349827A88738A04332DAFF2516A384BCC8FF
dirreq-stats-end 2015-03-20 07:52:16 (86400 s)
dirreq-v3-ips mx=8
dirreq-v3-reqs mx=8
dirreq-v3-resp ok=8,not-enough-sigs=0,unavailable=0,not-found=0,not-modified=0,busy=0
dirreq-v3-direct-dl complete=0,timeout=0,running=0
dirreq-v3-tunneled-dl complete=4,timeout=0,running=0
transport obfs3
bridge-stats-end 2015-03-20 07:52:22 (86400 s)
bridge-ips ??=8,mx=8
bridge-ip-versions v4=8,v6=8
bridge-ip-transports =8,obfs3=8
router-digest A493F46D74014938951862D30A71C59E652AEBE7
@type bridge-extra-info 1.2
extra-info UlrikeMeinhof B4869206C1EEA4A090FE614155BD6942701F80F1
published 2015-03-20 10:54:03
write-history 2015-03-20 10:40:27 (14400 s) 440320,487424,483328,495616,435200,1073152
read-history 2015-03-20 10:40:27 (14400 s) 5354496,5104640,4907008,4946944,4852736,6280192
geoip-db-digest C1EB5237F2FBAF63381D8551157F13D12EFCCA25
geoip6-db-digest 1F99B6B0EC78E9DB34D61AE7E0FC261D558E8E5D
dirreq-stats-end 2015-03-20 07:55:27 (86400 s)
dirreq-v3-ips
dirreq-v3-reqs
dirreq-v3-resp ok=0,not-enough-sigs=0,unavailable=0,not-found=0,not-modified=0,busy=0
dirreq-v3-direct-dl complete=0,timeout=0,running=0
dirreq-v3-tunneled-dl complete=0,timeout=0,running=0
transport obfs3
bridge-stats-end 2015-03-20 07:55:31 (86400 s)
bridge-ips
bridge-ip-versions v4=0,v6=0
bridge-ip-transports
router-digest 2BEA3A5A03D1125617892D5A4E69A1BFDAE07AB6
@type bridge-extra-info 1.2
extra-info Unnamed C18896EB6274DC8123491FAE1DD17E1769C54C4F
published 2015-03-20 10:55:41
write-history 2015-03-20 10:52:59 (900 s) 1520640,17408,24576,19456,11264,5120,130048,25600,20480,14336,11264,100352,12288
read-history 2015-03-20 10:52:59 (900 s) 7316480,16384,24576,23552,11264,4096,2151424,33792,23552,13312,12288,1253376,8192
router-digest 5D531EB5BC5B4D887B6AE1CFE8B20D61E9E4C43D
@type bridge-extra-info 1.2
extra-info default 478B4CB438302981DE9AAF246F48DBE57F69050A
published 2015-03-20 10:56:17
write-history 2015-03-20 10:54:10 (900 s) 1387520
read-history 2015-03-20 10:54:10 (900 s) 7402496
router-digest 132180906EAF02DD018CBD939AFE56236B2D3218
@type bridge-extra-info 1.2
extra-info Unnamed 25D9D52A0350B42E69C8AB7CE945DB1CA38DA0CF
published 2015-03-20 10:59:53
write-history 2015-03-20 10:51:53 (900 s) 1398784,70656,20480,21504,9216,7168,55296,35840,104448,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
read-history 2015-03-20 10:51:53 (900 s) 8119296,885760,26624,32768,18432,16384,1226752,60416,1311744,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
router-digest 1AA6F27BB6A55EE97FF8C22D8BC2026A437BC1EF
stem-1.6.0/test/unit/descriptor/hidden_service_descriptor.py 0000664 0001750 0001750 00000055035 13125773507 025131 0 ustar atagar atagar 0000000 0000000 """
Unit tests for stem.descriptor.hidden_service_descriptor.
"""
import datetime
import functools
import unittest
import stem.descriptor
import stem.prereq
import test.require
from stem.descriptor.hidden_service_descriptor import (
REQUIRED_FIELDS,
DecryptionFailure,
HiddenServiceDescriptor,
)
from test.unit.descriptor import (
get_resource,
base_expect_invalid_attr,
base_expect_invalid_attr_for_text,
)
MESSAGE_BLOCK = """
-----BEGIN MESSAGE-----
%s
-----END MESSAGE-----\
"""
EXPECTED_DDG_PERMANENT_KEY = """\
-----BEGIN RSA PUBLIC KEY-----
MIGJAoGBAJ/SzzgrXPxTlFrKVhXh3buCWv2QfcNgncUpDpKouLn3AtPH5Ocys0jE
aZSKdvaiQ62md2gOwj4x61cFNdi05tdQjS+2thHKEm/KsB9BGLSLBNJYY356bupg
I5gQozM65ENelfxYlysBjJ52xSDBd8C4f/p9umdzaaaCmzXG/nhzAgMBAAE=
-----END RSA PUBLIC KEY-----\
"""
EXPECTED_DDG_INTRODUCTION_POINTS_ENCODED = """\
-----BEGIN MESSAGE-----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-----END MESSAGE-----\
"""
EXPECTED_DDG_INTRODUCTION_POINTS_CONTENT = b"""\
introduction-point iwki77xtbvp6qvedfrwdzncxs3ckayeu
ip-address 178.62.222.129
onion-port 443
onion-key
-----BEGIN RSA PUBLIC KEY-----
MIGJAoGBAK94BEYIHZ4KdEkeyPhbLCpRW5ESg+2WPQhrM4yuKYGuq8wFWgumZYR9
k/WA//FYXMBz0bB+ckuZs/Yu9nK+HLzpGapV0clst4GUMcBInUCzCcpjJTQsQDgm
3/Y3cqh0W55gOCFhomQ4/1WOYg7YCjk4XYHJE20OdG2Ll5zotK6fAgMBAAE=
-----END RSA PUBLIC KEY-----
service-key
-----BEGIN RSA PUBLIC KEY-----
MIGJAoGBAJXmJb8lSydMMqCgCgfgvlB2E5rpd57kz/Aqg7/d1HKc3+l5QoUvHyuy
ZsAlyka8Eu534hl41oqEKpAKYcMn1TM0vpJEGNVOc+05BInxI9h9f0Mg01PD0tYu
GcLHYgBzcrfEmKwMtM8WEmcMJd7n2uffaAvJ846WubbeV7MW1YehAgMBAAE=
-----END RSA PUBLIC KEY-----
introduction-point em4gjk6eiiualhmlyiifrzc7lbtrsbip
ip-address 46.4.174.52
onion-port 443
onion-key
-----BEGIN RSA PUBLIC KEY-----
MIGJAoGBALBmhdF5wHxHrpLSmjAZottx220+995FdMOOtZNjRw1DBSprUZZqtxWa
P8TKpHKzwGJKCVYIIj7lohbv9T9urmlfTE05URGenZoifOFNz3YwMJTXScQEBJ10
9iWNLDTskLzDKCAbGhbn/MKwOfYGBhNTljdyTmNY5ECRbRzjev9vAgMBAAE=
-----END RSA PUBLIC KEY-----
service-key
-----BEGIN RSA PUBLIC KEY-----
MIGJAoGBAMxMHoAmrbUMsxiICp3iTPYghn0YueKHx219wu8O/Q51QycVVLpX27d1
hJXkPB33XQBXsBS7SxsSsSCQ3GEurQJ7GuBLpYIR/vqsakE/l8wc2CJC5WUhyFFk
+1TWIUI5txnXLyWCRcKDUrjqdosDaDosgHFg23Mnx+xXcaQ/frB/AgMBAAE=
-----END RSA PUBLIC KEY-----
introduction-point jqhfl364x3upe6lqnxizolewlfrsw2zy
ip-address 62.210.82.169
onion-port 443
onion-key
-----BEGIN RSA PUBLIC KEY-----
MIGJAoGBAPUkqxgfYdw0Pm/g6MbhmVsGKlujifmkhdfoEeuzgo+wnEsGvwUebzrz
fZJRt0caXFhnCGgQD2IgmarUaUvP24fXo/4mYzLcPeI7gZneuAQJYvm98Yv9vOHl
NaM/WvDkCsJ3GVNJ1H3wLPQRI3v7KbNuc9tCOYl/r09OhVaWkzajAgMBAAE=
-----END RSA PUBLIC KEY-----
service-key
-----BEGIN RSA PUBLIC KEY-----
MIGJAoGBALbx8LeqRoP/r9w9hjwD41YUm7Po697xRtytF0McyLCS7GRiUYnji7KY
fepXdvN/Jl5qQKHIBb602kuOTl0pN8Q+YeFUSIIDcmPBLpBDhH3PvrQMcGVaiOWH
8w0HMZCxgwAcCC51w5VwiumxEJNBVcZsOx0mzN1Cloy+90q0lFXLAgMBAAE=
-----END RSA PUBLIC KEY-----
"""
EXPECTED_DDG_SIGNATURE = """\
-----BEGIN SIGNATURE-----
VKMmsDIUUFOrpqvcQroIZjDZTKxqNs88a4M9Te8cR/ZvS7H2nffv6iQs0tom5X4D
4Dy4iZiy+pwYxdHfaOxmdpgMCRvgPb34MExWr5YemH0QuGtnlp5Wxr8GYaAQVuZX
cZjQLW0juUYCbgIGdxVEBnlEt2rgBSM9+1oR7EAfV1U=
-----END SIGNATURE-----\
"""
EXPECT_POINT_1_ONION_KEY = """\
-----BEGIN RSA PUBLIC KEY-----
MIGJAoGBAK94BEYIHZ4KdEkeyPhbLCpRW5ESg+2WPQhrM4yuKYGuq8wFWgumZYR9
k/WA//FYXMBz0bB+ckuZs/Yu9nK+HLzpGapV0clst4GUMcBInUCzCcpjJTQsQDgm
3/Y3cqh0W55gOCFhomQ4/1WOYg7YCjk4XYHJE20OdG2Ll5zotK6fAgMBAAE=
-----END RSA PUBLIC KEY-----\
"""
EXPECT_POINT_1_SERVICE_KEY = """\
-----BEGIN RSA PUBLIC KEY-----
MIGJAoGBAJXmJb8lSydMMqCgCgfgvlB2E5rpd57kz/Aqg7/d1HKc3+l5QoUvHyuy
ZsAlyka8Eu534hl41oqEKpAKYcMn1TM0vpJEGNVOc+05BInxI9h9f0Mg01PD0tYu
GcLHYgBzcrfEmKwMtM8WEmcMJd7n2uffaAvJ846WubbeV7MW1YehAgMBAAE=
-----END RSA PUBLIC KEY-----\
"""
EXPECT_POINT_2_ONION_KEY = """\
-----BEGIN RSA PUBLIC KEY-----
MIGJAoGBALBmhdF5wHxHrpLSmjAZottx220+995FdMOOtZNjRw1DBSprUZZqtxWa
P8TKpHKzwGJKCVYIIj7lohbv9T9urmlfTE05URGenZoifOFNz3YwMJTXScQEBJ10
9iWNLDTskLzDKCAbGhbn/MKwOfYGBhNTljdyTmNY5ECRbRzjev9vAgMBAAE=
-----END RSA PUBLIC KEY-----\
"""
EXPECT_POINT_2_SERVICE_KEY = """\
-----BEGIN RSA PUBLIC KEY-----
MIGJAoGBAMxMHoAmrbUMsxiICp3iTPYghn0YueKHx219wu8O/Q51QycVVLpX27d1
hJXkPB33XQBXsBS7SxsSsSCQ3GEurQJ7GuBLpYIR/vqsakE/l8wc2CJC5WUhyFFk
+1TWIUI5txnXLyWCRcKDUrjqdosDaDosgHFg23Mnx+xXcaQ/frB/AgMBAAE=
-----END RSA PUBLIC KEY-----\
"""
EXPECT_POINT_3_ONION_KEY = """\
-----BEGIN RSA PUBLIC KEY-----
MIGJAoGBAPUkqxgfYdw0Pm/g6MbhmVsGKlujifmkhdfoEeuzgo+wnEsGvwUebzrz
fZJRt0caXFhnCGgQD2IgmarUaUvP24fXo/4mYzLcPeI7gZneuAQJYvm98Yv9vOHl
NaM/WvDkCsJ3GVNJ1H3wLPQRI3v7KbNuc9tCOYl/r09OhVaWkzajAgMBAAE=
-----END RSA PUBLIC KEY-----\
"""
EXPECT_POINT_3_SERVICE_KEY = """\
-----BEGIN RSA PUBLIC KEY-----
MIGJAoGBALbx8LeqRoP/r9w9hjwD41YUm7Po697xRtytF0McyLCS7GRiUYnji7KY
fepXdvN/Jl5qQKHIBb602kuOTl0pN8Q+YeFUSIIDcmPBLpBDhH3PvrQMcGVaiOWH
8w0HMZCxgwAcCC51w5VwiumxEJNBVcZsOx0mzN1Cloy+90q0lFXLAgMBAAE=
-----END RSA PUBLIC KEY-----\
"""
EXPECTED_BASIC_AUTH_INTRODUCTION_POINTS_ENCODED = """\
-----BEGIN MESSAGE-----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-----END MESSAGE-----\
"""
expect_invalid_attr = functools.partial(base_expect_invalid_attr, HiddenServiceDescriptor, 'descriptor_id', 'y3olqqblqw2gbh6phimfuiroechjjafa')
expect_invalid_attr_for_text = functools.partial(base_expect_invalid_attr_for_text, HiddenServiceDescriptor, 'descriptor_id', 'y3olqqblqw2gbh6phimfuiroechjjafa')
class TestHiddenServiceDescriptor(unittest.TestCase):
def test_for_duckduckgo_with_validation(self):
"""
Parse duckduckgo's descriptor.
"""
descriptor_file = open(get_resource('hidden_service_duckduckgo'), 'rb')
desc = next(stem.descriptor.parse_file(descriptor_file, 'hidden-service-descriptor 1.0', validate = True))
self._assert_matches_duckduckgo(desc)
def test_for_duckduckgo_without_validation(self):
"""
Parse duckduckgo's descriptor
"""
descriptor_file = open(get_resource('hidden_service_duckduckgo'), 'rb')
desc = next(stem.descriptor.parse_file(descriptor_file, 'hidden-service-descriptor 1.0', validate = False))
self._assert_matches_duckduckgo(desc)
def test_for_facebook(self):
"""
Parse facebook's descriptor.
"""
descriptor_file = open(get_resource('hidden_service_facebook'), 'rb')
desc = next(stem.descriptor.parse_file(descriptor_file, 'hidden-service-descriptor 1.0', validate = True))
self.assertEqual('utjk4arxqg6s6zzo7n6cjnq6ot34udhr', desc.descriptor_id)
self.assertEqual(2, desc.version)
self.assertEqual('6355jaerje3bqozopwq2qmpf4iviizdn', desc.secret_id_part)
self.assertEqual(datetime.datetime(2014, 10, 31, 23, 0, 0), desc.published)
self.assertEqual([2, 3], desc.protocol_versions)
@test.require.cryptography
def test_descriptor_signing(self):
self.assertRaisesRegexp(NotImplementedError, 'Signing of HiddenServiceDescriptor not implemented', HiddenServiceDescriptor.create, sign = True)
@test.require.cryptography
def test_with_basic_auth(self):
"""
Parse a descriptor with introduction-points encrypted with basic auth.
"""
descriptor_file = open(get_resource('hidden_service_basic_auth'), 'rb')
desc = next(stem.descriptor.parse_file(descriptor_file, 'hidden-service-descriptor 1.0', validate = True))
self.assertEqual('yfmvdrkdbyquyqk5vygyeylgj2qmrvrd', desc.descriptor_id)
self.assertEqual(2, desc.version)
self.assertEqual('fluw7z3s5cghuuirq3imh5jjj5ljips6', desc.secret_id_part)
self.assertEqual(datetime.datetime(2015, 2, 24, 20, 0, 0), desc.published)
self.assertEqual([2, 3], desc.protocol_versions)
self.assertEqual(EXPECTED_BASIC_AUTH_INTRODUCTION_POINTS_ENCODED, desc.introduction_points_encoded)
self.assertEqual([], desc.introduction_points_auth)
self.assertRaises(DecryptionFailure, desc.introduction_points)
self.assertRaises(DecryptionFailure, desc.introduction_points, 'aCmx3qIvArbil8A0KM4KgQ==')
introduction_points = desc.introduction_points('dCmx3qIvArbil8A0KM4KgQ==')
self.assertEqual(3, len(introduction_points))
point = introduction_points[0]
self.assertEqual('hmtvoobwglmmec26alnvl7x7mgmmr7xv', point.identifier)
self.assertEqual('195.154.82.88', point.address)
self.assertEqual(443, point.port)
self.assertTrue('MIGJAoGBANbPRD07T' in point.onion_key)
self.assertTrue('MIGJAoGBAN+LAdZP/' in point.service_key)
self.assertEqual([], point.intro_authentication)
point = introduction_points[1]
self.assertEqual('q5w6l2f4g5zw4rkr56fkyovbkkrnzcj5', point.identifier)
self.assertEqual('37.252.190.133', point.address)
self.assertEqual(9001, point.port)
self.assertTrue('MIGJAoGBAKmsbKrtt' in point.onion_key)
self.assertTrue('MIGJAoGBANwczLtzR' in point.service_key)
self.assertEqual([], point.intro_authentication)
point = introduction_points[2]
self.assertEqual('qcvprvmvnjb4dfyqjtxskugniliwlrx3', point.identifier)
self.assertEqual('193.11.114.45', point.address)
self.assertEqual(9002, point.port)
self.assertTrue('MIGJAoGBAM1ILL+7P' in point.onion_key)
self.assertTrue('MIGJAoGBAM7B/cymp' in point.service_key)
self.assertEqual([], point.intro_authentication)
@test.require.cryptography
def test_with_stealth_auth(self):
"""
Parse a descriptor with introduction-points encrypted with stealth auth.
"""
descriptor_file = open(get_resource('hidden_service_stealth_auth'), 'rb')
desc = next(stem.descriptor.parse_file(descriptor_file, 'hidden-service-descriptor 1.0', validate = True))
self.assertEqual('ubf3xeibzlfil6s4larq6y5peup2z3oj', desc.descriptor_id)
self.assertEqual(2, desc.version)
self.assertEqual('jczvydhzetbpdiylj3d5nsnjvaigs7xm', desc.secret_id_part)
self.assertEqual(datetime.datetime(2015, 2, 24, 20, 0, 0), desc.published)
self.assertEqual([2, 3], desc.protocol_versions)
self.assertEqual([], desc.introduction_points_auth)
self.assertRaises(DecryptionFailure, desc.introduction_points)
self.assertRaises(DecryptionFailure, desc.introduction_points, 'aCmx3qIvArbil8A0KM4KgQ==')
introduction_points = desc.introduction_points('dCmx3qIvArbil8A0KM4KgQ==')
self.assertEqual(3, len(introduction_points))
point = introduction_points[0]
self.assertEqual('6h4bkedts3yz2exl3vu4lsyiwkjrx5ff', point.identifier)
self.assertEqual('95.85.60.23', point.address)
self.assertEqual(443, point.port)
self.assertTrue('MIGJAoGBAMX5hO5hQ' in point.onion_key)
self.assertTrue('MIGJAoGBAMNSjfydv' in point.service_key)
self.assertEqual([], point.intro_authentication)
point = introduction_points[1]
self.assertEqual('4ghasjftsdfbbycafvlfx7czln3hrk53', point.identifier)
self.assertEqual('178.254.55.101', point.address)
self.assertEqual(9901, point.port)
self.assertTrue('MIGJAoGBAL2v/KNEY' in point.onion_key)
self.assertTrue('MIGJAoGBAOXiuIgBr' in point.service_key)
self.assertEqual([], point.intro_authentication)
point = introduction_points[2]
self.assertEqual('76tsxvudxqx47gedk3tl5qpesdzrh6yh', point.identifier)
self.assertEqual('193.11.164.243', point.address)
self.assertEqual(9001, point.port)
self.assertTrue('MIGJAoGBALca3zEoS' in point.onion_key)
self.assertTrue('MIGJAoGBAL3rWIAQ6' in point.service_key)
self.assertEqual([], point.intro_authentication)
def _assert_matches_duckduckgo(self, desc):
self.assertEqual('y3olqqblqw2gbh6phimfuiroechjjafa', desc.descriptor_id)
self.assertEqual(2, desc.version)
self.assertEqual(EXPECTED_DDG_PERMANENT_KEY, desc.permanent_key)
self.assertEqual('e24kgecavwsznj7gpbktqsiwgvngsf4e', desc.secret_id_part)
self.assertEqual(datetime.datetime(2015, 2, 23, 20, 0, 0), desc.published)
self.assertEqual([2, 3], desc.protocol_versions)
self.assertEqual(EXPECTED_DDG_INTRODUCTION_POINTS_ENCODED, desc.introduction_points_encoded)
self.assertEqual([], desc.introduction_points_auth)
self.assertEqual(EXPECTED_DDG_INTRODUCTION_POINTS_CONTENT, desc.introduction_points_content)
self.assertEqual(EXPECTED_DDG_SIGNATURE, desc.signature)
introduction_points = desc.introduction_points()
self.assertEqual(3, len(introduction_points))
point = introduction_points[0]
self.assertEqual('iwki77xtbvp6qvedfrwdzncxs3ckayeu', point.identifier)
self.assertEqual('178.62.222.129', point.address)
self.assertEqual(443, point.port)
self.assertEqual(EXPECT_POINT_1_ONION_KEY, point.onion_key)
self.assertEqual(EXPECT_POINT_1_SERVICE_KEY, point.service_key)
self.assertEqual([], point.intro_authentication)
point = introduction_points[1]
self.assertEqual('em4gjk6eiiualhmlyiifrzc7lbtrsbip', point.identifier)
self.assertEqual('46.4.174.52', point.address)
self.assertEqual(443, point.port)
self.assertEqual(EXPECT_POINT_2_ONION_KEY, point.onion_key)
self.assertEqual(EXPECT_POINT_2_SERVICE_KEY, point.service_key)
self.assertEqual([], point.intro_authentication)
point = introduction_points[2]
self.assertEqual('jqhfl364x3upe6lqnxizolewlfrsw2zy', point.identifier)
self.assertEqual('62.210.82.169', point.address)
self.assertEqual(443, point.port)
self.assertEqual(EXPECT_POINT_3_ONION_KEY, point.onion_key)
self.assertEqual(EXPECT_POINT_3_SERVICE_KEY, point.service_key)
self.assertEqual([], point.intro_authentication)
def test_minimal_hidden_service_descriptor(self):
"""
Basic sanity check that we can parse a hidden service descriptor with minimal attributes.
"""
desc = HiddenServiceDescriptor.create()
self.assertEqual('y3olqqblqw2gbh6phimfuiroechjjafa', desc.descriptor_id)
self.assertEqual(2, desc.version)
self.assertEqual('e24kgecavwsznj7gpbktqsiwgvngsf4e', desc.secret_id_part)
self.assertEqual([2, 3], desc.protocol_versions)
self.assertEqual('-----BEGIN MESSAGE-----\n-----END MESSAGE-----', desc.introduction_points_encoded)
self.assertEqual([], desc.introduction_points_auth)
self.assertEqual(b'', desc.introduction_points_content)
self.assertEqual([], desc.introduction_points())
def test_unrecognized_line(self):
"""
Includes unrecognized content in the descriptor.
"""
desc = HiddenServiceDescriptor.create({'pepperjack': 'is oh so tasty!'})
self.assertEqual(['pepperjack is oh so tasty!'], desc.get_unrecognized_lines())
def test_proceeding_line(self):
"""
Includes a line prior to the 'rendezvous-service-descriptor' entry.
"""
expect_invalid_attr_for_text(self, b'hibernate 1\n' + HiddenServiceDescriptor.content())
def test_trailing_line(self):
"""
Includes a line after the 'router-signature' entry.
"""
expect_invalid_attr_for_text(self, HiddenServiceDescriptor.content() + b'\nhibernate 1')
def test_required_fields(self):
"""
Check that we require the mandatory fields.
"""
line_to_attr = {
'rendezvous-service-descriptor': 'descriptor_id',
'version': 'version',
'permanent-key': 'permanent_key',
'secret-id-part': 'secret_id_part',
'publication-time': 'published',
'introduction-points': 'introduction_points_encoded',
'protocol-versions': 'protocol_versions',
'signature': 'signature',
}
for line in REQUIRED_FIELDS:
desc_text = HiddenServiceDescriptor.content(exclude = (line,))
expected = [] if line == 'protocol-versions' else None
expect_invalid_attr_for_text(self, desc_text, line_to_attr[line], expected)
def test_invalid_version(self):
"""
Checks that our version field expects a numeric value.
"""
test_values = (
'',
'-10',
'hello',
)
for test_value in test_values:
expect_invalid_attr(self, {'version': test_value}, 'version')
def test_invalid_protocol_versions(self):
"""
Checks that our protocol-versions field expects comma separated numeric
values.
"""
test_values = (
'',
'-10',
'hello',
'10,',
',10',
'10,-10',
'10,hello',
)
for test_value in test_values:
expect_invalid_attr(self, {'protocol-versions': test_value}, 'protocol_versions', [])
def test_introduction_points_when_empty(self):
"""
It's valid to advertise zero introduciton points. I'm not clear if this
would mean an empty protocol-versions field or that it's omitted but either
are valid according to the spec.
"""
missing_field_desc = HiddenServiceDescriptor.create(exclude = ('introduction-points',))
self.assertEqual(None, missing_field_desc.introduction_points_encoded)
self.assertEqual([], missing_field_desc.introduction_points_auth)
self.assertEqual(None, missing_field_desc.introduction_points_content)
self.assertEqual([], missing_field_desc.introduction_points())
empty_field_desc = HiddenServiceDescriptor.create({'introduction-points': MESSAGE_BLOCK % ''})
self.assertEqual((MESSAGE_BLOCK % '').strip(), empty_field_desc.introduction_points_encoded)
self.assertEqual([], empty_field_desc.introduction_points_auth)
self.assertEqual(b'', empty_field_desc.introduction_points_content)
self.assertEqual([], empty_field_desc.introduction_points())
def test_introduction_points_when_not_base64(self):
"""
Checks the introduction-points field when the content isn't base64 encoded.
"""
test_values = (
MESSAGE_BLOCK % '12345',
MESSAGE_BLOCK % 'hello',
)
for test_value in test_values:
desc = expect_invalid_attr(self, {'introduction-points': test_value}, 'introduction_points_encoded', test_value.strip())
self.assertEqual([], desc.introduction_points_auth)
self.assertEqual(None, desc.introduction_points_content)
self.assertEqual([], desc.introduction_points())
stem-1.6.0/test/unit/descriptor/reader.py 0000664 0001750 0001750 00000051151 13124757510 021150 0 ustar atagar atagar 0000000 0000000 """
Unit tests for stem.descriptor.reader.
"""
import getpass
import io
import os
import shutil
import signal
import sys
import tarfile
import tempfile
import time
import unittest
import stem.descriptor.reader
import test.unit.descriptor
from stem.util import str_type, system
try:
# added in python 3.3
from unittest.mock import patch
except ImportError:
from mock import patch
BASIC_LISTING = """
/tmp 123
/bin/grep 4567
/file with spaces/and \\ stuff 890
"""
my_dir = os.path.dirname(__file__)
DESCRIPTOR_TEST_DATA = os.path.join(my_dir, 'data')
TAR_DESCRIPTORS = None
def _get_raw_tar_descriptors():
global TAR_DESCRIPTORS
if not TAR_DESCRIPTORS:
test_path = os.path.join(DESCRIPTOR_TEST_DATA, 'descriptor_archive.tar')
raw_descriptors = []
# TODO: revert to using the 'with' keyword for this when dropping python
# 2.6 support
tar_file = None
try:
tar_file = tarfile.open(test_path)
for tar_entry in tar_file:
if tar_entry.isfile():
entry = tar_file.extractfile(tar_entry)
entry.readline() # strip header
raw_descriptors.append(entry.read().decode('utf-8', 'replace'))
entry.close()
finally:
if tar_file:
tar_file.close()
TAR_DESCRIPTORS = raw_descriptors
return TAR_DESCRIPTORS
class SkipListener:
def __init__(self):
self.results = [] # (path, exception) tuples that we've received
def listener(self, path, exception):
self.results.append((path, exception))
class TestDescriptorReader(unittest.TestCase):
def setUp(self):
self.temp_directory = tempfile.mkdtemp()
self.test_listing_path = os.path.join(self.temp_directory, 'descriptor_processed_files')
def tearDown(self):
shutil.rmtree(self.temp_directory)
@patch('stem.descriptor.reader.open', create = True)
def test_load_processed_files(self, open_mock):
"""
Successful load of content.
"""
test_lines = (
str_type('/dir/ 0'),
str_type('/dir/file 12345'),
str_type('/dir/file with spaces 7138743'),
str_type(' /dir/with extra space 12345 '),
str_type(' \t '),
str_type(''),
str_type('/dir/after empty line 12345'),
)
expected_value = {
'/dir/': 0,
'/dir/file': 12345,
'/dir/file with spaces': 7138743,
'/dir/with extra space': 12345,
'/dir/after empty line': 12345,
}
open_mock.return_value = io.StringIO(str_type('\n'.join(test_lines)))
self.assertEqual(expected_value, stem.descriptor.reader.load_processed_files(''))
@patch('stem.descriptor.reader.open', create = True)
def test_load_processed_files_empty(self, open_mock):
"""
Tests the load_processed_files() function with an empty file.
"""
open_mock.return_value = io.StringIO(str_type(''))
self.assertEqual({}, stem.descriptor.reader.load_processed_files(''))
@patch('stem.descriptor.reader.open', create = True)
def test_load_processed_files_no_file(self, open_mock):
"""
Tests the load_processed_files() function content that is malformed because
it is missing the file path.
"""
open_mock.return_value = io.StringIO(str_type(' 12345'))
self.assertRaises(TypeError, stem.descriptor.reader.load_processed_files, '')
@patch('stem.descriptor.reader.open', create = True)
def test_load_processed_files_no_timestamp(self, open_mock):
"""
Tests the load_processed_files() function content that is malformed because
it is missing the timestamp.
"""
open_mock.return_value = io.StringIO(str_type('/dir/file '))
self.assertRaises(TypeError, stem.descriptor.reader.load_processed_files, '')
@patch('stem.descriptor.reader.open', create = True)
def test_load_processed_files_malformed_file(self, open_mock):
"""
Tests the load_processed_files() function content that is malformed because
it has an invalid file path.
"""
open_mock.return_value = io.StringIO(str_type('not_an_absolute_file 12345'))
self.assertRaises(TypeError, stem.descriptor.reader.load_processed_files, '')
@patch('stem.descriptor.reader.open', create = True)
def test_load_processed_files_malformed_timestamp(self, open_mock):
"""
Tests the load_processed_files() function content that is malformed because
it has a non-numeric timestamp.
"""
open_mock.return_value = io.StringIO(str_type('/dir/file 123a'))
self.assertRaises(TypeError, stem.descriptor.reader.load_processed_files, '')
def test_load_processed_files_from_data(self):
"""
Basic sanity test for loading a processed files listing from disk.
"""
test_listing_path = self._make_processed_files_listing(BASIC_LISTING)
loaded_listing = stem.descriptor.reader.load_processed_files(test_listing_path)
expected_listing = {
'/tmp': 123,
'/bin/grep': 4567,
'/file with spaces/and \\ stuff': 890,
}
self.assertEqual(expected_listing, loaded_listing)
def test_load_processed_files_missing(self):
"""
Tests the load_processed_files() function with a file that doesn't exist.
"""
self.assertRaises(IOError, stem.descriptor.reader.load_processed_files, '/non-existant/path')
def test_load_processed_files_permissions(self):
"""
Tests the load_processed_files() function with a file that can't be read
due to permissions.
"""
# test relies on being unable to read a file
if getpass.getuser() == 'root':
self.skipTest('(running as root)')
return
# Skip the test on windows, since you can only set the file's
# read-only flag with os.chmod(). For more information see...
# http://docs.python.org/library/os.html#os.chmod
if system.is_windows():
self.skipTest('(chmod not functional)')
test_listing_path = self._make_processed_files_listing(BASIC_LISTING)
os.chmod(test_listing_path, 0o077) # remove read permissions
self.assertRaises(IOError, stem.descriptor.reader.load_processed_files, test_listing_path)
def test_save_processed_files(self):
"""
Basic sanity test for persisting files listings to disk.
"""
initial_listing = {
'/tmp': 123,
'/bin/grep': 4567,
'/file with spaces/and \\ stuff': 890,
}
# saves the initial_listing to a file then reloads it
stem.descriptor.reader.save_processed_files(self.test_listing_path, initial_listing)
loaded_listing = stem.descriptor.reader.load_processed_files(self.test_listing_path)
self.assertEqual(initial_listing, loaded_listing)
def test_save_processed_files_malformed(self):
"""
Tests the save_processed_files() function with malformed data.
"""
missing_filename = {'': 123}
relative_filename = {'foobar': 123}
string_timestamp = {'/tmp': '123a'}
temp_path = tempfile.mkstemp(prefix = 'stem-unit-tests-', text = True)[1]
for listing in (missing_filename, relative_filename, string_timestamp):
self.assertRaises(TypeError, stem.descriptor.reader.save_processed_files, temp_path, listing)
# Though our attempts to save the processed files fail we'll write an empty
# file. Cleaning it up.
try:
os.remove(temp_path)
except:
pass
def test_basic_example(self):
"""
Exercises something similar to the first example in the header
documentation, checking that some of the contents match what we'd expect.
"""
# snag some of the plaintext descriptors so we can later make sure that we
# iterate over them
descriptor_entries = []
descriptor_path = os.path.join(DESCRIPTOR_TEST_DATA, 'example_descriptor')
with open(descriptor_path) as descriptor_file:
descriptor_file.readline() # strip header
descriptor_entries.append(descriptor_file.read())
# running this test multiple times to flush out concurrency issues
for _ in range(15):
remaining_entries = list(descriptor_entries)
with stem.descriptor.reader.DescriptorReader(descriptor_path) as reader:
for descriptor in reader:
descriptor_str = str(descriptor)
if descriptor_str in remaining_entries:
remaining_entries.remove(descriptor_str)
else:
# iterator is providing output that we didn't expect
self.fail()
# check that we've seen all of the descriptor_entries
self.assertTrue(len(remaining_entries) == 0)
def test_multiple_runs(self):
"""
Runs a DescriptorReader instance multiple times over the same content,
making sure that it can be used repeatedly.
"""
descriptor_path = os.path.join(DESCRIPTOR_TEST_DATA, 'example_descriptor')
reader = stem.descriptor.reader.DescriptorReader(descriptor_path)
with reader:
self.assertEqual(1, len(list(reader)))
# run it a second time, this shouldn't provide any descriptors because we
# have already read it
with reader:
self.assertEqual(0, len(list(reader)))
# clear the DescriptorReader's memory of seeing the file and run it again
reader.set_processed_files([])
with reader:
self.assertEqual(1, len(list(reader)))
def test_buffer_size(self):
"""
Checks that we can process sets of descriptors larger than our buffer size,
that we don't exceed it, and that we can still stop midway through reading
them.
"""
reader = stem.descriptor.reader.DescriptorReader(DESCRIPTOR_TEST_DATA, buffer_size = 2)
with reader:
self.assertTrue(reader.get_buffered_descriptor_count() <= 2)
time.sleep(0.001)
self.assertTrue(reader.get_buffered_descriptor_count() <= 2)
def test_persistence_path(self):
"""
Check that the persistence_path argument loads and saves a a processed
files listing.
"""
descriptor_path = os.path.join(DESCRIPTOR_TEST_DATA, 'example_descriptor')
# First run where the persistence_path doesn't yet exist. This just tests
# the saving functionality.
reader = stem.descriptor.reader.DescriptorReader(descriptor_path, persistence_path = self.test_listing_path)
with reader:
self.assertEqual(1, len(list(reader)))
# check that we've saved reading example_descriptor
self.assertTrue(os.path.exists(self.test_listing_path))
with open(self.test_listing_path) as persistence_file:
persistance_file_contents = persistence_file.read()
self.assertTrue(persistance_file_contents.startswith(descriptor_path))
# Try running again with a new reader but the same persistance path, if it
# reads and takes the persistence_path into account then it won't read the
# descriptor file. This in essence just tests its loading functionality.
reader = stem.descriptor.reader.DescriptorReader(descriptor_path, persistence_path = self.test_listing_path)
with reader:
self.assertEqual(0, len(list(reader)))
def test_archived_paths(self):
"""
Checks the get_path() and get_archive_path() for a tarball.
"""
expected_archive_paths = (
'descriptor_archive/0/2/02c311d3d789f3f55c0880b5c85f3c196343552c',
'descriptor_archive/1/b/1bb798cae15e21479db0bc700767eee4733e9d4a',
'descriptor_archive/1/b/1ef75fef564180d8b3f72c6f8635ff0cd855f92c',
)
test_path = os.path.join(DESCRIPTOR_TEST_DATA, 'descriptor_archive.tar')
with stem.descriptor.reader.DescriptorReader(test_path) as reader:
for desc in reader:
self.assertEqual(test_path, desc.get_path())
self.assertTrue(desc.get_archive_path() in expected_archive_paths)
def test_archived_uncompressed(self):
"""
Checks that we can read descriptors from an uncompressed archive.
"""
expected_results = _get_raw_tar_descriptors()
test_path = os.path.join(DESCRIPTOR_TEST_DATA, 'descriptor_archive.tar')
with stem.descriptor.reader.DescriptorReader(test_path) as reader:
read_descriptors = [str(desc) for desc in list(reader)]
self.assertEqual(expected_results, read_descriptors)
def test_archived_gzip(self):
"""
Checks that we can read descriptors from a gzipped archive.
"""
expected_results = _get_raw_tar_descriptors()
test_path = os.path.join(DESCRIPTOR_TEST_DATA, 'descriptor_archive.tar.gz')
with stem.descriptor.reader.DescriptorReader(test_path) as reader:
read_descriptors = [str(desc) for desc in list(reader)]
self.assertEqual(expected_results, read_descriptors)
def test_archived_bz2(self):
"""
Checks that we can read descriptors from an bzipped archive.
"""
# when python's compiled it only optionally has bz2 support
try:
import bz2
except ImportError:
self.skipTest('(bz2 unsupported}')
expected_results = _get_raw_tar_descriptors()
test_path = os.path.join(DESCRIPTOR_TEST_DATA, 'descriptor_archive.tar.bz2')
with stem.descriptor.reader.DescriptorReader(test_path) as reader:
read_descriptors = [str(desc) for desc in list(reader)]
self.assertEqual(expected_results, read_descriptors)
def test_stop(self):
"""
Runs a DescriptorReader over the root directory, then checks that calling
stop() makes it terminate in a timely fashion.
"""
# Skip on windows since SIGALRM is unavailable
if system.is_windows():
self.skipTest('(SIGALRM unavailable)')
is_test_running = True
reader = stem.descriptor.reader.DescriptorReader('/usr')
# Fails the test after a couple seconds if we don't finish successfully.
# Depending on what we're blocked on this might not work when the test
# fails, requiring that we give a manual kill to the test.
def timeout_handler(signum, frame):
if is_test_running:
self.fail()
signal.signal(signal.SIGALRM, timeout_handler)
signal.alarm(2)
reader.start()
time.sleep(0.001)
reader.stop()
is_test_running = False
def test_get_processed_files(self):
"""
Checks that get_processed_files() provides the expected results after
iterating over our test data.
"""
desc_path = os.path.join(DESCRIPTOR_TEST_DATA, 'example_descriptor')
last_modified = int(os.stat(desc_path).st_mtime)
reader = stem.descriptor.reader.DescriptorReader(desc_path)
with reader:
list(reader) # iterates over all of the descriptors
self.assertEqual({desc_path: last_modified}, reader.get_processed_files())
def test_skip_nondescriptor_contents(self):
"""
Checks that the reader properly reports when it skips both binary and
plaintext non-descriptor files.
"""
skip_listener = SkipListener()
reader = stem.descriptor.reader.DescriptorReader(os.path.join(DESCRIPTOR_TEST_DATA, 'unparseable'))
reader.register_skip_listener(skip_listener.listener)
expected_skip_files = ('riddle', 'tiny.png', 'vote', 'new_metrics_type', 'cached-microdesc-consensus_with_carriage_returns', 'extrainfo_nonascii_v3_reqs')
with reader:
list(reader) # iterates over all of the descriptors
# strip anything with a .swp suffix (vim tmp files)
skip_listener.results = [(path, exc) for (path, exc) in skip_listener.results if not path.endswith('.swp')]
if len(skip_listener.results) != len(expected_skip_files):
expected_label = ',\n '.join(expected_skip_files)
results_label = ',\n '.join(['%s (%s)' % (path, exc) for (path, exc) in skip_listener.results])
self.fail('Skipped files that we should have been able to parse.\n\nExpected:\n %s\n\nResult:\n %s' % (expected_label, results_label))
for skip_path, skip_exception in skip_listener.results:
if not os.path.basename(skip_path) in expected_skip_files:
self.fail('Unexpected non-descriptor content: %s' % skip_path)
self.assertTrue(isinstance(skip_exception, stem.descriptor.reader.UnrecognizedType))
def test_skip_listener_already_read(self):
"""
Checks that calling set_processed_files() prior to reading makes us skip
those files. This also doubles for testing that skip listeners are notified
of files that we've already read.
"""
# path that we want the DescriptorReader to skip
test_path = os.path.join(DESCRIPTOR_TEST_DATA, 'example_descriptor')
initial_processed_files = {test_path: sys.maxsize}
skip_listener = SkipListener()
reader = stem.descriptor.reader.DescriptorReader(test_path)
reader.register_skip_listener(skip_listener.listener)
reader.set_processed_files(initial_processed_files)
self.assertEqual(initial_processed_files, reader.get_processed_files())
with reader:
list(reader) # iterates over all of the descriptors
self.assertEqual(1, len(skip_listener.results))
skipped_path, skip_exception = skip_listener.results[0]
self.assertEqual(test_path, skipped_path)
self.assertTrue(isinstance(skip_exception, stem.descriptor.reader.AlreadyRead))
self.assertEqual(sys.maxsize, skip_exception.last_modified_when_read)
def test_skip_listener_unrecognized_type(self):
"""
Listens for a file that's skipped because its file type isn't recognized.
"""
# types are solely based on file extensions so making something that looks
# like an png image
test_path = os.path.join(self.temp_directory, 'test.png')
try:
test_file = open(test_path, 'w')
test_file.write('test data for test_skip_listener_unrecognized_type()')
test_file.close()
skip_listener = SkipListener()
reader = stem.descriptor.reader.DescriptorReader(test_path)
reader.register_skip_listener(skip_listener.listener)
with reader:
list(reader) # iterates over all of the descriptors
self.assertEqual(1, len(skip_listener.results))
skipped_path, skip_exception = skip_listener.results[0]
self.assertEqual(test_path, skipped_path)
self.assertTrue(isinstance(skip_exception, stem.descriptor.reader.UnrecognizedType))
self.assertTrue(skip_exception.mime_type in (('image/png', None), ('image/x-png', None)))
finally:
if os.path.exists(test_path):
os.remove(test_path)
def test_skip_listener_read_failure(self):
"""
Listens for a file that's skipped because we lack read permissions.
"""
# test relies on being unable to read a file
if getpass.getuser() == 'root':
self.skipTest('(running as root)')
return
elif system.is_windows():
self.skipTest('(chmod not functional)')
return
test_path = os.path.join(self.temp_directory, 'secret_file')
try:
test_file = open(test_path, 'w')
test_file.write('test data for test_skip_listener_unrecognized_type()')
test_file.close()
os.chmod(test_path, 0o077) # remove read permissions
skip_listener = SkipListener()
reader = stem.descriptor.reader.DescriptorReader(test_path)
reader.register_skip_listener(skip_listener.listener)
with reader:
list(reader) # iterates over all of the descriptors
self.assertEqual(1, len(skip_listener.results))
skipped_path, skip_exception = skip_listener.results[0]
self.assertEqual(test_path, skipped_path)
self.assertTrue(isinstance(skip_exception, stem.descriptor.reader.ReadFailed))
self.assertTrue(isinstance(skip_exception.exception, IOError))
finally:
if os.path.exists(test_path):
os.remove(test_path)
def test_skip_listener_file_missing(self):
"""
Listens for a file that's skipped because the file doesn't exist.
"""
test_path = '/non-existant/path'
skip_listener = SkipListener()
reader = stem.descriptor.reader.DescriptorReader(test_path)
reader.register_skip_listener(skip_listener.listener)
with reader:
list(reader) # iterates over all of the descriptors
self.assertEqual(1, len(skip_listener.results))
skipped_path, skip_exception = skip_listener.results[0]
self.assertEqual(test_path, skipped_path)
self.assertTrue(isinstance(skip_exception, stem.descriptor.reader.FileMissing))
def test_unrecognized_metrics_type(self):
"""
Parses a file that has a valid metrics header, but an unrecognized type.
"""
test_path = test.unit.descriptor.get_resource('unparseable/new_metrics_type')
skip_listener = SkipListener()
reader = stem.descriptor.reader.DescriptorReader(test_path)
reader.register_skip_listener(skip_listener.listener)
with reader:
list(reader) # iterates over all of the descriptors
self.assertEqual(1, len(skip_listener.results))
skipped_path, skip_exception = skip_listener.results[0]
self.assertEqual(test_path, skipped_path)
self.assertTrue(isinstance(skip_exception, stem.descriptor.reader.UnrecognizedType))
self.assertEqual((None, None), skip_exception.mime_type)
def _make_processed_files_listing(self, contents):
"""
Writes the given 'processed file' listing to disk, returning the path where
it is located.
"""
with open(self.test_listing_path, 'w') as test_listing_file:
test_listing_file.write(contents)
return self.test_listing_path
stem-1.6.0/test/unit/descriptor/certificate.py 0000664 0001750 0001750 00000016341 13124757510 022172 0 ustar atagar atagar 0000000 0000000 """
Unit tests for stem.descriptor.certificate.
"""
import base64
import datetime
import re
import unittest
import stem.descriptor.certificate
import stem.util.str_tools
import stem.prereq
import test.require
from stem.descriptor.certificate import ED25519_SIGNATURE_LENGTH, CertType, ExtensionType, ExtensionFlag, Ed25519Certificate, Ed25519CertificateV1, Ed25519Extension
from test.unit.descriptor import get_resource
ED25519_CERT = """
AQQABhtZAaW2GoBED1IjY3A6f6GNqBEl5A83fD2Za9upGke51JGqAQAgBABnprVR
ptIr43bWPo2fIzo3uOywfoMrryprpbm4HhCkZMaO064LP+1KNuLvlc8sGG8lTjx1
g4k3ELuWYgHYWU5rAia7nl4gUfBZOEfHAfKES7l3d63dBEjEX98Ljhdp2w4=
""".strip()
EXPECTED_CERT_KEY = b'\xa5\xb6\x1a\x80D\x0fR#cp:\x7f\xa1\x8d\xa8\x11%\xe4\x0f7|=\x99k\xdb\xa9\x1aG\xb9\xd4\x91\xaa'
EXPECTED_EXTENSION_DATA = b'g\xa6\xb5Q\xa6\xd2+\xe3v\xd6>\x8d\x9f#:7\xb8\xec\xb0~\x83+\xaf*k\xa5\xb9\xb8\x1e\x10\xa4d'
EXPECTED_SIGNATURE = b'\xc6\x8e\xd3\xae\x0b?\xedJ6\xe2\xef\x95\xcf,\x18o%N
.\" Date: 11/29/2015
.\" Manual: Tor Manual
.\" Source: Tor
.\" Language: English
.\"
.TH "TOR" "1" "11/29/2015" "Tor" "Tor Manual"
.\" -----------------------------------------------------------------
.\" * Define some portability stuff
.\" -----------------------------------------------------------------
.\" ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
.\" http://bugs.debian.org/507673
.\" http://lists.gnu.org/archive/html/groff/2009-02/msg00013.html
.\" ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
.ie \n(.g .ds Aq \(aq
.el .ds Aq '
.\" -----------------------------------------------------------------
.\" * set default formatting
.\" -----------------------------------------------------------------
.\" disable hyphenation
.nh
.\" disable justification (adjust text to left margin only)
.ad l
.\" -----------------------------------------------------------------
.\" * MAIN CONTENT STARTS HERE *
.\" -----------------------------------------------------------------
.SH "NAME"
tor \- The second\-generation onion router
.SH "SYNOPSIS"
.sp
\fBtor\fR [\fIOPTION\fR \fIvalue\fR]\&...
.SH "DESCRIPTION"
.sp
Tor is a connection\-oriented anonymizing communication service\&. Users choose a source\-routed path through a set of nodes, and negotiate a "virtual circuit" through the network, in which each node knows its predecessor and successor, but no others\&. Traffic flowing down the circuit is unwrapped by a symmetric key at each node, which reveals the downstream node\&.
.SH "COMMAND-LINE OPTIONS"
.PP
\fB\-h\fR, \fB\-help\fR
.RS 4
Display a short help message and exit\&.
.RE
.PP
\fB\-f\fR \fIFILE\fR
.RS 4
Specify a new configuration file to contain further Tor configuration options OR pass
\fB\-\fR
to make Tor read its configuration from standard input\&. (Default: @CONFDIR@/torrc, or $HOME/\&.torrc if that file is not found)
.RE
.PP
\fB\-\-allow\-missing\-torrc\fR
.RS 4
Do not require that configuration file specified by
\fB\-f\fR
exist if default torrc can be accessed\&.
.RE
.PP
.sp
Options on the command line override those in configuration files\&. See the next section for more information\&.
.SH "THE CONFIGURATION FILE FORMAT"
.sp
All configuration options in a configuration are written on a single line by default\&. They take the form of an option name and a value, or an option name and a quoted value (option value or option "value")\&. Anything after a # character is treated as a comment\&. Options are case\-insensitive\&. C\-style escaped characters are allowed inside quoted values\&. To split one configuration entry into multiple lines, use a single backslash character (\e) before the end of the line\&. Comments can be used in such multiline entries, but they must start at the beginning of a line\&.
.sp
By default, an option on the command line overrides an option found in the configuration file, and an option in a configuration file overrides one in the defaults file\&.
.SH "GENERAL OPTIONS"
.PP
\fBBandwidthRate\fR \fIN\fR \fBbytes\fR|\fBKBytes\fR|\fBMBytes\fR|\fBGBytes\fR|\fBKBits\fR|\fBMBits\fR|\fBGBits\fR
.RS 4
A token bucket limits the average incoming bandwidth usage on this node to the specified number of bytes per second, and the average outgoing bandwidth usage to that same value\&. If you want to run a relay in the public network, this needs to be
\fIat the very least\fR
75 KBytes for a relay (that is, 600 kbits) or 50 KBytes for a bridge (400 kbits) \(em but of course, more is better; we recommend at least 250 KBytes (2 mbits) if possible\&. (Default: 1 GByte)
With this option, and in other options that take arguments in bytes, KBytes, and so on, other formats are also supported\&. Notably, "KBytes" can also be written as "kilobytes" or "kb"; "MBytes" can be written as "megabytes" or "MB"; "kbits" can be written as "kilobits"; and so forth\&. Tor also accepts "byte" and "bit" in the singular\&. The prefixes "tera" and "T" are also recognized\&. If no units are given, we default to bytes\&. To avoid confusion, we recommend writing "bytes" or "bits" explicitly, since it\(cqs easy to forget that "B" means bytes, not bits\&.
.RE
.PP
\fBBandwidthBurst\fR \fIN\fR \fBbytes\fR|\fBKBytes\fR|\fBMBytes\fR|\fBGBytes\fR|\fBKBits\fR|\fBMBits\fR|\fBGBits\fR
.RS 4
Limit the maximum token bucket size (also known as the burst) to the given number of bytes in each direction\&. (Default: 1 GByte)
.RE
.PP
\fBMaxAdvertisedBandwidth\fR \fIN\fR \fBbytes\fR|\fBKBytes\fR|\fBMBytes\fR|\fBGBytes\fR|\fBKBits\fR|\fBMBits\fR|\fBGBits\fR
.RS 4
If set, we will not advertise more than this amount of bandwidth for our BandwidthRate\&. Server operators who want to reduce the number of clients who ask to build circuits through them (since this is proportional to advertised bandwidth rate) can thus reduce the CPU demands on their server without impacting network performance\&.
.RE
.SH "CLIENT OPTIONS"
.sp
The following options are useful only for clients (that is, if \fBSocksPort\fR, \fBTransPort\fR, \fBDNSPort\fR, or \fBNATDPort\fR is non\-zero):
.PP
\fBBridge\fR [\fItransport\fR] \fIIP\fR:\fIORPort\fR [\fIfingerprint\fR]
.RS 4
When set along with UseBridges, instructs Tor to use the relay at "IP:ORPort" as a "bridge" relaying into the Tor network\&. If "fingerprint" is provided (using the same format as for DirAuthority), we will verify that the relay running at that location has the right fingerprint\&. We also use fingerprint to look up the bridge descriptor at the bridge authority, if it\(cqs provided and if UpdateBridgesFromAuthority is set too\&.
If "transport" is provided, and matches to a ClientTransportPlugin line, we use that pluggable transports proxy to transfer data to the bridge\&.
.RE
.SH "SIGNALS"
.sp
Tor catches the following signals:
.PP
\fBSIGTERM\fR
.RS 4
Tor will catch this, clean up and sync to disk if necessary, and exit\&.
.RE
.PP
\fBSIGINT\fR
.RS 4
Tor clients behave as with SIGTERM; but Tor servers will do a controlled slow shutdown, closing listeners and waiting 30 seconds before exiting\&. (The delay can be configured with the ShutdownWaitLength config option\&.)
.RE
.PP
\fBSIGHUP\fR
.RS 4
The signal instructs Tor to reload its configuration (including closing and reopening logs), and kill and restart its helper processes if applicable\&.
.RE
.SH "FILES"
.PP
\fB@CONFDIR@/torrc\fR
.RS 4
The configuration file, which contains "option value" pairs\&.
.RE
.PP
\fB$HOME/\&.torrc\fR
.RS 4
Fallback location for torrc, if @CONFDIR@/torrc is not found\&.
.RE
.PP
\fB@LOCALSTATEDIR@/lib/tor/\fR
.RS 4
The tor process stores keys and other data here\&.
.RE
.PP
\fIDataDirectory\fR\fB/cached\-status/\fR
.RS 4
The most recently downloaded network status document for each authority\&. Each file holds one such document; the filenames are the hexadecimal identity key fingerprints of the directory authorities\&. Mostly obsolete\&.
.RE
.PP
\fIDataDirectory\fR\fB/cached\-certs\fR
.RS 4
This file holds downloaded directory key certificates that are used to verify authenticity of documents generated by Tor directory authorities\&.
.RE
.PP
\fIDataDirectory\fR\fB/state\fR
.RS 4
A set of persistent key\-value mappings\&. These are documented in the file\&. These include:
.sp
.RS 4
.ie n \{\
\h'-04'\(bu\h'+03'\c
.\}
.el \{\
.sp -1
.IP \(bu 2.3
.\}
The current entry guards and their status\&.
.RE
.sp
.RS 4
.ie n \{\
\h'-04'\(bu\h'+03'\c
.\}
.el \{\
.sp -1
.IP \(bu 2.3
.\}
The current bandwidth accounting values (unused so far; see below)\&.
.RE
.sp
.RS 4
.ie n \{\
\h'-04'\(bu\h'+03'\c
.\}
.el \{\
.sp -1
.IP \(bu 2.3
.\}
When the file was last written
.RE
.sp
.RS 4
.ie n \{\
\h'-04'\(bu\h'+03'\c
.\}
.el \{\
.sp -1
.IP \(bu 2.3
.\}
What version of Tor generated the state file
.RE
.sp
.RS 4
.ie n \{\
\h'-04'\(bu\h'+03'\c
.\}
.el \{\
.sp -1
.IP \(bu 2.3
.\}
A short history of bandwidth usage, as produced in the server descriptors\&.
.RE
.RE
.PP
\fIDataDirectory\fR\fB/bw_accounting\fR
.RS 4
Used to track bandwidth accounting values (when the current period starts and ends; how much has been read and written so far this period)\&. This file is obsolete, and the data is now stored in the \*(Aqstate\*(Aq file as well\&. Only used when bandwidth accounting is enabled\&.
.RE
.SH "SEE ALSO"
.sp
\fBtorsocks\fR(1), \fBtorify\fR(1)
.sp
\fBhttps://www\&.torproject\&.org/\fR
.sp
\fBtorspec: \fR\fBhttps://spec\&.torproject\&.org\fR\fB \fR
.SH "BUGS"
.sp
Plenty, probably\&. Tor is still in development\&. Please report them at https://trac\&.torproject\&.org/\&.
.SH "AUTHORS"
.sp
Roger Dingledine [arma at mit\&.edu], Nick Mathewson [nickm at alum\&.mit\&.edu]\&.
stem-1.6.0/test/unit/util/ 0000775 0001750 0001750 00000000000 13177674754 016150 5 ustar atagar atagar 0000000 0000000 stem-1.6.0/test/unit/util/text_file 0000664 0001750 0001750 00000000525 13115423200 020022 0 ustar atagar atagar 0000000 0000000 I'm in magic and books,
with spooks and the crooks,
and forbidden lover's bliss
after a vine trellis kiss.
I might be open or closed,
often plain as your nose.
I'm a gift you can't take back,
and in the sharing I crack.
Authors place me in Prague
or the dense London fog
but I'm with people you meet
both the wicked and sweet.
stem-1.6.0/test/unit/util/conf.py 0000664 0001750 0001750 00000016336 13115423200 017422 0 ustar atagar atagar 0000000 0000000 """
Unit tests for the stem.util.conf class and functions.
"""
import unittest
import stem.util.conf
import stem.util.enum
from stem.util.conf import parse_enum, parse_enum_csv
class TestConf(unittest.TestCase):
def tearDown(self):
# clears the config contents
test_config = stem.util.conf.get_config('unit_testing')
test_config.clear()
test_config.clear_listeners()
def test_config_dict(self):
"""
Tests the config_dict function.
"""
my_config = {
'bool_value': False,
'int_value': 5,
'str_value': 'hello',
'list_value': [],
}
test_config = stem.util.conf.get_config('unit_testing')
# checks that sync causes existing contents to be applied
test_config.set('bool_value', 'true')
my_config = stem.util.conf.config_dict('unit_testing', my_config)
self.assertEqual(True, my_config['bool_value'])
# check a basic synchronize
test_config.set('str_value', 'me')
self.assertEqual('me', my_config['str_value'])
# synchronize with a type mismatch, should keep the old value
test_config.set('int_value', '7a')
self.assertEqual(5, my_config['int_value'])
# changes for a collection
test_config.set('list_value', 'a', False)
self.assertEqual(['a'], my_config['list_value'])
test_config.set('list_value', 'b', False)
self.assertEqual(['a', 'b'], my_config['list_value'])
test_config.set('list_value', 'c', False)
self.assertEqual(['a', 'b', 'c'], my_config['list_value'])
def test_parse_enum(self):
"""
Tests the parse_enum function.
"""
Insects = stem.util.enum.Enum('BUTTERFLY', 'LADYBUG', 'CRICKET')
self.assertEqual(Insects.LADYBUG, parse_enum('my_option', 'ladybug', Insects))
self.assertRaises(ValueError, parse_enum, 'my_option', 'ugabuga', Insects)
self.assertRaises(ValueError, parse_enum, 'my_option', 'ladybug, cricket', Insects)
def test_parse_enum_csv(self):
"""
Tests the parse_enum_csv function.
"""
Insects = stem.util.enum.Enum('BUTTERFLY', 'LADYBUG', 'CRICKET')
# check the case insensitivity
self.assertEqual([Insects.LADYBUG], parse_enum_csv('my_option', 'ladybug', Insects))
self.assertEqual([Insects.LADYBUG], parse_enum_csv('my_option', 'Ladybug', Insects))
self.assertEqual([Insects.LADYBUG], parse_enum_csv('my_option', 'LaDyBuG', Insects))
self.assertEqual([Insects.LADYBUG], parse_enum_csv('my_option', 'LADYBUG', Insects))
# various number of values
self.assertEqual([], parse_enum_csv('my_option', '', Insects))
self.assertEqual([Insects.LADYBUG], parse_enum_csv('my_option', 'ladybug', Insects))
self.assertEqual(
[Insects.LADYBUG, Insects.BUTTERFLY],
parse_enum_csv('my_option', 'ladybug, butterfly', Insects)
)
self.assertEqual(
[Insects.LADYBUG, Insects.BUTTERFLY, Insects.CRICKET],
parse_enum_csv('my_option', 'ladybug, butterfly, cricket', Insects)
)
# edge cases for count argument where things are ok
self.assertEqual(
[Insects.LADYBUG, Insects.BUTTERFLY],
parse_enum_csv('my_option', 'ladybug, butterfly', Insects, 2)
)
self.assertEqual(
[Insects.LADYBUG, Insects.BUTTERFLY],
parse_enum_csv('my_option', 'ladybug, butterfly', Insects, (1, 2))
)
self.assertEqual(
[Insects.LADYBUG, Insects.BUTTERFLY],
parse_enum_csv('my_option', 'ladybug, butterfly', Insects, (2, 3))
)
self.assertEqual(
[Insects.LADYBUG, Insects.BUTTERFLY],
parse_enum_csv('my_option', 'ladybug, butterfly', Insects, (2, 2))
)
# failure cases
self.assertRaises(ValueError, parse_enum_csv, 'my_option', 'ugabuga', Insects)
self.assertRaises(ValueError, parse_enum_csv, 'my_option', 'ladybug, ugabuga', Insects)
self.assertRaises(ValueError, parse_enum_csv, 'my_option', 'ladybug butterfly', Insects) # no comma
self.assertRaises(ValueError, parse_enum_csv, 'my_option', 'ladybug', Insects, 2)
self.assertRaises(ValueError, parse_enum_csv, 'my_option', 'ladybug', Insects, (2, 3))
def test_clear(self):
"""
Tests the clear method.
"""
test_config = stem.util.conf.get_config('unit_testing')
self.assertEqual([], list(test_config.keys()))
# tests clearing when we're already empty
test_config.clear()
self.assertEqual([], list(test_config.keys()))
# tests clearing when we have contents
test_config.set('hello', 'world')
self.assertEqual(['hello'], list(test_config.keys()))
test_config.clear()
self.assertEqual([], list(test_config.keys()))
def test_listeners(self):
"""
Tests the add_listener and clear_listeners methods.
"""
listener_received_keys = []
def test_listener(config, key):
self.assertEqual(config, stem.util.conf.get_config('unit_testing'))
listener_received_keys.append(key)
test_config = stem.util.conf.get_config('unit_testing')
test_config.add_listener(test_listener)
self.assertEqual([], listener_received_keys)
test_config.set('hello', 'world')
self.assertEqual(['hello'], listener_received_keys)
test_config.clear_listeners()
test_config.set('foo', 'bar')
self.assertEqual(['hello'], listener_received_keys)
def test_unused_keys(self):
"""
Tests the unused_keys method.
"""
test_config = stem.util.conf.get_config('unit_testing')
test_config.set('hello', 'world')
test_config.set('foo', 'bar')
test_config.set('pw', '12345')
test_config.get('hello')
test_config.get_value('foo')
self.assertEqual(set(['pw']), test_config.unused_keys())
test_config.get('pw')
self.assertEqual(set(), test_config.unused_keys())
def test_get(self):
"""
Tests the get and get_value methods.
"""
test_config = stem.util.conf.get_config('unit_testing')
test_config.set('bool_value', 'true')
test_config.set('int_value', '11')
test_config.set('float_value', '11.1')
test_config.set('str_value', 'world')
test_config.set('list_value', 'a', False)
test_config.set('list_value', 'b', False)
test_config.set('list_value', 'c', False)
test_config.set('map_value', 'foo => bar')
# check that we get the default for type mismatch or missing values
self.assertEqual(5, test_config.get('foo', 5))
self.assertEqual(5, test_config.get('bool_value', 5))
# checks that we get a string when no default is supplied
self.assertEqual('11', test_config.get('int_value'))
# exercise type casting for each of the supported types
self.assertEqual(True, test_config.get('bool_value', False))
self.assertEqual(11, test_config.get('int_value', 0))
self.assertEqual(11.1, test_config.get('float_value', 0.0))
self.assertEqual('world', test_config.get('str_value', ''))
self.assertEqual(['a', 'b', 'c'], test_config.get('list_value', []))
self.assertEqual(('a', 'b', 'c'), test_config.get('list_value', ()))
self.assertEqual({'foo': 'bar'}, test_config.get('map_value', {}))
# the get_value is similar, though only provides back a string or list
self.assertEqual('c', test_config.get_value('list_value'))
self.assertEqual(['a', 'b', 'c'], test_config.get_value('list_value', multiple = True))
self.assertEqual(None, test_config.get_value('foo'))
self.assertEqual('hello', test_config.get_value('foo', 'hello'))
stem-1.6.0/test/unit/util/term.py 0000664 0001750 0001750 00000002142 13115423200 017432 0 ustar atagar atagar 0000000 0000000 """
Unit tests for the stem.util.term functions.
"""
import unittest
import stem.util.term
from stem.util.term import Color, Attr
class TestTerminal(unittest.TestCase):
def test_encoding(self):
"""
Exercises our encoding function.
"""
self.assertEqual(None, stem.util.term.encoding())
self.assertEqual('\x1b[31m', stem.util.term.encoding(Color.RED))
self.assertEqual('\x1b[31;1m', stem.util.term.encoding(Color.RED, Attr.BOLD))
def test_format(self):
"""
Exercises our format function.
"""
self.assertEqual('hi!', stem.util.term.format('hi!'))
self.assertEqual('\x1b[31mhi!\x1b[0m', stem.util.term.format('hi!', Color.RED))
self.assertEqual('\x1b[31;1mhi!\x1b[0m', stem.util.term.format('hi!', Color.RED, Attr.BOLD))
self.assertEqual('\x1b[31mhi\nthere!\x1b[0m', stem.util.term.format('hi\nthere!', Color.RED))
self.assertEqual('\x1b[31mhi\x1b[0m\n\x1b[31mthere!\x1b[0m', stem.util.term.format('hi\nthere!', Color.RED, Attr.LINES))
self.assertEqual('\001\x1b[31m\002hi!\001\x1b[0m\002', stem.util.term.format('hi!', Color.RED, Attr.READLINE_ESCAPE))
stem-1.6.0/test/unit/util/__init__.py 0000664 0001750 0001750 00000000764 13165210535 020244 0 ustar atagar atagar 0000000 0000000 """
Unit tests for stem.util.* contents.
"""
import datetime
import time
import unittest
from stem.util import datetime_to_unix
__all__ = [
'conf',
'connection',
'enum',
'log',
'proc',
'str_tools',
'system',
'tor_tools',
]
class TestBaseUtil(unittest.TestCase):
def test_datetime_to_unix(self):
self.assertEqual(1344251971.0, datetime_to_unix(datetime.datetime(2012, 8, 6, 11, 19, 31)))
self.assertTrue((time.time() - datetime_to_unix(datetime.datetime.utcnow())) < 2)
stem-1.6.0/test/unit/util/enum.py 0000664 0001750 0001750 00000002635 13115423200 017436 0 ustar atagar atagar 0000000 0000000 """
Unit tests for the stem.util.enum class and functions.
"""
import unittest
import stem.util.enum
class TestEnum(unittest.TestCase):
def test_enum_examples(self):
"""
Checks that the pydoc examples are accurate.
"""
insects = stem.util.enum.Enum('ANT', 'WASP', 'LADYBUG', 'FIREFLY')
self.assertEqual('Ant', insects.ANT)
self.assertEqual(('Ant', 'Wasp', 'Ladybug', 'Firefly'), tuple(insects))
pets = stem.util.enum.Enum(('DOG', 'Skippy'), 'CAT', ('FISH', 'Nemo'))
self.assertEqual('Skippy', pets.DOG)
self.assertEqual('Cat', pets.CAT)
def test_uppercase_enum_example(self):
"""
Checks that the pydoc example for the UppercaseEnum constructor function is
accurate.
"""
runlevels = stem.util.enum.UppercaseEnum('DEBUG', 'INFO', 'NOTICE', 'WARN', 'ERROR')
self.assertEqual('DEBUG', runlevels.DEBUG)
def test_enum_methods(self):
"""
Exercises enumeration methods.
"""
insects = stem.util.enum.Enum('ANT', 'WASP', 'LADYBUG', 'FIREFLY')
# next method
self.assertEqual(insects.WASP, insects.next(insects.ANT))
self.assertEqual(insects.ANT, insects.next(insects.FIREFLY))
# previous method
self.assertEqual(insects.FIREFLY, insects.previous(insects.ANT))
self.assertEqual(insects.LADYBUG, insects.previous(insects.FIREFLY))
# keys method
self.assertEqual(['ANT', 'WASP', 'LADYBUG', 'FIREFLY'], list(insects.keys()))
stem-1.6.0/test/unit/util/system.py 0000664 0001750 0001750 00000044422 13176650724 020042 0 ustar atagar atagar 0000000 0000000 """
Unit tests for the stem.util.system functions. This works by mocking the
stem.util.system.call function to selectively exercise other functions. None of
these tests actually make system calls, use proc, or otherwise deal with the
system running the tests.
"""
import functools
import ntpath
import os
import posixpath
import tempfile
import unittest
from stem.util import str_type, system
try:
# added in python 3.3
from unittest.mock import Mock, patch
except ImportError:
from mock import Mock, patch
# Base responses for the pid_by_name tests. The 'success' and
# 'multiple_results' entries are filled in by tests.
GET_PID_BY_NAME_BASE_RESULTS = {
'success': [],
'multiple_results': [],
'malformed_data': ['bad data'],
'no_results': [],
'command_fails': None,
}
# testing output for system calls
GET_PID_BY_NAME_PS_BSD = [
' PID TT STAT TIME COMMAND',
' 1 ?? Ss 9:00.22 launchd',
' 10 ?? Ss 0:09.97 kextd',
' 11 ?? Ss 5:47.36 DirectoryService',
' 12 ?? Ss 3:01.44 notifyd']
GET_PID_BY_NAME_PS_BSD_MULTIPLE = [
' PID TT STAT TIME COMMAND',
' 1 ?? Ss 9:00.22 launchd',
' 10 ?? Ss 0:09.97 kextd',
' 41 ?? Ss 9:00.22 launchd']
GET_PID_BY_NAME_TASKLIST_RESULTS = [
'Image Name PID Session Name Session# Mem Usage',
'System Idle Process 0 Services 0 20 K',
'svchost.exe 872 Services 0 8,744 K',
'hpservice.exe 1112 Services 0 3,828 K',
'tor.exe 3712 Console 1 29,976 K',
'tor.exe 3713 Console 1 21,976 K',
'conhost.exe 3012 Console 1 4,652 K']
GET_PID_BY_PORT_NETSTAT_RESULTS = [
'Active Internet connections (only servers)',
'Proto Recv-Q Send-Q Local Address Foreign Address State PID/Program name',
'tcp 0 0 127.0.0.1:631 0.0.0.0:* LISTEN - ',
'tcp 0 0 127.0.0.1:9051 0.0.0.0:* LISTEN 1641/tor ',
'tcp6 0 0 ::1:631 :::* LISTEN - ',
'udp 0 0 0.0.0.0:5353 0.0.0.0:* - ',
'udp6 0 0 fe80::7ae4:ff:fe2f::123 :::* - ']
GET_PID_BY_PORT_SOCKSTAT_RESULTS = [
'_tor tor 4397 7 tcp4 51.64.7.84:9051 *:*',
'_tor tor 4397 12 tcp4 51.64.7.84:54011 80.3.121.7:9051',
'_tor tor 4397 15 tcp4 51.64.7.84:59374 7.42.1.102:9051']
GET_PID_BY_PORT_LSOF_RESULTS = [
'COMMAND PID USER FD TYPE DEVICE SIZE/OFF NODE NAME',
'tor 1745 atagar 6u IPv4 14229 0t0 TCP 127.0.0.1:9051 (LISTEN)',
'apache 329 atagar 6u IPv4 14229 0t0 TCP 127.0.0.1:80 (LISTEN)']
GET_BSD_JAIL_PATH_RESULTS = [
' JID IP Address Hostname Path',
' 1 10.0.0.2 tor-jail /usr/jails/tor-jail',
]
def mock_call(base_cmd, responses):
"""
Provides mocking for the system module's call function. There are a couple
ways of using this...
- Simple usage is for base_cmd is the system call we want to respond to and
responses is a list containing the respnose. For instance...
mock_call('ls my_dir', ['file1', 'file2', 'file3'])
- The base_cmd can be a formatted string and responses are a dictionary of
completions for tat string to the responses. For instance...
mock_call('ls %s', {'dir1': ['file1', 'file2'], 'dir2': ['file3', 'file4']})
:param str base_cmd: command to match against
:param list,dict responses: either list with the response, or mapping of
base_cmd formatted string completions to responses
:returns: **functor** to override stem.util.system.call with
"""
def _mock_call(base_cmd, responses, command, default = None):
if isinstance(responses, list):
if base_cmd == command:
return responses
else:
return default
else:
for cmd_completion in responses:
if command == base_cmd % cmd_completion:
return responses[cmd_completion]
return default
return functools.partial(_mock_call, base_cmd, responses)
class TestSystem(unittest.TestCase):
@patch('stem.util.system.call')
@patch('stem.util.system.is_available', Mock(return_value = True))
def test_is_running(self, call_mock):
"""
Exercises multiple use cases for the is_running function.
"""
# mock response with a linux and bsd resolver
running_commands = [str_type('irssi'), str_type('moc'), str_type('tor'),
str_type('ps'), str_type(' firefox ')]
for ps_cmd in (system.IS_RUNNING_PS_LINUX, system.IS_RUNNING_PS_BSD):
call_mock.side_effect = mock_call(ps_cmd, running_commands)
self.assertTrue(system.is_running('irssi'))
self.assertTrue(system.is_running('moc'))
self.assertTrue(system.is_running('tor'))
self.assertTrue(system.is_running(['funky-tor', 'tor']))
self.assertTrue(system.is_running('ps'))
self.assertTrue(system.is_running('firefox'))
self.assertFalse(system.is_running('something_else'))
self.assertFalse(system.is_running(['funky-tor', 'funkier-tor']))
# mock both calls failing
call_mock.return_value = None
call_mock.side_effect = None
self.assertFalse(system.is_running('irssi'))
self.assertEqual(None, system.is_running('irssi'))
def test_size_of(self):
"""
Exercises the size_of function.
"""
self.assertTrue(system.size_of('') < system.size_of('hello') < system.size_of('hello world'))
self.assertTrue(system.size_of([]) < system.size_of(['hello']) < system.size_of(['hello', 'world']))
self.assertTrue(system.size_of({}) < system.size_of({'hello': 'world'}) < system.size_of({'hello': 'world', 'more': 'stuff'}))
@patch('stem.util.system.call')
@patch('stem.util.proc.is_available', Mock(return_value = False))
@patch('stem.util.system.is_available', Mock(return_value = True))
def test_name_by_pid_ps(self, call_mock):
"""
Tests the name_by_pid function with ps responses.
"""
responses = {
'success': ['COMMAND', 'vim'],
'malformed_command_1': ['COMMAND'],
'malformed_command_2': ['foobar'],
'malformed_command_3': ['NOT_COMMAND', 'vim'],
'no_results': [],
'command_fails': None,
}
call_mock.side_effect = mock_call(system.GET_NAME_BY_PID_PS, responses)
for test_input in responses:
expected_response = 'vim' if test_input == 'success' else None
self.assertEqual(expected_response, system.name_by_pid(test_input))
@patch('stem.util.system.call')
@patch('stem.util.system.is_available', Mock(return_value = True))
@patch('stem.util.system.is_windows', Mock(return_value = False))
def test_pid_by_name_pgrep(self, call_mock):
"""
Tests the pid_by_name function with pgrep responses.
"""
responses = dict(GET_PID_BY_NAME_BASE_RESULTS)
responses['success'] = ['1111']
responses['multiple_results'] = ['123', '456', '789']
call_mock.side_effect = mock_call(system.GET_PID_BY_NAME_PGREP, responses)
for test_input in responses:
expected_response = 1111 if test_input == 'success' else None
self.assertEqual(expected_response, system.pid_by_name(test_input))
self.assertEqual([123, 456, 789], system.pid_by_name('multiple_results', multiple = True))
@patch('stem.util.system.call')
@patch('stem.util.system.is_available', Mock(return_value = True))
@patch('stem.util.system.is_windows', Mock(return_value = False))
def test_pid_by_name_pidof(self, call_mock):
"""
Tests the pid_by_name function with pidof responses.
"""
responses = dict(GET_PID_BY_NAME_BASE_RESULTS)
responses['success'] = ['1111']
responses['multiple_results'] = ['123 456 789']
call_mock.side_effect = mock_call(system.GET_PID_BY_NAME_PIDOF, responses)
for test_input in responses:
expected_response = 1111 if test_input == 'success' else None
self.assertEqual(expected_response, system.pid_by_name(test_input))
self.assertEqual([123, 456, 789], system.pid_by_name('multiple_results', multiple = True))
@patch('stem.util.system.call')
@patch('stem.util.system.is_bsd', Mock(return_value = False))
@patch('stem.util.system.is_windows', Mock(return_value = False))
@patch('stem.util.system.is_available', Mock(return_value = True))
def test_pid_by_name_ps_linux(self, call_mock):
"""
Tests the pid_by_name function with the linux variant of ps.
"""
responses = dict(GET_PID_BY_NAME_BASE_RESULTS)
responses['success'] = ['PID', ' 1111']
responses['multiple_results'] = ['PID', ' 123', ' 456', ' 789']
call_mock.side_effect = mock_call(system.GET_PID_BY_NAME_PS_LINUX, responses)
for test_input in responses:
expected_response = 1111 if test_input == 'success' else None
self.assertEqual(expected_response, system.pid_by_name(test_input))
self.assertEqual([123, 456, 789], system.pid_by_name('multiple_results', multiple = True))
@patch('stem.util.system.call')
@patch('stem.util.system.is_bsd', Mock(return_value = True))
@patch('stem.util.system.is_windows', Mock(return_value = False))
@patch('stem.util.system.is_available', Mock(return_value = True))
def test_pid_by_name_ps_bsd(self, call_mock):
"""
Tests the pid_by_name function with the bsd variant of ps.
"""
call_mock.side_effect = mock_call(system.GET_PID_BY_NAME_PS_BSD, GET_PID_BY_NAME_PS_BSD)
self.assertEqual(1, system.pid_by_name('launchd'))
self.assertEqual(11, system.pid_by_name('DirectoryService'))
self.assertEqual(None, system.pid_by_name('blarg'))
call_mock.side_effect = mock_call(system.GET_PID_BY_NAME_PS_BSD, GET_PID_BY_NAME_PS_BSD_MULTIPLE)
self.assertEqual([1, 41], system.pid_by_name('launchd', multiple = True))
@patch('stem.util.system.call')
@patch('stem.util.system.is_available', Mock(return_value = True))
@patch('stem.util.system.is_windows', Mock(return_value = False))
def test_pid_by_name_lsof(self, call_mock):
"""
Tests the pid_by_name function with lsof responses.
"""
responses = dict(GET_PID_BY_NAME_BASE_RESULTS)
responses['success'] = ['1111']
responses['multiple_results'] = ['123', '456', '789']
call_mock.side_effect = mock_call(system.GET_PID_BY_NAME_LSOF, responses)
for test_input in responses:
expected_response = 1111 if test_input == 'success' else None
self.assertEqual(expected_response, system.pid_by_name(test_input))
self.assertEqual([123, 456, 789], system.pid_by_name('multiple_results', multiple = True))
@patch('stem.util.system.call')
@patch('stem.util.system.is_available', Mock(return_value = True))
@patch('stem.util.system.is_windows', Mock(return_value = True))
def test_pid_by_name_tasklist(self, call_mock):
"""
Tests the pid_by_name function with tasklist responses.
"""
call_mock.side_effect = mock_call('tasklist', GET_PID_BY_NAME_TASKLIST_RESULTS)
self.assertEqual(3712, system.pid_by_name('tor'))
self.assertEqual(None, system.pid_by_name('DirectoryService'))
self.assertEqual(None, system.pid_by_name('blarg'))
self.assertEqual([3712, 3713], system.pid_by_name('tor', multiple = True))
@patch('stem.util.system.call')
@patch('stem.util.system.is_available', Mock(return_value = True))
def test_pid_by_port_netstat(self, call_mock):
"""
Tests the pid_by_port function with a netstat response.
"""
call_mock.side_effect = mock_call(system.GET_PID_BY_PORT_NETSTAT, GET_PID_BY_PORT_NETSTAT_RESULTS)
self.assertEqual(1641, system.pid_by_port(9051))
self.assertEqual(1641, system.pid_by_port('9051'))
self.assertEqual(None, system.pid_by_port(631))
self.assertEqual(None, system.pid_by_port(123))
@patch('stem.util.system.call')
@patch('stem.util.system.is_available', Mock(return_value = True))
def test_pid_by_port_sockstat(self, call_mock):
"""
Tests the pid_by_port function with a sockstat response.
"""
call_mock.side_effect = mock_call(system.GET_PID_BY_PORT_SOCKSTAT % 9051, GET_PID_BY_PORT_SOCKSTAT_RESULTS)
self.assertEqual(4397, system.pid_by_port(9051))
self.assertEqual(4397, system.pid_by_port('9051'))
self.assertEqual(None, system.pid_by_port(123))
@patch('stem.util.system.call')
@patch('stem.util.system.is_available', Mock(return_value = True))
def test_pid_by_port_lsof(self, call_mock):
"""
Tests the pid_by_port function with a lsof response.
"""
call_mock.side_effect = mock_call(system.GET_PID_BY_PORT_LSOF, GET_PID_BY_PORT_LSOF_RESULTS)
self.assertEqual(1745, system.pid_by_port(9051))
self.assertEqual(1745, system.pid_by_port('9051'))
self.assertEqual(329, system.pid_by_port(80))
self.assertEqual(None, system.pid_by_port(123))
@patch('stem.util.system.call')
@patch('stem.util.system.is_available', Mock(return_value = True))
def test_pid_by_open_file_lsof(self, call_mock):
"""
Tests the pid_by_open_file function with a lsof response.
"""
lsof_query = system.GET_PID_BY_FILE_LSOF % '/tmp/foo'
call_mock.side_effect = mock_call(lsof_query, ['4762'])
self.assertEqual(4762, system.pid_by_open_file('/tmp/foo'))
call_mock.return_value = []
call_mock.side_effect = None
self.assertEqual(None, system.pid_by_open_file('/tmp/somewhere_else'))
@patch('stem.util.system.call')
@patch('stem.util.proc.is_available', Mock(return_value = False))
@patch('stem.util.system.is_available', Mock(return_value = True))
def test_cwd_pwdx(self, call_mock):
"""
Tests the cwd function with a pwdx response.
"""
responses = {
'3799': ['3799: /home/atagar'],
'5839': ['5839: No such process'],
'1234': ['malformed output'],
'7878': None,
}
call_mock.side_effect = mock_call(system.GET_CWD_PWDX, responses)
for test_input in responses:
expected_response = '/home/atagar' if test_input == '3799' else None
self.assertEqual(expected_response, system.cwd(test_input))
@patch('stem.util.system.call')
@patch('stem.util.proc.is_available', Mock(return_value = False))
@patch('stem.util.system.is_available', Mock(return_value = True))
def test_cwd_lsof(self, call_mock):
"""
Tests the cwd function with a lsof response.
"""
responses = {
'75717': ['p75717', 'n/Users/atagar/tor/src/or'],
'75718': ['p75718', 'fcwd', 'n/Users/atagar/tor/src/or'],
'1234': ['malformed output'],
'7878': [],
}
call_mock.side_effect = mock_call(system.GET_CWD_LSOF, responses)
for test_input in responses:
expected_response = '/Users/atagar/tor/src/or' if test_input in ('75717', '75718') else None
self.assertEqual(expected_response, system.cwd(test_input))
def test_tail(self):
"""
Exercise our tail() function with a variety of inputs.
"""
path = os.path.join(os.path.dirname(__file__), 'text_file')
# by file handle
with open(path, 'rb') as riddle_file:
self.assertEqual([' both the wicked and sweet.'], list(system.tail(riddle_file, 1)))
self.assertEqual([], list(system.tail(path, 0)))
self.assertEqual([' both the wicked and sweet.'], list(system.tail(path, 1)))
self.assertEqual([' both the wicked and sweet.', "but I'm with people you meet"], list(system.tail(path, 2)))
self.assertEqual(14, len(list(system.tail(path))))
self.assertEqual(14, len(list(system.tail(path, 200))))
self.assertRaises(IOError, list, system.tail('/path/doesnt/exist'))
fd, temp_path = tempfile.mkstemp()
os.chmod(temp_path, 0o077) # remove read permissions
self.assertRaises(IOError, list, system.tail(temp_path))
os.close(fd)
os.remove(temp_path)
@patch('stem.util.system.call')
@patch('stem.util.system.is_available', Mock(return_value = True))
def test_bsd_jail_id(self, call_mock):
"""
Tests the bsd_jail_id function.
"""
responses = {
'1111': ['JID', ' 1'],
'2222': ['JID', ' 0'],
'3333': ['JID', 'bad data'],
'4444': ['bad data'],
'5555': [],
'6666': []
}
call_mock.side_effect = mock_call(system.GET_BSD_JAIL_ID_PS, responses)
for test_input in responses:
expected_response = 1 if test_input == '1111' else 0
self.assertEqual(expected_response, system.bsd_jail_id(test_input))
@patch('stem.util.system.call')
@patch('stem.util.system.is_available', Mock(return_value = True))
def test_bsd_jail_path(self, call_mock):
"""
Tests the bsd_jail_path function.
"""
# check when we don't have a jail
call_mock.return_value = []
self.assertEqual(None, system.bsd_jail_path(1))
call_mock.side_effect = mock_call(system.GET_BSD_JAIL_PATH % '1', GET_BSD_JAIL_PATH_RESULTS)
self.assertEqual('/usr/jails/tor-jail', system.bsd_jail_path(1))
@patch('platform.system', Mock(return_value = 'Linux'))
@patch('os.path.join', Mock(side_effect = posixpath.join))
def test_expand_path_unix(self):
"""
Tests the expand_path function. This does not exercise home directory
expansions since that deals with our environment (that's left to integ
tests).
"""
self.assertEqual('', system.expand_path(''))
self.assertEqual('/tmp', system.expand_path('/tmp'))
self.assertEqual('/tmp', system.expand_path('/tmp/'))
self.assertEqual('/tmp', system.expand_path('.', '/tmp'))
self.assertEqual('/tmp', system.expand_path('./', '/tmp'))
self.assertEqual('/tmp/foo', system.expand_path('foo', '/tmp'))
self.assertEqual('/tmp/foo', system.expand_path('./foo', '/tmp'))
@patch('platform.system', Mock(return_value = 'Windows'))
@patch('os.path.join', Mock(side_effect = ntpath.join))
def test_expand_path_windows(self):
"""
Tests the expand_path function on windows. This does not exercise
home directory expansions since that deals with our environment
(that's left to integ tests).
"""
self.assertEqual('', system.expand_path(''))
self.assertEqual('C:\\tmp', system.expand_path('C:\\tmp'))
self.assertEqual('C:\\tmp', system.expand_path('C:\\tmp\\'))
self.assertEqual('C:\\tmp', system.expand_path('.', 'C:\\tmp'))
self.assertEqual('C:\\tmp', system.expand_path('.\\', 'C:\\tmp'))
self.assertEqual('C:\\tmp\\foo', system.expand_path('foo', 'C:\\tmp'))
self.assertEqual('C:\\tmp\\foo', system.expand_path('.\\foo', 'C:\\tmp'))
stem-1.6.0/test/unit/util/str_tools.py 0000664 0001750 0001750 00000015752 13165210535 020540 0 ustar atagar atagar 0000000 0000000 """
Unit tests for the stem.util.str_tools functions.
"""
import datetime
import unittest
from stem.util import str_tools
class TestStrTools(unittest.TestCase):
def test_to_int(self):
"""
Checks the _to_int() function.
"""
test_inputs = {
'': 0,
'h': 104,
'hi': 26729,
'hello': 448378203247,
str_tools._to_bytes('hello'): 448378203247,
str_tools._to_unicode('hello'): 448378203247,
}
for arg, expected in test_inputs.items():
self.assertEqual(expected, str_tools._to_int(arg))
def test_to_camel_case(self):
"""
Checks the _to_camel_case() function.
"""
# test the pydoc example
self.assertEqual('I Like Pepperjack!', str_tools._to_camel_case('I_LIKE_PEPPERJACK!'))
# check a few edge cases
self.assertEqual('', str_tools._to_camel_case(''))
self.assertEqual('Hello', str_tools._to_camel_case('hello'))
self.assertEqual('Hello', str_tools._to_camel_case('HELLO'))
self.assertEqual('Hello World', str_tools._to_camel_case('hello__world'))
self.assertEqual('Hello\tworld', str_tools._to_camel_case('hello\tWORLD'))
self.assertEqual('Hello\t\tWorld', str_tools._to_camel_case('hello__world', '_', '\t'))
def test_split_by_length(self):
self.assertEqual(['h', 'e', 'l', 'l', 'o'], str_tools._split_by_length('hello', 1))
self.assertEqual(['he', 'll', 'o'], str_tools._split_by_length('hello', 2))
self.assertEqual(['hel', 'lo'], str_tools._split_by_length('hello', 3))
self.assertEqual(['hell', 'o'], str_tools._split_by_length('hello', 4))
self.assertEqual(['hello'], str_tools._split_by_length('hello', 5))
self.assertEqual(['hello'], str_tools._split_by_length('hello', 6))
def test_crop(self):
# test the pydoc examples
self.assertEqual('This is a looo...', str_tools.crop('This is a looooong message', 17))
self.assertEqual('This is a...', str_tools.crop('This is a looooong message', 12))
self.assertEqual('', str_tools.crop('This is a looooong message', 3))
self.assertEqual('', str_tools.crop('This is a looooong message', 0))
def test_size_label(self):
"""
Checks the size_label() function.
"""
# test the pydoc examples
self.assertEqual('1 MB', str_tools.size_label(2000000))
self.assertEqual('1.02 KB', str_tools.size_label(1050, 2))
self.assertEqual('1.025 Kilobytes', str_tools.size_label(1050, 3, True))
self.assertEqual('1 KB', str_tools.size_label(1050, 0, round = True))
self.assertEqual('1.0 KB', str_tools.size_label(1050, 1, round = True))
self.assertEqual('1.03 KB', str_tools.size_label(1050, 2, round = True))
self.assertEqual('1.025 KB', str_tools.size_label(1050, 3, round = True))
self.assertEqual('0 B', str_tools.size_label(0))
self.assertEqual('0 Bytes', str_tools.size_label(0, is_long = True))
self.assertEqual('0.00 B', str_tools.size_label(0, 2))
self.assertEqual('-10 B', str_tools.size_label(-10))
self.assertEqual('80 b', str_tools.size_label(10, is_bytes = False))
self.assertEqual('-1 MB', str_tools.size_label(-2000000))
# checking that we round down
self.assertEqual('23.43 Kb', str_tools.size_label(3000, 2, is_bytes = False))
self.assertRaises(TypeError, str_tools.size_label, None)
self.assertRaises(TypeError, str_tools.size_label, 'hello world')
def test_time_label(self):
"""
Checks the time_label() function.
"""
# test the pydoc examples
self.assertEqual('2h', str_tools.time_label(10000))
self.assertEqual('1.0 minute', str_tools.time_label(61, 1, True))
self.assertEqual('1.01 minutes', str_tools.time_label(61, 2, True))
self.assertEqual('0s', str_tools.time_label(0))
self.assertEqual('0 seconds', str_tools.time_label(0, is_long = True))
self.assertEqual('0.00s', str_tools.time_label(0, 2))
self.assertEqual('-10s', str_tools.time_label(-10))
self.assertRaises(TypeError, str_tools.time_label, None)
self.assertRaises(TypeError, str_tools.time_label, 'hello world')
def test_time_labels(self):
"""
Checks the time_labels() function.
"""
# test the pydoc examples
self.assertEqual(['6m', '40s'], str_tools.time_labels(400))
self.assertEqual(['1 hour', '40 seconds'], str_tools.time_labels(3640, True))
self.assertEqual([], str_tools.time_labels(0))
self.assertEqual(['-10s'], str_tools.time_labels(-10))
self.assertRaises(TypeError, str_tools.time_labels, None)
self.assertRaises(TypeError, str_tools.time_labels, 'hello world')
def test_short_time_label(self):
"""
Checks the short_time_label() function.
"""
# test the pydoc examples
self.assertEqual('01:51', str_tools.short_time_label(111))
self.assertEqual('6-07:08:20', str_tools.short_time_label(544100))
self.assertEqual('00:00', str_tools.short_time_label(0))
self.assertRaises(TypeError, str_tools.short_time_label, None)
self.assertRaises(TypeError, str_tools.short_time_label, 'hello world')
self.assertRaises(ValueError, str_tools.short_time_label, -5)
def test_parse_short_time_label(self):
"""
Checks the parse_short_time_label() function.
"""
# test the pydoc examples
self.assertEqual(111, str_tools.parse_short_time_label('01:51'))
self.assertEqual(544100, str_tools.parse_short_time_label('6-07:08:20'))
self.assertEqual(110, str_tools.parse_short_time_label('01:50.62'))
self.assertEqual(0, str_tools.parse_short_time_label('00:00'))
# these aren't technically valid, but might as well allow unnecessary
# digits to be dropped
self.assertEqual(300, str_tools.parse_short_time_label('05:0'))
self.assertEqual(300, str_tools.parse_short_time_label('5:00'))
self.assertRaises(TypeError, str_tools.parse_short_time_label, None)
self.assertRaises(TypeError, str_tools.parse_short_time_label, 100)
self.assertRaises(ValueError, str_tools.parse_short_time_label, 'blarg')
self.assertRaises(ValueError, str_tools.parse_short_time_label, '00')
self.assertRaises(ValueError, str_tools.parse_short_time_label, '05:')
self.assertRaises(ValueError, str_tools.parse_short_time_label, '05a:00')
self.assertRaises(ValueError, str_tools.parse_short_time_label, '-05:00')
def test_parse_iso_timestamp(self):
"""
Checks the _parse_iso_timestamp() function.
"""
test_inputs = {
'2012-11-08T16:48:41.420251':
datetime.datetime(2012, 11, 8, 16, 48, 41, 420251),
'2012-11-08T16:48:41.000000':
datetime.datetime(2012, 11, 8, 16, 48, 41, 0),
'2012-11-08T16:48:41':
datetime.datetime(2012, 11, 8, 16, 48, 41, 0),
}
for arg, expected in test_inputs.items():
self.assertEqual(expected, str_tools._parse_iso_timestamp(arg))
invalid_input = [
None,
32,
'boom',
'hello world',
'2012-11-08T16:48:41.42025', # too few microsecond digits
'2012-11-08T16:48:41.4202511', # too many microsecond digits
'2012-11-08T16:48',
]
for arg in invalid_input:
self.assertRaises(ValueError, str_tools._parse_iso_timestamp, arg)
stem-1.6.0/test/unit/util/connection.py 0000664 0001750 0001750 00000074101 13124757510 020644 0 ustar atagar atagar 0000000 0000000 """
Unit tests for the stem.util.connection functions.
"""
import platform
import unittest
import stem.util.connection
from stem.util.connection import Resolver, Connection
try:
# added in python 3.3
from unittest.mock import Mock, patch
except ImportError:
from mock import Mock, patch
NETSTAT_OUTPUT = """\
Active Internet connections (w/o servers)
Proto Recv-Q Send-Q Local Address Foreign Address State PID/Program name
tcp 0 0 192.168.0.1:5939 73.94.23.87:443 ESTABLISHED 20586/firefox
tcp 0 0 192.168.0.1:4325 73.94.23.55:443 ESTABLISHED 20586/firefox
tcp 1 0 192.168.0.1:4378 29.208.141.42:443 CLOSE_WAIT 20586/firefox
tcp 0 0 127.0.0.1:22 127.0.0.1:56673 ESTABLISHED -
tcp 0 586 192.168.0.1:44284 38.229.79.2:443 ESTABLISHED 15843/tor
tcp 0 0 192.168.0.1:37909 16.111.19.278:6697 ESTABLISHED -
Active UNIX domain sockets (w/o servers)
Proto RefCnt Flags Type State I-Node PID/Program name Path
unix 14 [ ] DGRAM 8433 - /dev/log
unix 3 [ ] STREAM CONNECTED 34164277 15843/tor
unix 3 [ ] STREAM CONNECTED 34164276 15843/tor
unix 3 [ ] STREAM CONNECTED 7951 -
"""
NETSTAT_IPV6_OUTPUT = """\
Active Internet connections (w/o servers)
Proto Recv-Q Send-Q Local Address Foreign Address State PID/Program name
tcp6 0 0 5.9.158.75:5222 80.171.220.248:48910 ESTABLISHED 9820/beam
tcp6 0 0 2a01:4f8:190:514a::2:443 2001:638:a000:4140::ffff:189:41046 ESTABLISHED 1904/tor
tcp6 0 0 5.9.158.75:5269 146.255.57.226:38703 ESTABLISHED 9820/beam
tcp6 0 0 2a01:4f8:190:514a::2:443 2001:858:2:2:aabb:0:563b:1526:38260 ESTABLISHED 1904/tor
tcp6 0 0 5.9.158.75:5222 80.171.220.248:48966 ESTABLISHED 9820/beam
"""
NETSTAT_WINDOWS_OUTPUT = """\
Active Connections
Proto Local Address Foreign Address State PID
TCP 0.0.0.0:135 0.0.0.0:0 LISTENING 852
TCP 0.0.0.0:445 0.0.0.0:0 LISTENING 4
TCP 0.0.0.0:902 0.0.0.0:0 LISTENING 2076
TCP 0.0.0.0:912 0.0.0.0:0 LISTENING 2076
TCP 192.168.0.1:44284 38.229.79.2:443 ESTABLISHED 15843
TCP 0.0.0.0:37782 0.0.0.0:0 LISTENING 4128
"""
SS_OUTPUT = """\
Netid State Recv-Q Send-Q Local Address:Port Peer Address:Port
tcp CLOSE-WAIT 1 0 192.168.0.1:43780 53.203.145.45:443 users:(("firefox",20586,118))
tcp ESTAB 55274 0 192.168.0.1:46136 196.153.236.35:80 users:(("firefox",20586,93))
tcp ESTAB 0 0 192.168.0.1:44092 23.112.135.72:443 users:(("tor",15843,10))
tcp ESTAB 0 0 127.0.0.1:22 127.0.0.1:56673
tcp ESTAB 0 0 192.168.0.1:44415 38.229.79.2:443 users:(("tor",15843,9))
"""
SS_IPV6_OUTPUT = """\
Netid State Recv-Q Send-Q Local Address:Port Peer Address:Port
tcp ESTAB 0 0 5.9.158.75:443 107.170.93.13:56159 users:(("tor",pid=25056,fd=997))
tcp ESTAB 0 0 5.9.158.75:443 159.203.97.91:37802 users:(("tor",pid=25056,fd=77))
tcp ESTAB 0 0 2a01:4f8:190:514a::2:443 2001:638:a000:4140::ffff:189:38556 users:(("tor",pid=25056,fd=3175))
tcp ESTAB 0 0 ::ffff:5.9.158.75:5222 ::ffff:78.54.131.65:34950 users:(("beam",pid=1712,fd=29))
tcp ESTAB 0 0 2a01:4f8:190:514a::2:443 2001:858:2:2:aabb:0:563b:1526:51428 users:(("tor",pid=25056,fd=3248))
tcp ESTAB 0 0 ::ffff:5.9.158.75:5222 ::ffff:78.54.131.65:34882 users:(("beam",pid=1712,fd=26))
"""
LSOF_OUTPUT = """\
COMMAND PID USER FD TYPE DEVICE SIZE/OFF NODE NAME
ubuntu-ge 2164 atagar 11u IPv4 13593 0t0 TCP 192.168.0.1:55395->21.89.91.78:80 (CLOSE_WAIT)
tor 15843 atagar 6u IPv4 34164278 0t0 TCP 127.0.0.1:9050 (LISTEN)
tor 15843 atagar 7u IPv4 34164279 0t0 TCP 127.0.0.1:9051 (LISTEN)
tor 15843 atagar 9u IPv4 34188132 0t0 TCP 192.168.0.1:44415->38.229.79.2:443 (ESTABLISHED)
tor 15843 atagar 10u IPv4 34165291 0t0 TCP 192.168.0.1:44092->68.169.35.102:443 (ESTABLISHED)
python 16422 atagar 3u IPv4 34203773 0t0 UDP 127.0.0.1:39624->127.0.0.1:53
firefox 20586 atagar 66u IPv4 5765353 0t0 TCP 192.168.0.1:47486->62.135.16.134:443 (ESTABLISHED)
firefox 20586 atagar 71u IPv4 13094989 0t0 TCP 192.168.0.1:43762->182.3.10.42:443 (CLOSE_WAIT)
"""
LSOF_IPV6_OUTPUT = """\
COMMAND PID USER FD TYPE DEVICE SIZE/OFF NODE NAME
ntpd 1818 root 20u IPv6 530 0t0 UDP [::1]:123
ntpd 1818 root 21u IPv6 532 0t0 UDP [2a01:4f8:190:514a::2]:123
ntpd 1818 root 22u IPv6 534 0t0 UDP [fe80::3285:a9ff:feed:1cb]:123
tor 1904 tor 10u IPv6 4372 0t0 TCP [2a01:4f8:190:514a::2]:443 (LISTEN)
tor 1904 tor 3228u IPv6 10303350 0t0 TCP [2a01:4f8:190:514a::2]:443->[2001:858:2:2:aabb:0:563b:1526]:44811 (ESTABLISHED)
"""
LSOF_OUTPUT_OSX = """\
tor 129 atagar 4u IPv4 0xffffff3527af0500 0t0 TCP 127.0.0.1:9051 (LISTEN)
tor 129 atagar 5u IPv4 0xffffff363af9de40 0t0 TCP 192.168.1.10:9090 (LISTEN)
tor 129 atagar 6u IPv4 0xffffff306a960a40 0t0 TCP 192.168.1.10:9091 (LISTEN)
tor 129 atagar 8u IPv6 0xffffff13f5575a98 0t0 UDP *:48718
tor 129 atagar 9u IPv6 0xffffff1b2273a178 0t0 UDP *:48714
tor 129 atagar 10u IPv6 0xffffff1b473a9758 0t0 UDP *:48716
tor 129 atagar 11u IPv6 0xffffff1b5733aa48 0t0 UDP *:48719
tor 129 atagar 12u IPv4 0xffffff1cc6dd0160 0t0 TCP 192.168.1.20:9090->38.229.79.2:14010 (ESTABLISHED)
tor 129 atagar 22u IPv4 0xffffff35c9125500 0t0 TCP 192.168.1.20:9090->68.169.35.102:14815 (ESTABLISHED)
tor 129 atagar 23u IPv4 0xffffff3236168160 0t0 TCP 192.168.1.20:9090->62.135.16.134:14456 (ESTABLISHED)
"""
SOCKSTAT_OUTPUT = """\
USER PROCESS PID PROTO SOURCE ADDRESS FOREIGN ADDRESS STATE
atagar ubuntu-geoip-pr 2164 tcp4 192.168.0.1:55395 141.18.34.33:80 CLOSE_WAIT
atagar tor 15843 tcp4 127.0.0.1:9050 *:* LISTEN
atagar tor 15843 tcp4 127.0.0.1:9051 *:* LISTEN
atagar tor 15843 tcp4 192.168.0.1:44415 38.229.79.2:443 ESTABLISHED
atagar tor 15843 tcp4 192.168.0.1:44092 68.169.35.102:443 ESTABLISHED
atagar firefox 20586 tcp4 192.168.0.1:47486 213.24.100.160:443 ESTABLISHED
atagar firefox 20586 tcp4 192.168.0.1:43762 32.188.221.72:443 CLOSE_WAIT
"""
# I don't have actual sockstat and procstat output for FreeBSD. Rather, these
# are snippets of output from email threads.
BSD_SOCKSTAT_OUTPUT = """\
_tor tor 4397 7 tcp4 172.27.72.202:9050 *:*
_tor tor 4397 8 udp4 172.27.72.202:53 *:*
_tor tor 4397 9 tcp4 172.27.72.202:9051 *:*
_tor tor 4397 12 tcp4 172.27.72.202:54011 38.229.79.2:9001
_tor tor 4397 15 tcp4 172.27.72.202:59374 68.169.35.102:9001
_tor tor 4397 19 tcp4 172.27.72.202:59673 213.24.100.160:9001
_tor tor 4397 20 tcp4 172.27.72.202:51946 32.188.221.72:443
_tor tor 4397 22 tcp4 172.27.72.202:60344 21.89.91.78:9001
"""
BSD_PROCSTAT_OUTPUT = """\
PID COMM FD T V FLAGS REF OFFSET PRO NAME
3561 tor 4 s - rw---n-- 2 0 TCP 10.0.0.2:9050 10.0.0.1:22370
3561 tor 5 s - rw---n-- 2 0 TCP 10.0.0.2:9050 0.0.0.0:0
3561 tor 6 s - rw---n-- 2 0 TCP 10.0.0.2:9040 0.0.0.0:0
3561 tor 7 s - rw---n-- 2 0 UDP 10.0.0.2:53 0.0.0.0:0
3561 tor 8 s - rw---n-- 2 0 TCP 10.0.0.2:9051 0.0.0.0:0
3561 tor 14 s - rw---n-- 2 0 TCP 10.0.0.2:9050 10.0.0.1:44381
3561 tor 15 s - rw---n-- 2 0 TCP 10.0.0.2:33734 38.229.79.2:443
3561 tor 16 s - rw---n-- 2 0 TCP 10.0.0.2:47704 68.169.35.102:9001
"""
BSD_FSTAT_OUTPUT = """\
USER CMD PID FD MOUNT INUM MODE R/W SZ|DV
_tor tor 15843 text /usr/local 207875 -rwxr-xr-x r 2421008
_tor tor 15843 wd /var 623616 drwx------ r 512
_tor tor 15843 0 / 1160 crw-rw-rw- rw null
_tor tor 15843 1 / 1160 crw-rw-rw- rw null
_tor tor 15843 2 / 1160 crw-rw-rw- rw null
_tor tor 15843 3 kqueue 0x0 0 state: W
_tor tor 15843 4* internet dgram udp *:6063
_tor tor 15843 5* internet stream tcp 0x0 127.0.0.1:8443
_tor tor 15843 6* internet stream tcp 0x0 127.0.0.1:8080
_tor tor 15843 7 /var 623617 -rw------- rwe 0
_tor tor 15843 8* internet dgram udp *:19515
_tor tor 15843 9* internet dgram udp *:43052
_tor tor 15843 10 pipe 0x0 state:
_tor tor 15843 11 pipe 0x0 state:
_tor tor 15843 12* internet stream tcp 0x0 127.0.0.1:8443 <-- 1.2.3.4:54581
_tor tor 15843 20* internet stream tcp 0x0 192.168.1.100:36174 --> 4.3.2.1:443
"""
class TestConnection(unittest.TestCase):
@patch('os.access')
@patch('stem.util.system.is_available')
@patch('stem.util.proc.is_available')
def test_system_resolvers(self, proc_mock, is_available_mock, os_mock):
"""
Checks the system_resolvers function.
"""
is_available_mock.return_value = True
proc_mock.return_value = False
os_mock.return_value = True
self.assertEqual([Resolver.NETSTAT_WINDOWS], stem.util.connection.system_resolvers('Windows'))
self.assertEqual([Resolver.LSOF], stem.util.connection.system_resolvers('Darwin'))
self.assertEqual([Resolver.BSD_FSTAT], stem.util.connection.system_resolvers('OpenBSD'))
self.assertEqual([Resolver.BSD_SOCKSTAT, Resolver.BSD_PROCSTAT, Resolver.LSOF], stem.util.connection.system_resolvers('FreeBSD'))
self.assertEqual([Resolver.NETSTAT, Resolver.SOCKSTAT, Resolver.LSOF, Resolver.SS], stem.util.connection.system_resolvers('Linux'))
proc_mock.return_value = True
self.assertEqual([Resolver.PROC, Resolver.NETSTAT, Resolver.SOCKSTAT, Resolver.LSOF, Resolver.SS], stem.util.connection.system_resolvers('Linux'))
# check that calling without an argument is equivalent to calling for this
# platform
self.assertEqual(stem.util.connection.system_resolvers(platform.system()), stem.util.connection.system_resolvers())
# check that lacking commands in our PATH drops them from the results
is_available_mock.return_value = False
self.assertEqual([Resolver.PROC], stem.util.connection.system_resolvers('Linux'))
def test_port_usage(self):
"""
Check that port_usage can load our config and provide the expected results.
"""
self.assertEqual('HTTP', stem.util.connection.port_usage(80))
self.assertEqual('HTTP', stem.util.connection.port_usage('80')) # query with a string
self.assertEqual('BitTorrent', stem.util.connection.port_usage(6881)) # min and max value of a range
self.assertEqual('BitTorrent', stem.util.connection.port_usage(6999))
self.assertEqual(None, stem.util.connection.port_usage(30000)) # unrecognized port
@patch('stem.util.proc.connections')
def test_get_connections_by_proc(self, proc_mock):
"""
Checks the get_connections function with the proc resolver.
"""
proc_mock.return_value = [
('17.17.17.17', 4369, '34.34.34.34', 8738, 'tcp', False),
('187.187.187.187', 48059, '204.204.204.204', 52428, 'tcp', False),
]
expected = [
Connection('17.17.17.17', 4369, '34.34.34.34', 8738, 'tcp', False),
Connection('187.187.187.187', 48059, '204.204.204.204', 52428, 'tcp', False),
]
self.assertEqual(expected, stem.util.connection.get_connections(Resolver.PROC, process_pid = 1111))
proc_mock.side_effect = IOError('No connections for you!')
self.assertRaises(IOError, stem.util.connection.get_connections, Resolver.PROC, process_pid = 1111)
@patch('stem.util.system.call')
def test_get_connections_by_netstat(self, call_mock):
"""
Checks the get_connections function with the netstat resolver.
"""
call_mock.return_value = NETSTAT_OUTPUT.split('\n')
expected = [Connection('192.168.0.1', 44284, '38.229.79.2', 443, 'tcp', False)]
self.assertEqual(expected, stem.util.connection.get_connections(Resolver.NETSTAT, process_pid = 15843, process_name = 'tor'))
self.assertRaises(IOError, stem.util.connection.get_connections, Resolver.NETSTAT, process_pid = 15843, process_name = 'stuff')
self.assertRaises(IOError, stem.util.connection.get_connections, Resolver.NETSTAT, process_pid = 1111, process_name = 'tor')
call_mock.side_effect = OSError('Unable to call netstat')
self.assertRaises(IOError, stem.util.connection.get_connections, Resolver.NETSTAT, process_pid = 1111)
@patch('stem.util.system.call', Mock(return_value = NETSTAT_IPV6_OUTPUT.split('\n')))
def test_get_connections_by_netstat_ipv6(self):
"""
Checks the get_connections function with the netstat resolver for IPv6.
"""
expected = [
Connection('2a01:4f8:190:514a::2', 443, '2001:638:a000:4140::ffff:189', 41046, 'tcp', True),
Connection('2a01:4f8:190:514a::2', 443, '2001:858:2:2:aabb:0:563b:1526', 38260, 'tcp', True),
]
self.assertEqual(expected, stem.util.connection.get_connections(Resolver.NETSTAT, process_pid = 1904, process_name = 'tor'))
@patch('stem.util.system.call')
def test_get_connections_by_windows_netstat(self, call_mock):
"""
Checks the get_connections function with the Windows netstat resolver.
"""
call_mock.return_value = NETSTAT_WINDOWS_OUTPUT.split('\n')
expected = [Connection('192.168.0.1', 44284, '38.229.79.2', 443, 'tcp', False)]
self.assertEqual(expected, stem.util.connection.get_connections(Resolver.NETSTAT_WINDOWS, process_pid = 15843, process_name = 'tor'))
self.assertRaises(IOError, stem.util.connection.get_connections, Resolver.NETSTAT_WINDOWS, process_pid = 1111, process_name = 'tor')
call_mock.side_effect = OSError('Unable to call netstat')
self.assertRaises(IOError, stem.util.connection.get_connections, Resolver.NETSTAT_WINDOWS, process_pid = 1111)
@patch('stem.util.system.call')
def test_get_connections_by_ss(self, call_mock):
"""
Checks the get_connections function with the ss resolver.
"""
call_mock.return_value = SS_OUTPUT.split('\n')
expected = [
Connection('192.168.0.1', 44092, '23.112.135.72', 443, 'tcp', False),
Connection('192.168.0.1', 44415, '38.229.79.2', 443, 'tcp', False),
]
self.assertEqual(expected, stem.util.connection.get_connections(Resolver.SS, process_pid = 15843, process_name = 'tor'))
self.assertRaises(IOError, stem.util.connection.get_connections, Resolver.SS, process_pid = 15843, process_name = 'stuff')
self.assertRaises(IOError, stem.util.connection.get_connections, Resolver.SS, process_pid = 1111, process_name = 'tor')
call_mock.side_effect = OSError('Unable to call ss')
self.assertRaises(IOError, stem.util.connection.get_connections, Resolver.SS, process_pid = 1111)
@patch('stem.util.system.call', Mock(return_value = SS_IPV6_OUTPUT.split('\n')))
def test_get_connections_by_ss_ipv6(self):
"""
Checks the get_connections function with the ss resolver results on IPv6
conections. This also checks with the output from a hardened Gentoo system
which has subtle differences...
https://trac.torproject.org/projects/tor/ticket/18079
"""
expected = [
Connection('5.9.158.75', 443, '107.170.93.13', 56159, 'tcp', False),
Connection('5.9.158.75', 443, '159.203.97.91', 37802, 'tcp', False),
Connection('2a01:4f8:190:514a::2', 443, '2001:638:a000:4140::ffff:189', 38556, 'tcp', True),
Connection('2a01:4f8:190:514a::2', 443, '2001:858:2:2:aabb:0:563b:1526', 51428, 'tcp', True),
]
self.assertEqual(expected, stem.util.connection.get_connections(Resolver.SS, process_pid = 25056, process_name = 'tor'))
self.assertEqual(2, len(stem.util.connection.get_connections(Resolver.SS, process_name = 'beam')))
@patch('stem.util.system.call')
def test_get_connections_by_lsof(self, call_mock):
"""
Checks the get_connections function with the lsof resolver.
"""
call_mock.return_value = LSOF_OUTPUT.split('\n')
expected = [
Connection('192.168.0.1', 44415, '38.229.79.2', 443, 'tcp', False),
Connection('192.168.0.1', 44092, '68.169.35.102', 443, 'tcp', False),
]
self.assertEqual(expected, stem.util.connection.get_connections(Resolver.LSOF, process_pid = 15843, process_name = 'tor'))
self.assertRaises(IOError, stem.util.connection.get_connections, Resolver.LSOF, process_pid = 15843, process_name = 'stuff')
self.assertRaises(IOError, stem.util.connection.get_connections, Resolver.LSOF, process_pid = 1111, process_name = 'tor')
call_mock.side_effect = OSError('Unable to call lsof')
self.assertRaises(IOError, stem.util.connection.get_connections, Resolver.LSOF, process_pid = 1111)
@patch('stem.util.system.call', Mock(return_value = LSOF_IPV6_OUTPUT.split('\n')))
def test_get_connections_by_lsof_ipv6(self):
"""
Checks the get_connections function with the lsof resolver for IPv6.
"""
expected = [Connection('2a01:4f8:190:514a::2', 443, '2001:858:2:2:aabb:0:563b:1526', 44811, 'tcp', True)]
self.assertEqual(expected, stem.util.connection.get_connections(Resolver.LSOF, process_pid = 1904, process_name = 'tor'))
@patch('stem.util.system.call', Mock(return_value = LSOF_OUTPUT_OSX.split('\n')))
def test_get_connections_by_lsof_osx(self):
"""
Checks the get_connections function with the lsof resolver on OSX. This
only includes entries for the tor process.
"""
expected = [
Connection('192.168.1.20', 9090, '38.229.79.2', 14010, 'tcp', False),
Connection('192.168.1.20', 9090, '68.169.35.102', 14815, 'tcp', False),
Connection('192.168.1.20', 9090, '62.135.16.134', 14456, 'tcp', False),
]
self.assertEqual(expected, stem.util.connection.get_connections(Resolver.LSOF, process_pid = 129, process_name = 'tor'))
@patch('stem.util.system.call')
def test_get_connections_by_sockstat(self, call_mock):
"""
Checks the get_connections function with the sockstat resolver.
"""
call_mock.return_value = SOCKSTAT_OUTPUT.split('\n')
expected = [
Connection('192.168.0.1', 44415, '38.229.79.2', 443, 'tcp', False),
Connection('192.168.0.1', 44092, '68.169.35.102', 443, 'tcp', False),
]
self.assertEqual(expected, stem.util.connection.get_connections(Resolver.SOCKSTAT, process_pid = 15843, process_name = 'tor'))
self.assertRaises(IOError, stem.util.connection.get_connections, Resolver.SOCKSTAT, process_pid = 15843, process_name = 'stuff')
self.assertRaises(IOError, stem.util.connection.get_connections, Resolver.SOCKSTAT, process_pid = 1111, process_name = 'tor')
call_mock.side_effect = OSError('Unable to call sockstat')
self.assertRaises(IOError, stem.util.connection.get_connections, Resolver.SOCKSTAT, process_pid = 1111)
@patch('stem.util.system.call')
def test_get_connections_by_sockstat_for_bsd(self, call_mock):
"""
Checks the get_connections function with the bsd variant of the sockstat
resolver.
"""
call_mock.return_value = BSD_SOCKSTAT_OUTPUT.split('\n')
expected = [
Connection('172.27.72.202', 54011, '38.229.79.2', 9001, 'tcp', False),
Connection('172.27.72.202', 59374, '68.169.35.102', 9001, 'tcp', False),
Connection('172.27.72.202', 59673, '213.24.100.160', 9001, 'tcp', False),
Connection('172.27.72.202', 51946, '32.188.221.72', 443, 'tcp', False),
Connection('172.27.72.202', 60344, '21.89.91.78', 9001, 'tcp', False),
]
self.assertEqual(expected, stem.util.connection.get_connections(Resolver.BSD_SOCKSTAT, process_pid = 4397, process_name = 'tor'))
self.assertRaises(IOError, stem.util.connection.get_connections, Resolver.BSD_SOCKSTAT, process_pid = 4397, process_name = 'stuff')
self.assertRaises(IOError, stem.util.connection.get_connections, Resolver.BSD_SOCKSTAT, process_pid = 1111, process_name = 'tor')
call_mock.side_effect = OSError('Unable to call sockstat')
self.assertRaises(IOError, stem.util.connection.get_connections, Resolver.BSD_SOCKSTAT, process_pid = 1111)
@patch('stem.util.system.call')
def test_get_connections_by_procstat(self, call_mock):
"""
Checks the get_connections function with the procstat resolver.
"""
call_mock.return_value = BSD_PROCSTAT_OUTPUT.split('\n')
expected = [
Connection('10.0.0.2', 9050, '10.0.0.1', 22370, 'tcp', False),
Connection('10.0.0.2', 9050, '10.0.0.1', 44381, 'tcp', False),
Connection('10.0.0.2', 33734, '38.229.79.2', 443, 'tcp', False),
Connection('10.0.0.2', 47704, '68.169.35.102', 9001, 'tcp', False),
]
self.assertEqual(expected, stem.util.connection.get_connections(Resolver.BSD_PROCSTAT, process_pid = 3561, process_name = 'tor'))
self.assertRaises(IOError, stem.util.connection.get_connections, Resolver.BSD_PROCSTAT, process_pid = 3561, process_name = 'stuff')
self.assertRaises(IOError, stem.util.connection.get_connections, Resolver.BSD_PROCSTAT, process_pid = 1111, process_name = 'tor')
call_mock.side_effect = OSError('Unable to call procstat')
self.assertRaises(IOError, stem.util.connection.get_connections, Resolver.BSD_PROCSTAT, process_pid = 1111)
@patch('stem.util.system.call')
def test_get_connections_by_fstat(self, call_mock):
"""
Checks the get_connections function with the fstat resolver.
"""
call_mock.return_value = BSD_FSTAT_OUTPUT.split('\n')
expected = [
Connection('127.0.0.1', 8443, '1.2.3.4', 54581, 'tcp', False),
Connection('192.168.1.100', 36174, '4.3.2.1', 443, 'tcp', False),
]
self.assertEqual(expected, stem.util.connection.get_connections(Resolver.BSD_FSTAT, process_pid = 15843, process_name = 'tor'))
self.assertRaises(IOError, stem.util.connection.get_connections, Resolver.BSD_FSTAT, process_pid = 15843, process_name = 'stuff')
self.assertRaises(IOError, stem.util.connection.get_connections, Resolver.BSD_FSTAT, process_pid = 1111, process_name = 'tor')
call_mock.side_effect = OSError('Unable to call fstat')
self.assertRaises(IOError, stem.util.connection.get_connections, Resolver.BSD_FSTAT, process_pid = 1111)
def test_is_valid_ipv4_address(self):
"""
Checks the is_valid_ipv4_address function.
"""
valid_addresses = (
'0.0.0.0',
'1.2.3.4',
'192.168.0.1',
'255.255.255.255',
)
invalid_addresses = (
'0.0.00.0',
'0.0.0',
'1.2.3.256',
'1.2.3.-1',
'0.0.0.a',
'a.b.c.d',
)
for address in valid_addresses:
self.assertTrue(stem.util.connection.is_valid_ipv4_address(address))
for address in invalid_addresses:
self.assertFalse(stem.util.connection.is_valid_ipv4_address(address))
def test_is_valid_ipv6_address(self):
"""
Checks the is_valid_ipv6_address function.
"""
valid_addresses = (
'fe80:0000:0000:0000:0202:b3ff:fe1e:8329',
'fe80:0:0:0:202:b3ff:fe1e:8329',
'fe80::202:b3ff:fe1e:8329',
'::ffff:5.9.158.75',
'5.9.158.75::ffff',
'::5.9.158.75:ffff',
'::',
)
invalid_addresses = (
'fe80:0000:0000:0000:0202:b3ff:fe1e:829g',
'fe80:0000:0000:0000:0202:b3ff:fe1e: 8329',
'2001:db8::aaaa::1',
'::ffff:5.9.158.75.12',
'::ffff:5.9.158',
'::ffff:5.9',
':::',
':',
'',
)
for address in valid_addresses:
self.assertTrue(stem.util.connection.is_valid_ipv6_address(address), "%s isn't a valid IPv6 address" % address)
for address in invalid_addresses:
self.assertFalse(stem.util.connection.is_valid_ipv6_address(address), '%s should be an invalid IPv6 address' % address)
def test_is_valid_port(self):
"""
Checks the is_valid_port function.
"""
valid_ports = (1, '1', 1234, '1234', 65535, '65535', [1, '2'])
invalid_ports = (0, '0', 65536, '65536', 'abc', '*', ' 15', '01', True, {})
for port in valid_ports:
self.assertTrue(stem.util.connection.is_valid_port(port))
for port in invalid_ports:
self.assertFalse(stem.util.connection.is_valid_port(port))
self.assertTrue(stem.util.connection.is_valid_port(0, allow_zero = True))
self.assertTrue(stem.util.connection.is_valid_port('0', allow_zero = True))
def test_is_private_address(self):
"""
Checks the is_private_address function.
"""
self.assertTrue(stem.util.connection.is_private_address('127.0.0.1'))
self.assertTrue(stem.util.connection.is_private_address('10.0.0.0'))
self.assertTrue(stem.util.connection.is_private_address('172.16.0.0'))
self.assertTrue(stem.util.connection.is_private_address('172.31.0.0'))
self.assertTrue(stem.util.connection.is_private_address('192.168.0.50'))
self.assertFalse(stem.util.connection.is_private_address('74.125.28.103'))
self.assertFalse(stem.util.connection.is_private_address('172.15.0.0'))
self.assertFalse(stem.util.connection.is_private_address('172.32.0.0'))
self.assertRaises(ValueError, stem.util.connection.is_private_address, '')
self.assertRaises(ValueError, stem.util.connection.is_private_address, 'blarg')
self.assertRaises(ValueError, stem.util.connection.is_private_address, '127.0.0')
self.assertRaises(ValueError, stem.util.connection.is_private_address, 'fe80:0000:0000:0000:0202:b3ff:fe1e:8329')
def test_address_to_int(self):
"""
Checks the address_to_int function.
"""
self.assertEqual(1, stem.util.connection.address_to_int('0.0.0.1'))
self.assertEqual(2, stem.util.connection.address_to_int('0.0.0.2'))
self.assertEqual(256, stem.util.connection.address_to_int('0.0.1.0'))
self.assertEqual(2130706433, stem.util.connection.address_to_int('127.0.0.1'))
self.assertEqual(338288524927261089654163772891438416681, stem.util.connection.address_to_int('fe80:0000:0000:0000:0202:b3ff:fe1e:8329'))
def test_expand_ipv6_address(self):
"""
Checks the expand_ipv6_address function.
"""
test_values = {
'2001:db8::ff00:42:8329': '2001:0db8:0000:0000:0000:ff00:0042:8329',
'::': '0000:0000:0000:0000:0000:0000:0000:0000',
'::1': '0000:0000:0000:0000:0000:0000:0000:0001',
'1::1': '0001:0000:0000:0000:0000:0000:0000:0001',
'::ffff:5.9.158.75': '0000:0000:0000:0000:0000:ffff:0509:9e4b',
'5.9.158.75::ffff': '0509:9e4b:0000:0000:0000:0000:0000:ffff',
'::5.9.158.75:ffff': '0000:0000:0000:0000:0000:0509:9e4b:ffff',
}
for test_arg, expected in test_values.items():
self.assertEqual(expected, stem.util.connection.expand_ipv6_address(test_arg))
self.assertRaises(ValueError, stem.util.connection.expand_ipv6_address, '127.0.0.1')
def test_get_mask_ipv4(self):
"""
Checks the get_mask_ipv4 function.
"""
self.assertEqual('255.255.255.255', stem.util.connection.get_mask_ipv4(32))
self.assertEqual('255.255.255.248', stem.util.connection.get_mask_ipv4(29))
self.assertEqual('255.255.254.0', stem.util.connection.get_mask_ipv4(23))
self.assertEqual('0.0.0.0', stem.util.connection.get_mask_ipv4(0))
self.assertRaises(ValueError, stem.util.connection.get_mask_ipv4, -1)
self.assertRaises(ValueError, stem.util.connection.get_mask_ipv4, 33)
def test_get_mask_ipv6(self):
"""
Checks the get_mask_ipv6 function.
"""
self.assertEqual('FFFF:FFFF:FFFF:FFFF:FFFF:FFFF:FFFF:FFFF', stem.util.connection.get_mask_ipv6(128))
self.assertEqual('FFFF:FFFF:FFFF:FFFF:FFFF:FFFF:FFFE:0000', stem.util.connection.get_mask_ipv6(111))
self.assertEqual('0000:0000:0000:0000:0000:0000:0000:0000', stem.util.connection.get_mask_ipv6(0))
self.assertRaises(ValueError, stem.util.connection.get_mask_ipv6, -1)
self.assertRaises(ValueError, stem.util.connection.get_mask_ipv6, 129)
def test_get_masked_bits(self):
"""
Checks the _get_masked_bits function.
"""
self.assertEqual(32, stem.util.connection._get_masked_bits('255.255.255.255'))
self.assertEqual(29, stem.util.connection._get_masked_bits('255.255.255.248'))
self.assertEqual(23, stem.util.connection._get_masked_bits('255.255.254.0'))
self.assertEqual(0, stem.util.connection._get_masked_bits('0.0.0.0'))
self.assertRaises(ValueError, stem.util.connection._get_masked_bits, 'blarg')
self.assertRaises(ValueError, stem.util.connection._get_masked_bits, '255.255.0.255')
def test_get_address_binary(self):
"""
Checks the _get_address_binary function.
"""
test_values = {
'0.0.0.0': '00000000000000000000000000000000',
'1.2.3.4': '00000001000000100000001100000100',
'127.0.0.1': '01111111000000000000000000000001',
'255.255.255.255': '11111111111111111111111111111111',
'::': '0' * 128,
'::1': ('0' * 127) + '1',
'1::1': '0000000000000001' + ('0' * 111) + '1',
'2001:db8::ff00:42:8329': '00100000000000010000110110111000000000000000000000000000000000000000000000000000111111110000000000000000010000101000001100101001',
}
for test_arg, expected in test_values.items():
self.assertEqual(expected, stem.util.connection._get_address_binary(test_arg))
self.assertRaises(ValueError, stem.util.connection._get_address_binary, '')
self.assertRaises(ValueError, stem.util.connection._get_address_binary, 'blarg')
stem-1.6.0/test/unit/util/proc.py 0000664 0001750 0001750 00000025436 13174655130 017457 0 ustar atagar atagar 0000000 0000000 """
Unit testing code for the stem.util.proc functions.
"""
import io
import re
import unittest
import test
from stem.util import proc
from stem.util.connection import Connection
try:
from unittest.mock import Mock, patch
except ImportError:
from mock import Mock, patch
TITLE_LINE = b'sl local_address rem_address st tx_queue rx_queue tr tm->when retrnsmt uid timeout'
TCP6_CONTENT = b"""\
sl local_address remote_address st tx_queue rx_queue tr tm->when retrnsmt uid timeout inode
0: 00000000000000000000000000000000:1495 00000000000000000000000000000000:0000 0A 00000000:00000000 00:00000000 00000000 106 0 14347030 1 0000000000000000 100 0 0 10 0
1: 00000000000000000000000000000000:0035 00000000000000000000000000000000:0000 0A 00000000:00000000 00:00000000 00000000 0 0 1457 1 0000000000000000 100 0 0 10 0
2: 00000000000000000000000000000000:0217 00000000000000000000000000000000:0000 0A 00000000:00000000 00:00000000 00000000 0 0 6606 1 0000000000000000 100 0 0 10 0
3: F804012A4A5190010000000002000000:01BB 00000000000000000000000000000000:0000 0A 00000000:00000000 00:00000000 00000000 0 0 4372 1 0000000000000000 100 0 0 10 0
4: 00000000000000000000000000000000:14A1 00000000000000000000000000000000:0000 0A 00000000:00000000 00:00000000 00000000 106 0 14347031 1 0000000000000000 100 0 0 10 0
5: 00000000000000000000000000000000:1466 00000000000000000000000000000000:0000 0A 00000000:00000000 00:00000000 00000000 106 0 14347029 1 0000000000000000 100 0 0 10 0
6: F804012A4A5190010000000002000000:01BB 38060120404100A0000000008901FFFF:9DF3 01 00000000:00000000 00:00000000 00000000 101 0 42088802 1 0000000000000000 20 4 25 10 7
7: F804012A4A5190010000000002000000:01BB 58080120020002000000BBAA26153B56:ADB5 01 00000000:00000000 00:00000000 00000000 101 0 41691357 1 0000000000000000 24 4 32 10 7
8: 0000000000000000FFFF00004B9E0905:1466 0000000000000000FFFF00002186364E:95BA 01 00000000:00000000 02:000A5B3D 00000000 106 0 41878761 2 0000000000000000 26 4 30 10 -1
9: F804012A4A5190010000000002000000:1495 F806012011006F120000000026000000:C5A2 01 00000000:00000000 02:000A5B3D 00000000 106 0 41825895 2 0000000000000000 21 4 15 10 -1
10: 0000000000000000FFFF00004B9E0905:1466 0000000000000000FFFF00002186364E:951E 01 00000000:00000000 02:00090E70 00000000 106 0 41512577 2 0000000000000000 26 4 31 10 -1
"""
class TestProc(unittest.TestCase):
@patch('stem.util.proc._get_line')
def test_system_start_time(self, get_line_mock):
"""
Tests the system_start_time function.
"""
get_line_mock.side_effect = lambda *params: {
('/proc/stat', 'btime', 'system start time'): 'btime 1001001',
}[params]
self.assertEqual(1001001, proc.system_start_time())
@patch('stem.util.proc._get_line')
def test_physical_memory(self, get_line_mock):
"""
Tests the physical_memory function.
"""
get_line_mock.side_effect = lambda *params: {
('/proc/meminfo', 'MemTotal:', 'system physical memory'): 'MemTotal: 12345 kB',
}[params]
self.assertEqual((12345 * 1024), proc.physical_memory())
@patch('os.readlink')
def test_cwd(self, readlink_mock):
"""
Tests the cwd function with a given pid.
"""
readlink_mock.side_effect = lambda param: {
'/proc/24019/cwd': '/home/directory/TEST'
}[param]
self.assertEqual('/home/directory/TEST', proc.cwd(24019))
@patch('stem.util.proc._get_line')
def test_uid(self, get_line_mock):
"""
Tests the uid function with a given pid.
"""
for test_value in [(24019, 11111), (0, 22222)]:
pid, uid = test_value
get_line_mock.side_effect = lambda *params: {
('/proc/%s/status' % pid, 'Uid:', 'uid'): 'Uid: %s' % uid,
}[params]
self.assertEqual(uid, proc.uid(pid))
@patch('stem.util.proc._get_lines')
def test_memory_usage(self, get_lines_mock):
"""
Tests the memory_usage function with a given pid.
"""
get_lines_mock.side_effect = lambda *params: {
('/proc/1111/status', ('VmRSS:', 'VmSize:'), 'memory usage'):
{'VmRSS:': 'VmRSS: 100 kB', 'VmSize:': 'VmSize: 1800 kB'}
}[params]
self.assertEqual((0, 0), proc.memory_usage(0))
self.assertEqual((100 * 1024, 1800 * 1024), proc.memory_usage(1111))
@patch('stem.util.proc._get_line')
@patch('stem.util.proc.system_start_time', Mock(return_value = 10))
@patch('stem.util.proc.CLOCK_TICKS', 100)
def test_stats(self, get_line_mock):
"""
Tests stats() with all combinations of stat_type arguments.
"""
# list of all combinations of args with respective return values
stat_combinations = test.get_all_combinations([
('command', 'test_program'),
('utime', '0.13'),
('stime', '0.14'),
('start time', '10.21'),
])
stat_path = '/proc/24062/stat'
stat = '1 (test_program) 2 3 4 5 6 7 8 9 10 11 12 13.0 14.0 15 16 17 18 19 20 21.0 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43'
# tests the case where no stat_types are specified
get_line_mock.side_effect = lambda *params: {
(stat_path, '24062', 'process '): stat
}[params]
self.assertEqual((), proc.stats(24062))
for stats in stat_combinations:
# the stats variable is...
# [(arg1, resp1), (arg2, resp2)...]
#
# but we need...
# (arg1, arg2...), (resp1, resp2...).
args, response = list(zip(*stats))
get_line_mock.side_effect = lambda *params: {
(stat_path, '24062', 'process %s' % ', '.join(args)): stat
}[params]
self.assertEqual(response, proc.stats(24062, *args))
# tests the case where pid = 0
if 'start time' in args:
response = 10
else:
response = ()
for arg in args:
if arg == 'command':
response += ('sched',)
elif arg == 'utime':
response += ('0',)
elif arg == 'stime':
response += ('0',)
get_line_mock.side_effect = lambda *params: {
('/proc/0/stat', '0', 'process %s' % ', '.join(args)): stat
}[params]
self.assertEqual(response, proc.stats(0, *args))
@patch('os.listdir')
def test_file_descriptors_used(self, listdir_mock):
"""
Tests the file_descriptors_used function.
"""
# check that we reject bad pids
for arg in (None, -100, 'hello',):
self.assertRaises(IOError, proc.file_descriptors_used, arg)
# when proc directory doesn't exist
error_msg = "OSError: [Errno 2] No such file or directory: '/proc/2118/fd'"
listdir_mock.side_effect = OSError(error_msg)
exc_msg = 'Unable to check number of file descriptors used: %s' % error_msg
self.assertRaisesRegexp(IOError, re.escape(exc_msg), proc.file_descriptors_used, 2118)
# successful calls
listdir_mock.return_value = ['0', '1', '2', '3', '4', '5']
listdir_mock.side_effect = None
self.assertEqual(6, proc.file_descriptors_used(2118))
self.assertEqual(6, proc.file_descriptors_used('2118'))
@patch('os.listdir')
@patch('os.path.exists')
@patch('os.readlink')
@patch('stem.util.proc.open', create = True)
def test_connections(self, open_mock, readlink_mock, path_exists_mock, listdir_mock):
"""
Tests the connections function.
"""
pid = 1111
listdir_mock.side_effect = lambda param: {
'/proc/%s/fd' % pid: ['1', '2', '3', '4'],
}[param]
readlink_mock.side_effect = lambda param: {
'/proc/%s/fd/1' % pid: 'socket:[99999999]',
'/proc/%s/fd/2' % pid: 'socket:[IIIIIIII]',
'/proc/%s/fd/3' % pid: 'pipe:[30303]',
'/proc/%s/fd/4' % pid: 'pipe:[40404]',
}[param]
tcp = TITLE_LINE + b'\n 0: 11111111:1111 22222222:2222 01 44444444:44444444 55:55555555 66666666 1111 8 99999999'
udp = TITLE_LINE + b'\n A: BBBBBBBB:BBBB CCCCCCCC:CCCC DD EEEEEEEE:EEEEEEEE FF:FFFFFFFF GGGGGGGG 1111 H IIIIIIII'
path_exists_mock.side_effect = lambda param: {
'/proc/net/tcp': True,
'/proc/net/tcp6': False,
'/proc/net/udp': True,
'/proc/net/udp6': False
}[param]
open_mock.side_effect = lambda param, mode: {
'/proc/net/tcp': io.BytesIO(tcp),
'/proc/net/udp': io.BytesIO(udp)
}[param]
expected_results = [
Connection('17.17.17.17', 4369, '34.34.34.34', 8738, 'tcp', False),
Connection('187.187.187.187', 48059, '204.204.204.204', 52428, 'udp', False),
]
self.assertEqual(expected_results, proc.connections(pid))
@patch('os.listdir')
@patch('os.path.exists')
@patch('os.readlink')
@patch('stem.util.proc.open', create = True)
def test_connections_ipv6(self, open_mock, readlink_mock, path_exists_mock, listdir_mock):
"""
Tests the connections function with ipv6 addresses.
"""
pid = 1111
listdir_mock.side_effect = lambda param: {
'/proc/%s/fd' % pid: ['1', '2'],
}[param]
readlink_mock.side_effect = lambda param: {
'/proc/%s/fd/1' % pid: 'socket:[42088802]',
'/proc/%s/fd/2' % pid: 'socket:[41691357]',
}[param]
path_exists_mock.side_effect = lambda param: {
'/proc/net/tcp6': True,
'/proc/net/udp6': False
}[param]
open_mock.side_effect = lambda param, mode: {
'/proc/net/tcp': io.BytesIO(TITLE_LINE),
'/proc/net/tcp6': io.BytesIO(TCP6_CONTENT),
'/proc/net/udp': io.BytesIO(TITLE_LINE),
}[param]
expected_results = [
Connection('2a01:04f8:0190:514a:0000:0000:0000:0002', 443, '2001:0638:a000:4140:0000:0000:ffff:0189', 40435, 'tcp', True),
Connection('2a01:04f8:0190:514a:0000:0000:0000:0002', 443, '2001:0858:0002:0002:aabb:0000:563b:1526', 44469, 'tcp', True),
]
self.assertEqual(expected_results, proc.connections(pid = pid))
@patch('os.path.exists')
@patch('pwd.getpwnam')
@patch('stem.util.proc.open', create = True)
def test_connections_ipv6_by_user(self, open_mock, getpwnam_mock, path_exists_mock):
"""
Tests the connections function with ipv6 addresses.
"""
getpwnam_mock('me').pw_uid = 106
path_exists_mock.side_effect = lambda param: {
'/proc/net/tcp6': True,
'/proc/net/udp6': False
}[param]
open_mock.side_effect = lambda param, mode: {
'/proc/net/tcp': io.BytesIO(TITLE_LINE),
'/proc/net/tcp6': io.BytesIO(TCP6_CONTENT),
'/proc/net/udp': io.BytesIO(TITLE_LINE),
}[param]
expected_results = [
Connection('0000:0000:0000:0000:0000:ffff:0509:9e4b', 5222, '0000:0000:0000:0000:0000:ffff:4e36:8621', 38330, 'tcp', True),
Connection('2a01:04f8:0190:514a:0000:0000:0000:0002', 5269, '2001:06f8:126f:0011:0000:0000:0000:0026', 50594, 'tcp', True),
Connection('0000:0000:0000:0000:0000:ffff:0509:9e4b', 5222, '0000:0000:0000:0000:0000:ffff:4e36:8621', 38174, 'tcp', True),
]
self.assertEqual(expected_results, proc.connections(user = 'me'))
stem-1.6.0/test/unit/util/tor_tools.py 0000664 0001750 0001750 00000005672 13177405637 020550 0 ustar atagar atagar 0000000 0000000 """
Unit tests for the stem.util.tor_tools functions.
"""
import unittest
import stem.util.str_tools
import stem.util.tor_tools
class TestTorTools(unittest.TestCase):
def test_is_valid_fingerprint(self):
"""
Checks the is_valid_fingerprint function.
"""
valid_fingerprints = (
'$A7569A83B5706AB1B1A9CB52EFF7D2D32E4553EB',
'$a7569a83b5706ab1b1a9cb52eff7d2d32e4553eb',
stem.util.str_tools._to_bytes('$A7569A83B5706AB1B1A9CB52EFF7D2D32E4553EB'),
stem.util.str_tools._to_unicode('$A7569A83B5706AB1B1A9CB52EFF7D2D32E4553EB'),
)
invalid_fingerprints = (
None,
'',
5,
['A7569A83B5706AB1B1A9CB52EFF7D2D32E4553EB'],
'A7569A83B5706AB1B1A9CB52EFF7D2D32E4553EB',
'$A7569A83B5706AB1B1A9CB52EFF7D2D32E4553E',
'$A7569A83B5706AB1B1A9CB52EFF7D2D32E4553E33',
'$A7569A83B5706AB1B1A9CB52EFF7D2D32E4553EG',
)
for fingerprint in valid_fingerprints:
self.assertTrue(stem.util.tor_tools.is_valid_fingerprint(fingerprint, True))
for fingerprint in invalid_fingerprints:
self.assertFalse(stem.util.tor_tools.is_valid_fingerprint(fingerprint, True))
def test_is_valid_nickname(self):
"""
Checks the is_valid_nickname function.
"""
valid_nicknames = (
'caerSidi',
'a',
'abcABC123',
stem.util.str_tools._to_bytes('caerSidi'),
stem.util.str_tools._to_unicode('caerSidi'),
)
invalid_nicknames = (
None,
'',
5,
'toolongggggggggggggg',
'bad_character',
)
for nickname in valid_nicknames:
self.assertTrue(stem.util.tor_tools.is_valid_nickname(nickname))
for nickname in invalid_nicknames:
self.assertFalse(stem.util.tor_tools.is_valid_nickname(nickname))
def test_is_valid_circuit_id(self):
"""
Checks the is_valid_circuit_id function.
"""
valid_circuit_ids = (
'0',
'2',
'abcABC123',
stem.util.str_tools._to_bytes('2'),
stem.util.str_tools._to_unicode('2'),
)
invalid_circuit_ids = (
None,
'',
0,
2,
'toolonggggggggggg',
'bad_character',
)
for circuit_id in valid_circuit_ids:
self.assertTrue(stem.util.tor_tools.is_valid_circuit_id(circuit_id))
for circuit_id in invalid_circuit_ids:
self.assertFalse(stem.util.tor_tools.is_valid_circuit_id(circuit_id))
def test_is_valid_hex_digits(self):
"""
Checks the is_valid_hex_digits function.
"""
valid_hex_digits = (
'12345',
'AbCdE',
stem.util.str_tools._to_bytes('AbCdE'),
stem.util.str_tools._to_unicode('AbCdE'),
)
invalid_hex_digits = (
None,
'',
5,
'X',
'1234',
'ABCDEF',
[1, '2', (3, 4)]
)
for hex_digits in valid_hex_digits:
self.assertTrue(stem.util.tor_tools.is_hex_digits(hex_digits, 5))
for hex_digits in invalid_hex_digits:
self.assertFalse(stem.util.tor_tools.is_hex_digits(hex_digits, 5))
stem-1.6.0/test/unit/util/log.py 0000664 0001750 0001750 00000001061 13165210535 017255 0 ustar atagar atagar 0000000 0000000 """
Unit tests for the stem.util.log functions.
"""
import unittest
from stem.util import log
class TestLog(unittest.TestCase):
def test_is_tracing(self):
logger = log.get_logger()
original_handlers = logger.handlers
logger.handlers = [log._NullHandler()]
try:
self.assertFalse(log.is_tracing())
logger.addHandler(log.LogBuffer(log.DEBUG))
self.assertFalse(log.is_tracing())
logger.addHandler(log.LogBuffer(log.TRACE))
self.assertTrue(log.is_tracing())
finally:
logger.handlers = original_handlers
stem-1.6.0/test/unit/tutorial.py 0000664 0001750 0001750 00000020652 13125773507 017402 0 ustar atagar atagar 0000000 0000000 """
Tests for the examples given in stem's tutorial.
"""
import io
import unittest
import stem.descriptor.remote
from stem.control import Controller
from stem.descriptor.reader import DescriptorReader
from stem.descriptor.router_status_entry import RouterStatusEntryV2, RouterStatusEntryV3
from stem.descriptor.networkstatus import NetworkStatusDocumentV3
from stem.descriptor.server_descriptor import RelayDescriptor
from test.unit import exec_documentation_example
try:
from StringIO import StringIO
except ImportError:
from io import StringIO
try:
# added in python 3.3
from unittest.mock import Mock, patch
except ImportError:
from mock import Mock, patch
OVER_THE_RIVER_OUTPUT = """\
* Connecting to tor
* Creating our hidden service in /home/atagar/.tor/hello_world
* Our service is available at uxiuaxejc3sxrb6i.onion, press ctrl+c to quit
* Shutting down our hidden service
"""
MIRROR_MIRROR_OUTPUT = """\
1. speedyexit (102.13 KB/s)
2. speedyexit (102.13 KB/s)
3. speedyexit (102.13 KB/s)
"""
class TestTutorial(unittest.TestCase):
def tearDown(self):
# Ensure we don't cache a Mock object as our downloader. Otherwise future
# tests will understandably be very sad. :P
stem.descriptor.remote.SINGLETON_DOWNLOADER = None
@patch('sys.stdout', new_callable = StringIO)
@patch('stem.control.Controller.from_port', spec = Controller)
def test_the_little_relay_that_could(self, from_port_mock, stdout_mock):
controller = from_port_mock().__enter__()
controller.get_info.side_effect = lambda arg: {
'traffic/read': '33406',
'traffic/written': '29649',
}[arg]
exec_documentation_example('hello_world.py')
self.assertEqual('My Tor relay has read 33406 bytes and written 29649.\n', stdout_mock.getvalue())
@patch('sys.stdout', new_callable = StringIO)
@patch('shutil.rmtree')
@patch('stem.control.Controller.from_port', spec = Controller)
def test_over_the_river(self, from_port_mock, rmtree_mock, stdout_mock):
def tutorial_example(app):
import os
import shutil
from stem.control import Controller
@app.route('/')
def index():
return 'Hi Grandma!
'
print(' * Connecting to tor')
with Controller.from_port() as controller:
controller.authenticate()
# All hidden services have a directory on disk. Lets put ours in tor's data
# directory.
hidden_service_dir = os.path.join(controller.get_conf('DataDirectory', '/tmp'), 'hello_world')
# Create a hidden service where visitors of port 80 get redirected to local
# port 5000 (this is where flask runs by default).
print(' * Creating our hidden service in %s' % hidden_service_dir)
result = controller.create_hidden_service(hidden_service_dir, 80, target_port = 5000)
# The hostname is only available we can read the hidden service directory.
# This requires us to be running with the same user as tor.
if result.hostname:
print(' * Our service is available at %s, press ctrl+c to quit' % result.hostname)
else:
print(" * Unable to determine our service's hostname, probably due to being unable to read the hidden service directory")
try:
app.run()
finally:
# Shut down the hidden service and clean it off disk. Note that you *don't*
# want to delete the hidden service directory if you'd like to have this
# same *.onion address in the future.
print(' * Shutting down our hidden service')
controller.remove_hidden_service(hidden_service_dir)
shutil.rmtree(hidden_service_dir)
flask_mock = Mock()
hidden_service_data = Mock()
hidden_service_data.hostname = 'uxiuaxejc3sxrb6i.onion'
controller = from_port_mock().__enter__()
controller.get_conf.return_value = '/home/atagar/.tor'
controller.create_hidden_service.return_value = hidden_service_data
tutorial_example(flask_mock)
controller.get_conf.assert_called_once_with('DataDirectory', '/tmp')
controller.create_hidden_service.assert_called_once_with('/home/atagar/.tor/hello_world', 80, target_port = 5000)
rmtree_mock.assert_called_once_with('/home/atagar/.tor/hello_world')
self.assertEqual(OVER_THE_RIVER_OUTPUT, stdout_mock.getvalue())
@patch('sys.stdout', new_callable = StringIO)
@patch('stem.descriptor.remote.DescriptorDownloader')
def test_mirror_mirror_on_the_wall_1(self, downloader_mock, stdout_mock):
downloader_mock().get_consensus().run.return_value = [RouterStatusEntryV2.create({
'r': 'caerSidi p1aag7VwarGxqctS7/fS0y5FU+s oQZFLYe9e4A7bOkWKR7TaNxb0JE 2012-08-06 11:19:31 71.35.150.29 9001 0',
})]
exec_documentation_example('current_descriptors.py')
self.assertEqual('found relay caerSidi (A7569A83B5706AB1B1A9CB52EFF7D2D32E4553EB)\n', stdout_mock.getvalue())
@patch('sys.stdout', new_callable = StringIO)
@patch('stem.control.Controller.from_port', spec = Controller)
def test_mirror_mirror_on_the_wall_2(self, from_port_mock, stdout_mock):
controller = from_port_mock().__enter__()
controller.get_network_statuses.return_value = [RouterStatusEntryV2.create({
'r': 'caerSidi p1aag7VwarGxqctS7/fS0y5FU+s oQZFLYe9e4A7bOkWKR7TaNxb0JE 2012-08-06 11:19:31 71.35.150.29 9001 0',
})]
exec_documentation_example('descriptor_from_tor_control_socket.py')
self.assertEqual('found relay caerSidi (A7569A83B5706AB1B1A9CB52EFF7D2D32E4553EB)\n', stdout_mock.getvalue())
@patch('sys.stdout', new_callable = StringIO)
@patch('%s.open' % __name__, create = True)
def test_mirror_mirror_on_the_wall_3(self, open_mock, stdout_mock):
def tutorial_example():
from stem.descriptor import parse_file
for desc in parse_file(open('/home/atagar/.tor/cached-consensus')):
print('found relay %s (%s)' % (desc.nickname, desc.fingerprint))
test_file = io.BytesIO(NetworkStatusDocumentV3.content(routers = [RouterStatusEntryV3.create({
'r': 'caerSidi p1aag7VwarGxqctS7/fS0y5FU+s oQZFLYe9e4A7bOkWKR7TaNxb0JE 2012-08-06 11:19:31 71.35.150.29 9001 0',
})]))
test_file.name = '/home/atagar/.tor/cached-consensus'
open_mock.return_value = test_file
tutorial_example()
self.assertEqual('found relay caerSidi (A7569A83B5706AB1B1A9CB52EFF7D2D32E4553EB)\n', stdout_mock.getvalue())
@patch('sys.stdout', new_callable = StringIO)
@patch('stem.descriptor.reader.DescriptorReader', spec = DescriptorReader)
def test_mirror_mirror_on_the_wall_4(self, reader_mock, stdout_mock):
reader = reader_mock().__enter__()
reader.__iter__.return_value = iter([RelayDescriptor.create({'router': 'caerSidi 71.35.133.197 9001 0 0'})])
exec_documentation_example('past_descriptors.py')
self.assertEqual('found relay caerSidi (None)\n', stdout_mock.getvalue())
@patch('sys.stdout', new_callable = StringIO)
@patch('stem.descriptor.remote.DescriptorDownloader')
@patch('stem.prereq.is_crypto_available', Mock(return_value = False))
def test_mirror_mirror_on_the_wall_5(self, downloader_mock, stdout_mock):
def tutorial_example():
from stem.descriptor.remote import DescriptorDownloader
from stem.util import str_tools
# provides a mapping of observed bandwidth to the relay nicknames
def get_bw_to_relay():
bw_to_relay = {}
downloader = DescriptorDownloader()
try:
for desc in downloader.get_server_descriptors().run():
if desc.exit_policy.is_exiting_allowed():
bw_to_relay.setdefault(desc.observed_bandwidth, []).append(desc.nickname)
except Exception as exc:
print('Unable to retrieve the server descriptors: %s' % exc)
return bw_to_relay
# prints the top fifteen relays
bw_to_relay = get_bw_to_relay()
count = 1
for bw_value in sorted(bw_to_relay.keys(), reverse = True):
for nickname in bw_to_relay[bw_value]:
print('%i. %s (%s/s)' % (count, nickname, str_tools.size_label(bw_value, 2)))
count += 1
if count > 15:
return
exit_descriptor = RelayDescriptor.content({'router': 'speedyexit 149.255.97.109 9001 0 0'}).replace(b'reject *:*', b'accept *:*')
exit_descriptor = RelayDescriptor(exit_descriptor)
downloader_mock().get_server_descriptors().run.return_value = [
exit_descriptor,
RelayDescriptor.create(), # non-exit
exit_descriptor,
exit_descriptor,
]
tutorial_example()
self.assertEqual(MIRROR_MIRROR_OUTPUT, stdout_mock.getvalue())
stem-1.6.0/test/unit/installation.py 0000664 0001750 0001750 00000005520 13124757510 020230 0 ustar atagar atagar 0000000 0000000 import json
import os
import re
import unittest
import test
class TestInstallation(unittest.TestCase):
# TODO: remove when dropping support for python 2.6
skip_reason = 'setUpClass() unsupported in python 2.6'
@classmethod
def setUpClass(self):
setup_path = os.path.join(test.STEM_BASE, 'setup.py')
self.skip_reason = None
self.setup_contents = False
if os.path.exists(setup_path):
with open(setup_path) as setup_file:
self.setup_contents = setup_file.read()
else:
self.skip_reason = '(only for git checkout)'
def test_installs_all_modules(self):
if self.skip_reason:
self.skipTest(self.skip_reason)
return True
# Modules cited my our setup.py looks like...
#
# packages = ['stem', 'stem.descriptor', 'stem.util'],
modules = json.loads(re.search('packages = (\[.*\])', self.setup_contents).group(1).replace("'", '"'))
module_paths = dict([(m, os.path.join(test.STEM_BASE, m.replace('.', os.path.sep))) for m in modules])
for module, path in module_paths.items():
if not os.path.exists(path):
self.fail("setup.py's module %s doesn't exist at %s" % (module, path))
for entry in os.walk(os.path.join(test.STEM_BASE, 'stem')):
directory = entry[0]
if directory.endswith('__pycache__'):
continue
elif directory not in module_paths.values():
self.fail("setup.py doesn't install %s" % directory)
def test_installs_all_data_files(self):
if self.skip_reason:
self.skipTest(self.skip_reason)
return True
# Checking that we have all non-source files. Data looks like...
#
# package_data = {
# 'stem': ['cached_tor_manual.cfg', 'settings.cfg'],
# 'stem.descriptor': ['fallback_directories.cfg'],
# },
package_data = {}
for line in self.setup_contents.split('package_data = {\n', 1)[1].splitlines():
if '},' in line:
break
directory = line.strip().split()[0][1:-2]
files = line.strip().split(' ', 1)[1][2:-3].split("', '")
package_data[directory] = files
data_files = []
for module, files in package_data.items():
for module_file in files:
data_files.append(os.path.join(test.STEM_BASE, module.replace('.', os.path.sep), module_file))
for path in data_files:
if not os.path.exists(path):
self.fail("setup.py installs a data file that doesn't exist: %s" % path)
for entry in os.walk(os.path.join(test.STEM_BASE, 'stem')):
directory = entry[0]
if directory.endswith('__pycache__'):
continue
for filename in entry[2]:
path = os.path.join(directory, filename)
file_type = path.split('.')[-1]
if file_type in (['py'] + test.IGNORED_FILE_TYPES):
continue
elif path not in data_files:
self.fail("setup.py doesn't install %s" % path)
stem-1.6.0/test/unit/tutorial_examples.py 0000664 0001750 0001750 00000033403 13125773507 021276 0 ustar atagar atagar 0000000 0000000 """
Tests for the examples given in stem's tutorial.
"""
import itertools
import os
import unittest
try:
from StringIO import StringIO
except ImportError:
from io import StringIO
import stem.response
import stem.descriptor.remote
import stem.prereq
from stem.control import Controller
from stem.descriptor.networkstatus import NetworkStatusDocumentV3
from stem.descriptor.remote import DIRECTORY_AUTHORITIES
from stem.descriptor.router_status_entry import RouterStatusEntryV3
from stem.descriptor.server_descriptor import RelayDescriptor
from stem.response import ControlMessage
from stem.util import str_type
from test.unit import exec_documentation_example
try:
# added in python 3.3
from unittest.mock import Mock, patch
except ImportError:
from mock import Mock, patch
OPEN_FUNCTION = open # make a reference so mocking open() won't mess with us
CIRC_CONTENT = '650 CIRC %d %s \
%s \
PURPOSE=%s'
PATH_CONTENT = '$%s=%s,$%s=%s,$%s=%s'
LIST_CIRCUITS_OUTPUT = str_type("""\
Circuit 4 (GENERAL)
|- B1FA7D51B8B6F0CB585D944F450E7C06EDE7E44C (ByTORAndTheSnowDog, 173.209.180.61)
|- 0DD9935C5E939CFA1E07B8DDA6D91C1A2A9D9338 (afo02, 87.238.194.176)
+- DB3B1CFBD3E4D97B84B548ADD5B9A31451EEC4CC (edwardsnowden3, 109.163.234.10)
Circuit 6 (GENERAL)
|- B1FA7D51B8B6F0CB585D944F450E7C06EDE7E44C (ByTORAndTheSnowDog, 173.209.180.61)
|- EC01CB4766BADC1611678555CE793F2A7EB2D723 (sprockets, 46.165.197.96)
+- 9EA317EECA56BDF30CAEB208A253FB456EDAB1A0 (bolobolo1, 96.47.226.20)
Circuit 10 (GENERAL)
|- B1FA7D51B8B6F0CB585D944F450E7C06EDE7E44C (ByTORAndTheSnowDog, 173.209.180.61)
|- 00C2C2A16AEDB51D5E5FB7D6168FC66B343D822F (ph3x, 86.59.119.83)
+- 65242C91BFF30F165DA4D132C81A9EBA94B71D62 (torexit16, 176.67.169.171)
""")
EXIT_USED_OUTPUT = str_type("""\
Tracking requests for tor exits. Press 'enter' to end.
Exit relay for our connection to 64.15.112.44:80
address: 31.172.30.2:443
fingerprint: A59E1E7C7EAEE083D756EE1FF6EC31CA3D8651D7
nickname: chaoscomputerclub19
locale: unknown
""")
OUTDATED_RELAYS_OUTPUT = str_type("""\
Checking for outdated relays...
0.1.0 Sambuddha Basu
2 outdated relays found, 1 had contact information
""")
COMPARE_FLAGS_OUTPUT = """\
maatuska has the Running flag but moria1 doesn't: E2BB13AA2F6960CD93ABE5257A825687F3973C62
moria1 has the Running flag but maatuska doesn't: 546C54E2A89D88E0794D04AECBF1AC8AC9DA81DE
maatuska has the Running flag but moria1 doesn't: 92FCB6748A40E6088E22FBAB943AB2DD743EA818
maatuska has the Running flag but moria1 doesn't: 6871F682350BA931838C0EC1E4A23044DAE06A73
moria1 has the Running flag but maatuska doesn't: DCAEC3D069DC39AAE43D13C8AF31B5645E05ED61
"""
VOTES_BY_BANDWIDTH_AUTHORITIES_OUTPUT = """\
Getting gabelmoo's vote from http://131.188.40.189:80/tor/status-vote/current/authority:
5935 measured entries and 1332 unmeasured
Getting moria1's vote from http://128.31.0.39:9131/tor/status-vote/current/authority:
6647 measured entries and 625 unmeasured
Getting maatuska's vote from http://171.25.193.9:443/tor/status-vote/current/authority:
6313 measured entries and 1112 unmeasured
"""
PERSISTING_A_CONSENSUS_OUTPUT = """\
A7569A83B5706AB1B1A9CB52EFF7D2D32E4553EB: caerSidi
"""
def _get_event(content):
return ControlMessage.from_str(content, 'EVENT', normalize = True)
def _get_circ_event(id, status, hop1, hop2, hop3, purpose):
path = PATH_CONTENT % (hop1[0], hop1[1], hop2[0], hop2[1], hop3[0], hop3[1])
content = CIRC_CONTENT % (id, status, path, purpose)
return _get_event(content)
def _get_router_status(address = None, port = None, nickname = None, fingerprint_base64 = None, s_line = None):
r_line = 'caerSidi p1aag7VwarGxqctS7/fS0y5FU+s oQZFLYe9e4A7bOkWKR7TaNxb0JE 2012-08-06 11:19:31 71.35.150.29 9001 0'
if address:
r_line = r_line.replace('71.35.150.29', address)
if port:
r_line = r_line.replace('9001', port)
if nickname:
r_line = r_line.replace('caerSidi', nickname)
if fingerprint_base64:
r_line = r_line.replace('p1aag7VwarGxqctS7/fS0y5FU+s', fingerprint_base64)
if s_line:
return RouterStatusEntryV3.create({'r': r_line, 's': s_line})
else:
return RouterStatusEntryV3.create({'r': r_line})
class TestTutorialExamples(unittest.TestCase):
def assert_equal_unordered(self, expected, actual):
if stem.prereq.is_python_3():
self.assertCountEqual(expected.splitlines(), actual.splitlines())
else:
self.assertItemsEqual(expected.splitlines(), actual.splitlines())
@patch('sys.stdout', new_callable = StringIO)
@patch('stem.control.Controller.from_port', spec = Controller)
def test_list_circuits(self, from_port_mock, stdout_mock):
path_1 = ('B1FA7D51B8B6F0CB585D944F450E7C06EDE7E44C', 'ByTORAndTheSnowDog')
path_2 = ('0DD9935C5E939CFA1E07B8DDA6D91C1A2A9D9338', 'afo02')
path_3 = ('DB3B1CFBD3E4D97B84B548ADD5B9A31451EEC4CC', 'edwardsnowden3')
path_4 = ('EC01CB4766BADC1611678555CE793F2A7EB2D723', 'sprockets')
path_5 = ('9EA317EECA56BDF30CAEB208A253FB456EDAB1A0', 'bolobolo1')
path_6 = ('00C2C2A16AEDB51D5E5FB7D6168FC66B343D822F', 'ph3x')
path_7 = ('65242C91BFF30F165DA4D132C81A9EBA94B71D62', 'torexit16')
circuit_4 = _get_circ_event(4, 'BUILT', path_1, path_2, path_3, 'GENERAL')
circuit_6 = _get_circ_event(6, 'BUILT', path_1, path_4, path_5, 'GENERAL')
circuit_10 = _get_circ_event(10, 'BUILT', path_1, path_6, path_7, 'GENERAL')
controller = from_port_mock().__enter__()
controller.get_circuits.return_value = [circuit_4, circuit_6, circuit_10]
controller.get_network_status.side_effect = lambda fingerprint, *args: {
path_1[0]: _get_router_status('173.209.180.61'),
path_2[0]: _get_router_status('87.238.194.176'),
path_3[0]: _get_router_status('109.163.234.10'),
path_4[0]: _get_router_status('46.165.197.96'),
path_5[0]: _get_router_status('96.47.226.20'),
path_6[0]: _get_router_status('86.59.119.83'),
path_7[0]: _get_router_status('176.67.169.171')
}[fingerprint]
exec_documentation_example('list_circuits.py')
self.assert_equal_unordered(LIST_CIRCUITS_OUTPUT, stdout_mock.getvalue())
@patch('sys.stdout', new_callable = StringIO)
@patch('stem.control.Controller.from_port', spec = Controller)
def test_exit_used(self, from_port_mock, stdout_mock):
def tutorial_example(mock_event):
import functools
from stem import StreamStatus
from stem.control import EventType, Controller
def main():
print("Tracking requests for tor exits. Press 'enter' to end.\n")
with Controller.from_port() as controller:
controller.authenticate()
stream_listener = functools.partial(stream_event, controller)
controller.add_event_listener(stream_listener, EventType.STREAM)
stream_event(controller, mock_event) # simulate an event during the raw_input()
def stream_event(controller, event):
if event.status == StreamStatus.SUCCEEDED and event.circ_id:
circ = controller.get_circuit(event.circ_id)
exit_fingerprint = circ.path[-1][0]
exit_relay = controller.get_network_status(exit_fingerprint)
print('Exit relay for our connection to %s' % (event.target))
print(' address: %s:%i' % (exit_relay.address, exit_relay.or_port))
print(' fingerprint: %s' % exit_relay.fingerprint)
print(' nickname: %s' % exit_relay.nickname)
print(' locale: %s\n' % controller.get_info('ip-to-country/%s' % exit_relay.address, 'unknown'))
main()
path_1 = ('9EA317EECA56BDF30CAEB208A253FB456EDAB1A0', 'bolobolo1')
path_2 = ('00C2C2A16AEDB51D5E5FB7D6168FC66B343D822F', 'ph3x')
path_3 = ('A59E1E7C7EAEE083D756EE1FF6EC31CA3D8651D7', 'chaoscomputerclub19')
circuit = _get_circ_event(1, 'BUILT', path_1, path_2, path_3, 'GENERAL')
event_content = '650 STREAM 15 SUCCEEDED 3 64.15.112.44:80'
event = _get_event(event_content)
controller = from_port_mock().__enter__()
controller.get_circuit.return_value = circuit
controller.get_network_status.return_value = _get_router_status('31.172.30.2', '443', path_3[1], 'pZ4efH6u4IPXVu4f9uwxyj2GUdc=')
controller.get_info.return_value = 'unknown'
tutorial_example(event)
self.assert_equal_unordered(EXIT_USED_OUTPUT, stdout_mock.getvalue())
@patch('sys.stdout', new_callable = StringIO)
@patch('stem.descriptor.remote.DescriptorDownloader')
def test_outdated_relays(self, downloader_mock, stdout_mock):
downloader_mock().get_server_descriptors.return_value = [
RelayDescriptor.create({'platform': 'node-Tor 0.2.3.0 on Linux x86_64'}),
RelayDescriptor.create({'platform': 'node-Tor 0.1.0 on Linux x86_64'}),
RelayDescriptor.create({'opt': 'contact Random Person admin@gtr-10.de', 'platform': 'node-Tor 0.2.3.0 on Linux x86_64'}),
RelayDescriptor.create({'opt': 'contact Sambuddha Basu', 'platform': 'node-Tor 0.1.0 on Linux x86_64'}),
]
exec_documentation_example('outdated_relays.py')
self.assert_equal_unordered(OUTDATED_RELAYS_OUTPUT, stdout_mock.getvalue())
@patch('sys.stdout', new_callable = StringIO)
@patch('stem.descriptor.remote.Query')
@patch('stem.descriptor.remote.get_authorities')
def test_compare_flags(self, get_authorities_mock, query_mock, stdout_mock):
if stem.prereq._is_python_26():
# example imports OrderedDict from collections which doesn't work under
# python 2.6
self.skipTest("(example doesn't support python 2.6)")
return
get_authorities_mock().items.return_value = [('moria1', DIRECTORY_AUTHORITIES['moria1']), ('maatuska', DIRECTORY_AUTHORITIES['maatuska'])]
fingerprint = [
('92FCB6748A40E6088E22FBAB943AB2DD743EA818', 'kvy2dIpA5giOIvurlDqy3XQ+qBg='),
('6871F682350BA931838C0EC1E4A23044DAE06A73', 'aHH2gjULqTGDjA7B5KIwRNrganM='),
('E2BB13AA2F6960CD93ABE5257A825687F3973C62', '4rsTqi9pYM2Tq+UleoJWh/OXPGI='),
('546C54E2A89D88E0794D04AECBF1AC8AC9DA81DE', 'VGxU4qidiOB5TQSuy/Gsisnagd4='),
('DCAEC3D069DC39AAE43D13C8AF31B5645E05ED61', '3K7D0GncOarkPRPIrzG1ZF4F7WE='),
]
entry = [
# entries for moria1
_get_router_status(fingerprint_base64 = fingerprint[0][1], s_line = ' '),
_get_router_status(fingerprint_base64 = fingerprint[1][1], s_line = ' '),
_get_router_status(fingerprint_base64 = fingerprint[2][1], s_line = ' '),
_get_router_status(fingerprint_base64 = fingerprint[3][1]),
_get_router_status(fingerprint_base64 = fingerprint[4][1]),
# entries for maatuska
_get_router_status(fingerprint_base64 = fingerprint[0][1]),
_get_router_status(fingerprint_base64 = fingerprint[1][1]),
_get_router_status(fingerprint_base64 = fingerprint[2][1]),
_get_router_status(fingerprint_base64 = fingerprint[3][1], s_line = ' '),
_get_router_status(fingerprint_base64 = fingerprint[4][1], s_line = ' '),
]
query_mock().run.side_effect = [
[NetworkStatusDocumentV3.create(routers = (entry[0], entry[1], entry[2], entry[3], entry[4]))],
[NetworkStatusDocumentV3.create(routers = (entry[5], entry[6], entry[7], entry[8], entry[9]))],
]
exec_documentation_example('compare_flags.py')
self.assert_equal_unordered(COMPARE_FLAGS_OUTPUT, stdout_mock.getvalue())
@patch('sys.stdout', new_callable = StringIO)
@patch('stem.descriptor.remote.get_authorities')
@patch('stem.descriptor.remote.DescriptorDownloader.query')
def test_votes_by_bandwidth_authorities(self, query_mock, get_authorities_mock, stdout_mock):
directory_values = [
DIRECTORY_AUTHORITIES['gabelmoo'],
DIRECTORY_AUTHORITIES['moria1'],
DIRECTORY_AUTHORITIES['maatuska'],
]
directory_values[0].address = '131.188.40.189'
get_authorities_mock().values.return_value = directory_values
entry_with_measurement = RouterStatusEntryV3.create({'w': 'Bandwidth=1 Measured=1'})
entry_without_measurement = RouterStatusEntryV3.create()
query1 = Mock()
query1.download_url = 'http://131.188.40.189:80/tor/status-vote/current/authority'
query1.run.return_value = [entry_with_measurement] * 5935 + [entry_without_measurement] * 1332
query2 = Mock()
query2.download_url = 'http://128.31.0.39:9131/tor/status-vote/current/authority'
query2.run.return_value = [entry_with_measurement] * 6647 + [entry_without_measurement] * 625
query3 = Mock()
query3.download_url = 'http://171.25.193.9:443/tor/status-vote/current/authority'
query3.run.return_value = [entry_with_measurement] * 6313 + [entry_without_measurement] * 1112
query_mock.side_effect = [query1, query2, query3]
exec_documentation_example('votes_by_bandwidth_authorities.py')
self.assert_equal_unordered(VOTES_BY_BANDWIDTH_AUTHORITIES_OUTPUT, stdout_mock.getvalue())
@patch('sys.stdout', new_callable = StringIO)
@patch('stem.descriptor.parse_file')
@patch('stem.descriptor.remote.Query')
def test_persisting_a_consensus(self, query_mock, parse_file_mock, stdout_mock):
def tutorial_example_2():
from stem.descriptor import DocumentHandler, parse_file
consensus = next(parse_file(
'/tmp/descriptor_dump',
descriptor_type = 'network-status-consensus-3 1.0',
document_handler = DocumentHandler.DOCUMENT,
))
for fingerprint, relay in consensus.routers.items():
print('%s: %s' % (fingerprint, relay.nickname))
network_status = NetworkStatusDocumentV3.create(routers = (RouterStatusEntryV3.create({
'r': 'caerSidi p1aag7VwarGxqctS7/fS0y5FU+s oQZFLYe9e4A7bOkWKR7TaNxb0JE 2012-08-06 11:19:31 71.35.150.29 9001 0',
}),))
query_mock().run.return_value = [network_status]
parse_file_mock.return_value = itertools.cycle([network_status])
exec_documentation_example('persisting_a_consensus.py')
exec_documentation_example('persisting_a_consensus_with_parse_file.py')
self.assertEqual(PERSISTING_A_CONSENSUS_OUTPUT, stdout_mock.getvalue())
if os.path.exists('/tmp/descriptor_dump'):
os.remove('/tmp/descriptor_dump')
stem-1.6.0/test/unit/interpreter/ 0000775 0001750 0001750 00000000000 13177674754 017536 5 ustar atagar atagar 0000000 0000000 stem-1.6.0/test/unit/interpreter/help.py 0000664 0001750 0001750 00000004614 13115423200 021007 0 ustar atagar atagar 0000000 0000000 import unittest
from stem.interpreter.help import response, _normalize
from test.unit.interpreter import CONTROLLER
class TestHelpResponses(unittest.TestCase):
def test_normalization(self):
self.assertEqual('', _normalize(''))
self.assertEqual('', _normalize(' '))
self.assertEqual('GETINFO', _normalize('GETINFO'))
self.assertEqual('GETINFO', _normalize('GetInfo'))
self.assertEqual('GETINFO', _normalize('getinfo'))
self.assertEqual('GETINFO', _normalize('GETINFO version'))
self.assertEqual('GETINFO', _normalize('GETINFO '))
self.assertEqual('INFO', _normalize('/info'))
self.assertEqual('INFO', _normalize('/info caerSidi'))
def test_unrecognized_option(self):
result = response(CONTROLLER, 'FOOBAR')
self.assertEqual("\x1b[1;31mNo help information available for 'FOOBAR'...\x1b[0m", result)
def test_general_help(self):
result = response(CONTROLLER, '')
self.assertTrue('Interpreter commands include:' in result)
self.assertTrue('\x1b[34;1m GETINFO\x1b[0m\x1b[34m - queries information from tor\x1b[0m\n' in result)
def test_getinfo_help(self):
result = response(CONTROLLER, 'GETINFO')
self.assertTrue('Queries the tor process for information. Options are...' in result)
self.assertTrue('\x1b[34;1minfo/names \x1b[0m\x1b[34m - List of GETINFO options, types, and documentation.' in result)
def test_getconf_help(self):
result = response(CONTROLLER, 'GETCONF')
self.assertTrue('Provides the current value for a given configuration value. Options include...' in result)
self.assertTrue('\x1b[34mExitNodes ExitPolicy' in result)
def test_signal_help(self):
result = response(CONTROLLER, 'SIGNAL')
self.assertTrue('Issues a signal that tells the tor process to' in result)
self.assertTrue('\x1b[34;1mRELOAD / HUP \x1b[0m\x1b[34m - reload our torrc' in result)
def test_setevents_help(self):
result = response(CONTROLLER, 'SETEVENTS')
self.assertTrue('Sets the events that we will receive.' in result)
self.assertTrue('\x1b[34mBW DEBUG INFO NOTICE\x1b[0m' in result)
def test_usefeature_help(self):
result = response(CONTROLLER, 'USEFEATURE')
self.assertTrue('Customizes the behavior of the control port.' in result)
self.assertTrue('\x1b[34mVERBOSE_NAMES EXTENDED_EVENTS\x1b[0m' in result)
stem-1.6.0/test/unit/interpreter/commands.py 0000664 0001750 0001750 00000016630 13124757510 021677 0 ustar atagar atagar 0000000 0000000 import datetime
import unittest
import stem
import stem.response
import stem.version
from stem.interpreter.commands import ControlInterpreter, _get_fingerprint
from stem.response import ControlMessage
from test.unit.interpreter import CONTROLLER
try:
# added in python 3.3
from unittest.mock import Mock, patch
except ImportError:
from mock import Mock, patch
EXPECTED_EVENTS_RESPONSE = """\
\x1b[34mBW 15 25\x1b[0m
\x1b[34mBW 758 570\x1b[0m
\x1b[34mDEBUG connection_edge_process_relay_cell(): Got an extended cell! Yay.\x1b[0m
"""
EXPECTED_INFO_RESPONSE = """\
moria1 (9695DFC35FFEB861329B9F1AB04C46397020CE31)
\x1b[34;1maddress: \x1b[0m128.31.0.34:9101 (moria.csail.mit.edu)
\x1b[34;1mtor version: \x1b[0m0.2.5.4-alpha-dev
\x1b[34;1mflags: \x1b[0mAuthority, Fast, Guard, HSDir, Named, Running, Stable, V2Dir, Valid
\x1b[34;1mexit policy: \x1b[0mreject *:*
\x1b[34;1mcontact: \x1b[0m1024D/28988BF5 arma mit edu
"""
EXPECTED_GETCONF_RESPONSE = """\
\x1b[34;1mlog\x1b[0m\x1b[34m => notice stdout\x1b[0m
\x1b[34;1maddress\x1b[0m\x1b[34m => \x1b[0m
"""
FINGERPRINT = '9695DFC35FFEB861329B9F1AB04C46397020CE31'
class TestInterpreterCommands(unittest.TestCase):
def test_get_fingerprint_for_ourselves(self):
controller = Mock()
controller.get_info.side_effect = lambda arg: {
'fingerprint': FINGERPRINT,
}[arg]
self.assertEqual(FINGERPRINT, _get_fingerprint('', controller))
controller.get_info.side_effect = stem.ControllerError
self.assertRaises(ValueError, _get_fingerprint, '', controller)
def test_get_fingerprint_for_fingerprint(self):
self.assertEqual(FINGERPRINT, _get_fingerprint(FINGERPRINT, Mock()))
def test_get_fingerprint_for_nickname(self):
controller, descriptor = Mock(), Mock()
descriptor.fingerprint = FINGERPRINT
controller.get_network_status.side_effect = lambda arg: {
'moria1': descriptor,
}[arg]
self.assertEqual(FINGERPRINT, _get_fingerprint('moria1', controller))
controller.get_network_status.side_effect = stem.ControllerError
self.assertRaises(ValueError, _get_fingerprint, 'moria1', controller)
def test_get_fingerprint_for_address(self):
controller = Mock()
self.assertRaises(ValueError, _get_fingerprint, '127.0.0.1:-1', controller)
self.assertRaises(ValueError, _get_fingerprint, '127.0.0.901:80', controller)
descriptor = Mock()
descriptor.address = '127.0.0.1'
descriptor.or_port = 80
descriptor.fingerprint = FINGERPRINT
controller.get_network_statuses.return_value = [descriptor]
self.assertEqual(FINGERPRINT, _get_fingerprint('127.0.0.1', controller))
self.assertEqual(FINGERPRINT, _get_fingerprint('127.0.0.1:80', controller))
self.assertRaises(ValueError, _get_fingerprint, '127.0.0.1:81', controller)
self.assertRaises(ValueError, _get_fingerprint, '127.0.0.2', controller)
def test_get_fingerprint_for_unrecognized_inputs(self):
self.assertRaises(ValueError, _get_fingerprint, 'blarg!', Mock())
def test_when_disconnected(self):
controller = Mock()
controller.msg.side_effect = stem.SocketClosed('kaboom!')
interpreter = ControlInterpreter(controller)
# we should be able to run non-tor commands
self.assertTrue('Interpreter commands include:' in interpreter.run_command('/help'))
# ... but tor commands should provide exceptions
self.assertRaises(stem.SocketClosed, interpreter.run_command, 'GETINFO version')
def test_quit(self):
interpreter = ControlInterpreter(CONTROLLER)
self.assertRaises(stem.SocketClosed, interpreter.run_command, '/quit')
self.assertRaises(stem.SocketClosed, interpreter.run_command, 'QUIT')
def test_help(self):
interpreter = ControlInterpreter(CONTROLLER)
self.assertTrue('Interpreter commands include:' in interpreter.run_command('/help'))
self.assertTrue('Queries the tor process for information.' in interpreter.run_command('/help GETINFO'))
self.assertTrue('Queries the tor process for information.' in interpreter.run_command('/help GETINFO version'))
def test_events(self):
interpreter = ControlInterpreter(CONTROLLER)
# no received events
self.assertEqual('', interpreter.run_command('/events'))
# with enqueued events
event_contents = (
'650 BW 15 25',
'650 BW 758 570',
'650 DEBUG connection_edge_process_relay_cell(): Got an extended cell! Yay.',
)
for content in event_contents:
event = ControlMessage.from_str(content, 'EVENT', normalize = True)
interpreter._received_events.append(event)
self.assertEqual(EXPECTED_EVENTS_RESPONSE, interpreter.run_command('/events'))
@patch('stem.descriptor.remote.DescriptorDownloader')
@patch('socket.gethostbyaddr', Mock(return_value = ['moria.csail.mit.edu']))
def test_info(self, downloader_mock):
controller, server_desc, ns_desc = Mock(), Mock(), Mock()
controller.get_microdescriptor.return_value = None
controller.get_server_descriptor.return_value = server_desc
controller.get_network_status.return_value = ns_desc
downloader_mock().get_server_descriptors.return_value = [server_desc]
controller.get_info.side_effect = lambda arg, _: {
'ip-to-country/128.31.0.34': 'us',
}[arg]
ns_desc.address = '128.31.0.34'
ns_desc.or_port = 9101
ns_desc.published = datetime.datetime(2014, 5, 5, 5, 52, 5)
ns_desc.nickname = 'moria1'
ns_desc.flags = ['Authority', 'Fast', 'Guard', 'HSDir', 'Named', 'Running', 'Stable', 'V2Dir', 'Valid']
server_desc.exit_policy = 'reject *:*'
server_desc.platform = 'Linux'
server_desc.tor_version = stem.version.Version('0.2.5.4-alpha-dev')
server_desc.contact = '1024D/28988BF5 arma mit edu'
interpreter = ControlInterpreter(controller)
self.assertTrue(interpreter.run_command('/info ' + FINGERPRINT).startswith(EXPECTED_INFO_RESPONSE))
def test_unrecognized_interpreter_command(self):
interpreter = ControlInterpreter(CONTROLLER)
expected = "\x1b[1;31m'/unrecognized' isn't a recognized command\x1b[0m\n"
self.assertEqual(expected, interpreter.run_command('/unrecognized'))
def test_getinfo(self):
controller = Mock()
controller.msg.return_value = ControlMessage.from_str('250-version=0.2.5.1-alpha-dev (git-245ecfff36c0cecc)\r\n250 OK\r\n')
interpreter = ControlInterpreter(controller)
self.assertEqual('\x1b[34m250-version=0.2.5.1-alpha-dev (git-245ecfff36c0cecc)\r\x1b[0m\n\x1b[34m250 OK\x1b[0m\n', interpreter.run_command('GETINFO version'))
self.assertEqual('\x1b[34m250-version=0.2.5.1-alpha-dev (git-245ecfff36c0cecc)\r\x1b[0m\n\x1b[34m250 OK\x1b[0m\n', interpreter.run_command('GETINFO version'))
controller.msg.assert_called_with('GETINFO version')
controller.msg.side_effect = stem.ControllerError('kaboom!')
self.assertEqual('\x1b[1;31mkaboom!\x1b[0m\n', interpreter.run_command('getinfo process/user'))
def test_getconf(self):
controller = Mock()
controller.msg.return_value = ControlMessage.from_str('250-Log=notice stdout\r\n250 Address\r\n')
interpreter = ControlInterpreter(controller)
self.assertEqual('\x1b[34m250-Log=notice stdout\r\x1b[0m\n\x1b[34m250 Address\x1b[0m\n', interpreter.run_command('GETCONF log address'))
controller.msg.assert_called_with('GETCONF log address')
def test_setevents(self):
controller = Mock()
controller.msg.return_value = ControlMessage.from_str('250 OK\r\n')
interpreter = ControlInterpreter(controller)
self.assertEqual('\x1b[34m250 OK\x1b[0m\n', interpreter.run_command('SETEVENTS BW'))
stem-1.6.0/test/unit/interpreter/__init__.py 0000664 0001750 0001750 00000001432 13115423200 021611 0 ustar atagar atagar 0000000 0000000 """
Unit tests for the stem's interpreter prompt.
"""
__all__ = [
'arguments',
'autocomplete',
'commands',
'help',
]
try:
# added in python 3.3
from unittest.mock import Mock
except ImportError:
from mock import Mock
GETINFO_NAMES = """
info/names -- List of GETINFO options, types, and documentation.
ip-to-country/* -- Perform a GEOIP lookup
md/id/* -- Microdescriptors by ID
""".strip()
GETCONF_NAMES = """
ExitNodes RouterList
ExitPolicy LineList
ExitPolicyRejectPrivate Boolean
""".strip()
CONTROLLER = Mock()
CONTROLLER.get_info.side_effect = lambda arg, _: {
'info/names': GETINFO_NAMES,
'config/names': GETCONF_NAMES,
'events/names': 'BW DEBUG INFO NOTICE',
'features/names': 'VERBOSE_NAMES EXTENDED_EVENTS',
'signal/names': 'RELOAD HUP SHUTDOWN',
}[arg]
stem-1.6.0/test/unit/interpreter/autocomplete.py 0000664 0001750 0001750 00000006346 13115423200 022564 0 ustar atagar atagar 0000000 0000000 import unittest
from stem.interpreter.autocomplete import _get_commands, Autocompleter
from test.unit.interpreter import CONTROLLER
try:
# added in python 3.3
from unittest.mock import Mock
except ImportError:
from mock import Mock
class TestAutocompletion(unittest.TestCase):
def test_autocomplete_results_from_config(self):
"""
Check that we load autocompletion results from our configuration.
"""
commands = _get_commands(None)
self.assertTrue('PROTOCOLINFO' in commands)
self.assertTrue('/quit' in commands)
def test_autocomplete_results_from_tor(self):
"""
Check our ability to determine autocompletion results based on our tor
instance's capabilities.
"""
# Check that when GETINFO requests fail we have base commands, but nothing
# with arguments.
controller = Mock()
controller.get_info.return_value = None
commands = _get_commands(controller)
self.assertTrue('GETINFO ' in commands)
self.assertTrue('GETCONF ' in commands)
self.assertTrue('SIGNAL ' in commands)
self.assertFalse('GETINFO info/names' in commands)
self.assertFalse('GETCONF ExitPolicy' in commands)
self.assertFalse('SIGNAL SHUTDOWN' in commands)
# Now check where we should be able to determine tor's capabilities.
commands = _get_commands(CONTROLLER)
expected = (
'GETINFO info/names',
'GETINFO ip-to-country/',
'GETINFO md/id/',
'GETCONF ExitNodes',
'GETCONF ExitPolicy',
'SETCONF ExitPolicy',
'RESETCONF ExitPolicy',
'SETEVENTS BW',
'SETEVENTS INFO',
'USEFEATURE VERBOSE_NAMES',
'USEFEATURE EXTENDED_EVENTS',
'SIGNAL RELOAD',
'SIGNAL SHUTDOWN',
)
for result in expected:
self.assertTrue(result in commands)
# We shouldn't include the base commands since we have results with
# their arguments.
self.assertFalse('GETINFO ' in commands)
self.assertFalse('GETCONF ' in commands)
self.assertFalse('SIGNAL ' in commands)
def test_autocompleter_match(self):
"""
Exercise our Autocompleter's match method.
"""
autocompleter = Autocompleter(None)
self.assertEqual(['/help'], autocompleter.matches('/help'))
self.assertEqual(['/help'], autocompleter.matches('/hel'))
self.assertEqual(['/help'], autocompleter.matches('/he'))
self.assertEqual(['/help'], autocompleter.matches('/h'))
self.assertEqual(['/help', '/events', '/info', '/quit'], autocompleter.matches('/'))
# check case sensitivity
self.assertEqual(['/help'], autocompleter.matches('/HELP'))
self.assertEqual(['/help'], autocompleter.matches('/HeLp'))
# check when we shouldn't have any matches
self.assertEqual([], autocompleter.matches('blarg'))
def test_autocompleter_complete(self):
"""
Exercise our Autocompleter's complete method.
"""
autocompleter = Autocompleter(None)
self.assertEqual('/help', autocompleter.complete('/', 0))
self.assertEqual('/events', autocompleter.complete('/', 1))
self.assertEqual('/info', autocompleter.complete('/', 2))
self.assertEqual('/quit', autocompleter.complete('/', 3))
self.assertEqual(None, autocompleter.complete('/', 4))
self.assertEqual(None, autocompleter.complete('blarg', 0))
stem-1.6.0/test/unit/interpreter/arguments.py 0000664 0001750 0001750 00000003637 13124757510 022106 0 ustar atagar atagar 0000000 0000000 import unittest
from stem.interpreter.arguments import DEFAULT_ARGS, parse, get_help
class TestArgumentParsing(unittest.TestCase):
def test_that_we_get_default_values(self):
args = parse([])
for attr in DEFAULT_ARGS:
self.assertEqual(DEFAULT_ARGS[attr], getattr(args, attr))
def test_that_we_load_arguments(self):
args = parse(['--interface', '10.0.0.25:80'])
self.assertEqual('10.0.0.25', args.control_address)
self.assertEqual(80, args.control_port)
args = parse(['--interface', '80'])
self.assertEqual(DEFAULT_ARGS['control_address'], args.control_address)
self.assertEqual(80, args.control_port)
args = parse(['--socket', '/tmp/my_socket'])
self.assertEqual('/tmp/my_socket', args.control_socket)
args = parse(['--help'])
self.assertEqual(True, args.print_help)
def test_examples(self):
args = parse(['-i', '1643'])
self.assertEqual(1643, args.control_port)
args = parse(['-s', '~/.tor/socket'])
self.assertEqual('~/.tor/socket', args.control_socket)
def test_that_we_reject_unrecognized_arguments(self):
self.assertRaises(ValueError, parse, ['--blarg', 'stuff'])
def test_that_we_reject_invalid_interfaces(self):
invalid_inputs = (
'',
' ',
'blarg',
'127.0.0.1',
'127.0.0.1:',
':80',
'400.0.0.1:80',
'127.0.0.1:-5',
'127.0.0.1:500000',
)
for invalid_input in invalid_inputs:
self.assertRaises(ValueError, parse, ['--interface', invalid_input])
def test_run_with_command(self):
self.assertEqual('GETINFO version', parse(['--run', 'GETINFO version']).run_cmd)
def test_run_with_path(self):
self.assertEqual(__file__, parse(['--run', __file__]).run_path)
def test_get_help(self):
help_text = get_help()
self.assertTrue('Interactive interpreter for Tor.' in help_text)
self.assertTrue('change control interface from 127.0.0.1:default' in help_text)
stem-1.6.0/test/unit/connection/ 0000775 0001750 0001750 00000000000 13177674754 017332 5 ustar atagar atagar 0000000 0000000 stem-1.6.0/test/unit/connection/__init__.py 0000664 0001750 0001750 00000000121 13115423200 021377 0 ustar atagar atagar 0000000 0000000 """
Unit tests for stem.connection.
"""
__all__ = ['authentication', 'connect']
stem-1.6.0/test/unit/connection/authentication.py 0000664 0001750 0001750 00000014077 13124757510 022714 0 ustar atagar atagar 0000000 0000000 """
Unit tests for the stem.connection.authenticate function.
Under the covers the authentiate function really just translates a
PROTOCOLINFO response into authenticate_* calls, then does prioritization
on the exceptions if they all fail.
This monkey patches the various functions authenticate relies on to exercise
various error conditions, and make sure that the right exception is raised.
"""
import unittest
import stem.connection
import test
from stem.response import ControlMessage
from stem.util import log
try:
# added in python 3.3
from unittest.mock import Mock, patch
except ImportError:
from mock import Mock, patch
class TestAuthenticate(unittest.TestCase):
@patch('stem.connection.get_protocolinfo')
@patch('stem.connection.authenticate_none', Mock())
def test_with_get_protocolinfo(self, get_protocolinfo_mock):
"""
Tests the authenticate() function when it needs to make a get_protocolinfo.
"""
# tests where get_protocolinfo succeeds
protocolinfo_message = ControlMessage.from_str('250-PROTOCOLINFO 1\r\n250 OK\r\n', 'PROTOCOLINFO')
protocolinfo_message.auth_methods = (stem.connection.AuthMethod.NONE, )
get_protocolinfo_mock.return_value = protocolinfo_message
stem.connection.authenticate(None)
# tests where get_protocolinfo raises an exception
get_protocolinfo_mock.side_effect = stem.ProtocolError
self.assertRaises(stem.connection.IncorrectSocketType, stem.connection.authenticate, None)
get_protocolinfo_mock.side_effect = stem.SocketError
self.assertRaises(stem.connection.AuthenticationFailure, stem.connection.authenticate, None)
@patch('stem.connection.authenticate_none')
@patch('stem.connection.authenticate_password')
@patch('stem.connection.authenticate_cookie')
@patch('stem.connection.authenticate_safecookie')
def test_all_use_cases(self, authenticate_safecookie_mock, authenticate_cookie_mock, authenticate_password_mock, authenticate_none_mock):
"""
Does basic validation that all valid use cases for the PROTOCOLINFO input
and dependent functions result in either success or a AuthenticationFailed
subclass being raised.
"""
# mute the logger for this test since otherwise the output is overwhelming
stem_logger = log.get_logger()
stem_logger.setLevel(log.logging_level(None))
# exceptions that the authentication functions are documented to raise
all_auth_none_exc = (
None,
stem.connection.OpenAuthRejected(None),
stem.ControllerError(None))
all_auth_password_exc = (
None,
stem.connection.PasswordAuthRejected(None),
stem.connection.IncorrectPassword(None),
stem.ControllerError(None))
all_auth_cookie_exc = (
None,
stem.connection.CookieAuthRejected(None, False, None),
stem.connection.IncorrectCookieValue(None, False, None),
stem.connection.IncorrectCookieSize(None, False, None),
stem.connection.UnreadableCookieFile(None, False, None),
stem.connection.AuthChallengeFailed(None, None),
stem.ControllerError(None))
auth_method_combinations = test.get_all_combinations([
stem.connection.AuthMethod.NONE,
stem.connection.AuthMethod.PASSWORD,
stem.connection.AuthMethod.COOKIE,
stem.connection.AuthMethod.SAFECOOKIE,
stem.connection.AuthMethod.UNKNOWN,
], include_empty = True)
protocolinfo = ControlMessage.from_str('250-PROTOCOLINFO 1\r\n250 OK\r\n', 'PROTOCOLINFO')
protocolinfo.cookie_path = '/tmp/blah'
for auth_methods in auth_method_combinations:
for auth_none_exc in all_auth_none_exc:
for auth_password_exc in all_auth_password_exc:
for auth_cookie_exc in all_auth_cookie_exc:
# Skip iteration if it's to test exceptions for authentication
# we're not using.
if auth_none_exc and stem.connection.AuthMethod.NONE not in auth_methods:
continue
elif auth_password_exc and stem.connection.AuthMethod.PASSWORD not in auth_methods:
continue
elif auth_cookie_exc and stem.connection.AuthMethod.COOKIE not in auth_methods and stem.connection.AuthMethod.SAFECOOKIE not in auth_methods:
continue
# Determine if the authenticate() call will succeed and mock each
# of the authenticate_* function to raise its given exception.
#
# This implementation is slightly inaccurate in a couple regards...
# a. it raises safecookie exceptions from authenticate_cookie()
# b. exceptions raised by authenticate_cookie() and
# authenticate_safecookie() are always the same
#
# However, adding another loop for safe_cookie exceptions means
# multiplying our runtime many fold. This exercises everything that
# matters so the above inaccuracies seem fine.
expect_success = False
protocolinfo.auth_methods = auth_methods
for auth_method in auth_methods:
if auth_method == stem.connection.AuthMethod.NONE:
auth_mock, raised_exc = authenticate_none_mock, auth_none_exc
elif auth_method == stem.connection.AuthMethod.PASSWORD:
auth_mock, raised_exc = authenticate_password_mock, auth_password_exc
elif auth_method == stem.connection.AuthMethod.COOKIE:
auth_mock, raised_exc = authenticate_cookie_mock, auth_cookie_exc
elif auth_method == stem.connection.AuthMethod.SAFECOOKIE:
auth_mock, raised_exc = authenticate_safecookie_mock, auth_cookie_exc
if raised_exc:
auth_mock.side_effect = raised_exc
else:
auth_mock.side_effect = None
expect_success = True
if expect_success:
stem.connection.authenticate(None, 'blah', None, protocolinfo)
else:
self.assertRaises(stem.connection.AuthenticationFailure, stem.connection.authenticate, None, 'blah', None, protocolinfo)
# revert logging back to normal
stem_logger.setLevel(log.logging_level(log.TRACE))
stem-1.6.0/test/unit/connection/connect.py 0000664 0001750 0001750 00000016036 13115423200 021305 0 ustar atagar atagar 0000000 0000000 """
Unit tests for the stem.connection.connect function.
"""
import unittest
try:
from StringIO import StringIO
except ImportError:
from io import StringIO
try:
from mock import Mock, patch
except ImportError:
from unittest.mock import Mock, patch
import stem
import stem.connection
import stem.socket
class TestConnect(unittest.TestCase):
@patch('sys.stdout', new_callable = StringIO)
@patch('stem.util.system.is_running')
@patch('os.path.exists', Mock(return_value = True))
@patch('stem.socket.ControlSocketFile', Mock(side_effect = stem.SocketError('failed')))
@patch('stem.socket.ControlPort', Mock(side_effect = stem.SocketError('failed')))
@patch('stem.connection._connect_auth', Mock())
def test_failue_with_the_default_endpoint(self, is_running_mock, stdout_mock):
is_running_mock.return_value = False
self._assert_connect_fails_with({}, stdout_mock, "Unable to connect to tor. Are you sure it's running?")
is_running_mock.return_value = True
self._assert_connect_fails_with({}, stdout_mock, "Unable to connect to tor. Maybe it's running without a ControlPort?")
@patch('sys.stdout', new_callable = StringIO)
@patch('os.path.exists')
@patch('stem.util.system.is_running', Mock(return_value = True))
@patch('stem.socket.ControlSocketFile', Mock(side_effect = stem.SocketError('failed')))
@patch('stem.socket.ControlPort', Mock(side_effect = stem.SocketError('failed')))
@patch('stem.connection._connect_auth', Mock())
def test_failure_with_a_custom_endpoint(self, path_exists_mock, stdout_mock):
path_exists_mock.return_value = True
self._assert_connect_fails_with({'control_port': ('127.0.0.1', 80), 'control_socket': None}, stdout_mock, "Unable to connect to 127.0.0.1:80: failed")
self._assert_connect_fails_with({'control_port': None, 'control_socket': '/tmp/my_socket'}, stdout_mock, "Unable to connect to '/tmp/my_socket': failed")
path_exists_mock.return_value = False
self._assert_connect_fails_with({'control_port': ('127.0.0.1', 80), 'control_socket': None}, stdout_mock, "Unable to connect to 127.0.0.1:80: failed")
self._assert_connect_fails_with({'control_port': None, 'control_socket': '/tmp/my_socket'}, stdout_mock, "The socket file you specified (/tmp/my_socket) doesn't exist")
@patch('stem.socket.ControlPort')
@patch('os.path.exists', Mock(return_value = False))
@patch('stem.connection._connect_auth', Mock())
def test_getting_a_control_port(self, port_mock):
stem.connection.connect()
port_mock.assert_called_once_with('127.0.0.1', 9051)
port_mock.reset_mock()
stem.connection.connect(control_port = ('255.0.0.10', 80), control_socket = None)
port_mock.assert_called_once_with('255.0.0.10', 80)
@patch('stem.socket.ControlSocketFile')
@patch('os.path.exists', Mock(return_value = True))
@patch('stem.connection._connect_auth', Mock())
def test_getting_a_control_socket(self, socket_mock):
stem.connection.connect()
socket_mock.assert_called_once_with('/var/run/tor/control')
socket_mock.reset_mock()
stem.connection.connect(control_port = None, control_socket = '/tmp/my_socket')
socket_mock.assert_called_once_with('/tmp/my_socket')
def _assert_connect_fails_with(self, args, stdout_mock, msg):
result = stem.connection.connect(**args)
if result is not None:
self.fail()
# Python 3.x seems to have an oddity where StringIO has prefixed null
# characters (\x00) after we call truncate(). This could be addressed
# a couple ways...
#
# * Don't use a stdout mock more than once.
# * Strip the null characters.
#
# Opting for the second (which is admittedly a hack) so the tests are a
# little nicer.
stdout_output = stdout_mock.getvalue()
stdout_mock.truncate(0)
self.assertEqual(msg, stdout_output.strip().lstrip('\x00'))
@patch('stem.connection.authenticate')
def test_auth_success(self, authenticate_mock):
control_socket = Mock()
stem.connection._connect_auth(control_socket, None, False, None, None)
authenticate_mock.assert_called_with(control_socket, None, None)
authenticate_mock.reset_mock()
stem.connection._connect_auth(control_socket, 's3krit!!!', False, '/my/chroot', None)
authenticate_mock.assert_called_with(control_socket, 's3krit!!!', '/my/chroot')
@patch('getpass.getpass')
@patch('stem.connection.authenticate')
def test_auth_success_with_password_prompt(self, authenticate_mock, getpass_mock):
control_socket = Mock()
def authenticate_mock_func(controller, password, *args):
if password is None:
raise stem.connection.MissingPassword('no password')
elif password == 'my_password':
return None # success
else:
raise ValueError('Unexpected authenticate_mock input: %s' % password)
authenticate_mock.side_effect = authenticate_mock_func
getpass_mock.return_value = 'my_password'
stem.connection._connect_auth(control_socket, None, True, None, None)
authenticate_mock.assert_any_call(control_socket, None, None)
authenticate_mock.assert_any_call(control_socket, 'my_password', None)
@patch('sys.stdout', new_callable = StringIO)
@patch('stem.connection.authenticate')
def test_auth_failure(self, authenticate_mock, stdout_mock):
control_socket = stem.socket.ControlPort(connect = False)
authenticate_mock.side_effect = stem.connection.IncorrectSocketType('unable to connect to socket')
self._assert_authenticate_fails_with(control_socket, stdout_mock, 'Please check in your torrc that 9051 is the ControlPort.')
control_socket = stem.socket.ControlSocketFile(connect = False)
self._assert_authenticate_fails_with(control_socket, stdout_mock, 'Are you sure the interface you specified belongs to')
authenticate_mock.side_effect = stem.connection.UnrecognizedAuthMethods('unable to connect', ['telepathy'])
self._assert_authenticate_fails_with(control_socket, stdout_mock, 'Tor is using a type of authentication we do not recognize...\n\n telepathy')
authenticate_mock.side_effect = stem.connection.IncorrectPassword('password rejected')
self._assert_authenticate_fails_with(control_socket, stdout_mock, 'Incorrect password')
authenticate_mock.side_effect = stem.connection.UnreadableCookieFile('permission denied', '/tmp/my_cookie', False)
self._assert_authenticate_fails_with(control_socket, stdout_mock, "We were unable to read tor's authentication cookie...\n\n Path: /tmp/my_cookie\n Issue: permission denied")
authenticate_mock.side_effect = stem.connection.OpenAuthRejected('crazy failure')
self._assert_authenticate_fails_with(control_socket, stdout_mock, 'Unable to authenticate: crazy failure')
def _assert_authenticate_fails_with(self, control_socket, stdout_mock, msg):
result = stem.connection._connect_auth(control_socket, None, False, None, None)
if result is not None:
self.fail() # _connect_auth() was successful
stdout_output = stdout_mock.getvalue()
stdout_mock.truncate(0)
if msg not in stdout_output:
self.fail("Expected...\n\n%s\n\n... which couldn't be found in...\n\n%s" % (msg, stdout_output))
stem-1.6.0/test/unit/control/ 0000775 0001750 0001750 00000000000 13177674754 016653 5 ustar atagar atagar 0000000 0000000 stem-1.6.0/test/unit/control/__init__.py 0000664 0001750 0001750 00000000077 13115423200 020732 0 ustar atagar atagar 0000000 0000000 """
Unit tests for stem.control.
"""
__all__ = ['controller']
stem-1.6.0/test/unit/control/controller.py 0000664 0001750 0001750 00000063527 13176650724 021413 0 ustar atagar atagar 0000000 0000000 """
Unit tests for the stem.control module. The module's primarily exercised via
integ tests, but a few bits lend themselves to unit testing.
"""
import datetime
import io
import time
import unittest
import stem.descriptor.router_status_entry
import stem.response
import stem.socket
import stem.util.system
import stem.version
from stem import ControllerError, DescriptorUnavailable, InvalidArguments, InvalidRequest, ProtocolError, UnsatisfiableRequest
from stem.control import _parse_circ_path, Listener, Controller, EventType
from stem.response import ControlMessage
from stem.exit_policy import ExitPolicy
try:
# added in python 3.3
from unittest.mock import Mock, patch
except ImportError:
from mock import Mock, patch
NS_DESC = 'r %s %s u5lTXJKGsLKufRLnSyVqT7TdGYw 2012-12-30 22:02:49 77.223.43.54 9001 0\ns Fast Named Running Stable Valid\nw Bandwidth=75'
class TestControl(unittest.TestCase):
def setUp(self):
socket = stem.socket.ControlSocket()
with patch('stem.control.Controller.add_event_listener', Mock()):
self.controller = Controller(socket)
def test_event_description(self):
self.assertEqual("Logging at the debug runlevel. This is low level, high volume information about tor's internals that generally isn't useful to users.", stem.control.event_description('DEBUG'))
self.assertEqual('Event emitted every second with the bytes sent and received by tor.', stem.control.event_description('BW'))
self.assertEqual('Event emitted every second with the bytes sent and received by tor.', stem.control.event_description('bw'))
def test_event_description_includes_all_events(self):
self.assertEqual(None, stem.control.event_description('NO_SUCH_EVENT'))
for event in stem.control.EventType:
self.assertTrue(stem.control.event_description(event) is not None)
@patch('stem.control.Controller.msg')
def test_get_info(self, msg_mock):
msg_mock.return_value = ControlMessage.from_str('250-hello=hi right back!\r\n250 OK\r\n', 'GETINFO')
self.assertEqual('hi right back!', self.controller.get_info('hello'))
@patch('stem.control.Controller.msg')
def test_get_info_address_caching(self, msg_mock):
test_start = time.time()
msg_mock.return_value = ControlMessage.from_str('551 Address unknown\r\n')
self.assertEqual(0, self.controller._address_cached_at)
self.assertEqual(None, self.controller._last_address_exc)
self.assertRaisesRegexp(stem.ProtocolError, 'Address unknown', self.controller.get_info, 'address')
self.assertTrue(test_start <= self.controller._address_cached_at <= time.time())
self.assertEqual("GETINFO response didn't have an OK status:\nAddress unknown", str(self.controller._last_address_exc))
self.assertEqual(1, msg_mock.call_count)
# now that we have a cached failure we should provide that back
self.assertRaisesRegexp(stem.ProtocolError, 'Address unknown', self.controller.get_info, 'address')
self.assertEqual(1, msg_mock.call_count)
# pretend it's a minute later and try again, now with an address
msg_mock.return_value = ControlMessage.from_str('250-address=17.2.89.80\r\n250 OK\r\n', 'GETINFO')
self.assertRaisesRegexp(stem.ProtocolError, 'Address unknown', self.controller.get_info, 'address')
self.controller._address_cached_at -= 60
self.assertEqual('17.2.89.80', self.controller.get_info('address'))
@patch('stem.control.Controller.msg')
@patch('stem.control.Controller.get_conf')
def test_get_info_without_fingerprint(self, get_conf_mock, msg_mock):
msg_mock.return_value = ControlMessage.from_str('551 Not running in server mode\r\n')
get_conf_mock.return_value = None
self.assertEqual(None, self.controller._last_fingerprint_exc)
self.assertRaisesRegexp(stem.ProtocolError, 'Not running in server mode', self.controller.get_info, 'fingerprint')
self.assertEqual("GETINFO response didn't have an OK status:\nNot running in server mode", str(self.controller._last_fingerprint_exc))
self.assertEqual(1, msg_mock.call_count)
# now that we have a cached failure we should provide that back
self.assertRaisesRegexp(stem.ProtocolError, 'Not running in server mode', self.controller.get_info, 'fingerprint')
self.assertEqual(1, msg_mock.call_count)
# ... but if we become a relay we'll call it again
get_conf_mock.return_value = '443'
self.assertRaisesRegexp(stem.ProtocolError, 'Not running in server mode', self.controller.get_info, 'fingerprint')
self.assertEqual(2, msg_mock.call_count)
@patch('stem.control.Controller.get_info')
def test_get_version(self, get_info_mock):
"""
Exercises the get_version() method.
"""
try:
# Use one version for first check.
version_2_1 = '0.2.1.32'
version_2_1_object = stem.version.Version(version_2_1)
get_info_mock.return_value = version_2_1
# Return a version with a cold cache.
self.assertEqual(version_2_1_object, self.controller.get_version())
# Use a different version for second check.
version_2_2 = '0.2.2.39'
version_2_2_object = stem.version.Version(version_2_2)
get_info_mock.return_value = version_2_2
# Return a version with a hot cache, so it will be the old version.
self.assertEqual(version_2_1_object, self.controller.get_version())
# Turn off caching.
self.controller._is_caching_enabled = False
# Return a version without caching, so it will be the new version.
self.assertEqual(version_2_2_object, self.controller.get_version())
# Spec says the getinfo response may optionally be prefixed by 'Tor '. In
# practice it doesn't but we should accept that.
get_info_mock.return_value = 'Tor 0.2.1.32'
self.assertEqual(version_2_1_object, self.controller.get_version())
# Raise an exception in the get_info() call.
get_info_mock.side_effect = InvalidArguments
# Get a default value when the call fails.
self.assertEqual(
'default returned',
self.controller.get_version(default = 'default returned')
)
# No default value, accept the error.
self.assertRaises(InvalidArguments, self.controller.get_version)
# Give a bad version. The stem.version.Version ValueError should bubble up.
version_A_42 = '0.A.42.spam'
get_info_mock.return_value = version_A_42
get_info_mock.side_effect = None
self.assertRaises(ValueError, self.controller.get_version)
finally:
# Turn caching back on before we leave.
self.controller._is_caching_enabled = True
@patch('stem.control.Controller.get_info')
@patch('stem.control.Controller.get_conf')
def test_get_exit_policy(self, get_conf_mock, get_info_mock):
"""
Exercises the get_exit_policy() method.
"""
get_conf_mock.side_effect = lambda param, **kwargs: {
'ExitPolicyRejectPrivate': '1',
'ExitPolicy': ['accept *:80, accept *:443', 'accept 43.5.5.5,reject *:22'],
}[param]
get_info_mock.side_effect = lambda param, default = None: {
'address': '123.45.67.89',
'exit-policy/default': 'reject *:25,reject *:119,reject *:135-139,reject *:445,reject *:563,reject *:1214,reject *:4661-4666,reject *:6346-6429,reject *:6699,reject *:6881-6999,accept *:*',
}[param]
expected = ExitPolicy(
'reject 0.0.0.0/8:*', # private entries
'reject 169.254.0.0/16:*',
'reject 127.0.0.0/8:*',
'reject 192.168.0.0/16:*',
'reject 10.0.0.0/8:*',
'reject 172.16.0.0/12:*',
'reject 123.45.67.89:*', # relay's public address
'accept *:80', # finally we get to our ExitPolicy
'accept *:443',
'accept 43.5.5.5:*',
'reject *:22',
'reject *:25', # default policy
'reject *:119',
'reject *:135-139',
'reject *:445',
'reject *:563',
'reject *:1214',
'reject *:4661-4666',
'reject *:6346-6429',
'reject *:6699',
'reject *:6881-6999',
'accept *:*',
)
self.assertEqual(expected, self.controller.get_exit_policy())
@patch('stem.control.Controller.get_info')
@patch('stem.control.Controller.get_conf')
def test_get_ports(self, get_conf_mock, get_info_mock):
"""
Exercises the get_ports() and get_listeners() methods.
"""
# Exercise as an old version of tor that doesn't support the 'GETINFO
# net/listeners/*' options.
get_info_mock.side_effect = InvalidArguments
get_conf_mock.side_effect = lambda param, **kwargs: {
'ControlPort': '9050',
'ControlListenAddress': ['127.0.0.1'],
}[param]
self.assertEqual([('127.0.0.1', 9050)], self.controller.get_listeners(Listener.CONTROL))
self.assertEqual([9050], self.controller.get_ports(Listener.CONTROL))
self.controller.clear_cache()
# non-local addresss
get_conf_mock.side_effect = lambda param, **kwargs: {
'ControlPort': '9050',
'ControlListenAddress': ['27.4.4.1'],
}[param]
self.assertEqual([('27.4.4.1', 9050)], self.controller.get_listeners(Listener.CONTROL))
self.assertEqual([], self.controller.get_ports(Listener.CONTROL))
self.controller.clear_cache()
# exercise via the GETINFO option
get_info_mock.side_effect = None
get_info_mock.return_value = '"127.0.0.1:1112" "127.0.0.1:1114"'
self.assertEqual(
[('127.0.0.1', 1112), ('127.0.0.1', 1114)],
self.controller.get_listeners(Listener.CONTROL)
)
self.assertEqual([1112, 1114], self.controller.get_ports(Listener.CONTROL))
self.controller.clear_cache()
# with all localhost addresses, including a couple that aren't
get_info_mock.side_effect = None
get_info_mock.return_value = '"27.4.4.1:1113" "127.0.0.5:1114" "0.0.0.0:1115" "[::]:1116" "[::1]:1117" "[10::]:1118"'
self.assertEqual([1114, 1115, 1116, 1117], self.controller.get_ports(Listener.OR))
self.controller.clear_cache()
# IPv6 address
get_info_mock.return_value = '"0.0.0.0:9001" "[fe80:0000:0000:0000:0202:b3ff:fe1e:8329]:9001"'
self.assertEqual(
[('0.0.0.0', 9001), ('fe80:0000:0000:0000:0202:b3ff:fe1e:8329', 9001)],
self.controller.get_listeners(Listener.CONTROL)
)
# unix socket file
self.controller.clear_cache()
get_info_mock.return_value = '"unix:/tmp/tor/socket"'
self.assertEqual([], self.controller.get_listeners(Listener.CONTROL))
self.assertEqual([], self.controller.get_ports(Listener.CONTROL))
@patch('stem.control.Controller.get_info')
@patch('stem.control.Controller.get_conf')
def test_get_socks_listeners_old(self, get_conf_mock, get_info_mock):
"""
Exercises the get_socks_listeners() method as though talking to an old tor
instance.
"""
# An old tor raises stem.InvalidArguments for get_info about socks, but
# get_socks_listeners should work anyway.
get_info_mock.side_effect = InvalidArguments
get_conf_mock.side_effect = lambda param, **kwargs: {
'SocksPort': '9050',
'SocksListenAddress': ['127.0.0.1'],
}[param]
self.assertEqual([('127.0.0.1', 9050)], self.controller.get_socks_listeners())
self.controller.clear_cache()
# Again, an old tor, but SocksListenAddress overrides the port number.
get_conf_mock.side_effect = lambda param, **kwargs: {
'SocksPort': '9050',
'SocksListenAddress': ['127.0.0.1:1112'],
}[param]
self.assertEqual([('127.0.0.1', 1112)], self.controller.get_socks_listeners())
self.controller.clear_cache()
# Again, an old tor, but multiple listeners
get_conf_mock.side_effect = lambda param, **kwargs: {
'SocksPort': '9050',
'SocksListenAddress': ['127.0.0.1:1112', '127.0.0.1:1114'],
}[param]
self.assertEqual([('127.0.0.1', 1112), ('127.0.0.1', 1114)], self.controller.get_socks_listeners())
self.controller.clear_cache()
# Again, an old tor, but no SOCKS listeners
get_conf_mock.side_effect = lambda param, **kwargs: {
'SocksPort': '0',
'SocksListenAddress': [],
}[param]
self.assertEqual([], self.controller.get_socks_listeners())
self.controller.clear_cache()
# Where tor provides invalid ports or addresses
get_conf_mock.side_effect = lambda param, **kwargs: {
'SocksPort': 'blarg',
'SocksListenAddress': ['127.0.0.1'],
}[param]
self.assertRaises(stem.ProtocolError, self.controller.get_socks_listeners)
get_conf_mock.side_effect = lambda param, **kwargs: {
'SocksPort': '0',
'SocksListenAddress': ['127.0.0.1:abc'],
}[param]
self.assertRaises(stem.ProtocolError, self.controller.get_socks_listeners)
get_conf_mock.side_effect = lambda param, **kwargs: {
'SocksPort': '40',
'SocksListenAddress': ['500.0.0.1'],
}[param]
self.assertRaises(stem.ProtocolError, self.controller.get_socks_listeners)
@patch('stem.control.Controller.get_info')
def test_get_socks_listeners_new(self, get_info_mock):
"""
Exercises the get_socks_listeners() method as if talking to a newer tor
instance.
"""
# multiple SOCKS listeners
get_info_mock.return_value = '"127.0.0.1:1112" "127.0.0.1:1114"'
self.assertEqual(
[('127.0.0.1', 1112), ('127.0.0.1', 1114)],
self.controller.get_socks_listeners()
)
# no SOCKS listeners
self.controller.clear_cache()
get_info_mock.return_value = ''
self.assertEqual([], self.controller.get_socks_listeners())
# check where GETINFO provides malformed content
invalid_responses = (
'"127.0.0.1"', # address only
'"1112"', # port only
'"5127.0.0.1:1112"', # invlaid address
'"127.0.0.1:991112"', # invalid port
)
for response in invalid_responses:
self.controller.clear_cache()
get_info_mock.return_value = response
self.assertRaises(stem.ProtocolError, self.controller.get_socks_listeners)
@patch('stem.control.Controller.get_info')
@patch('time.time', Mock(return_value = 1410723598.276578))
def test_get_accounting_stats(self, get_info_mock):
"""
Exercises the get_accounting_stats() method.
"""
get_info_mock.side_effect = lambda param, **kwargs: {
'accounting/enabled': '1',
'accounting/hibernating': 'awake',
'accounting/interval-end': '2014-09-14 19:41:00',
'accounting/bytes': '4837 2050',
'accounting/bytes-left': '102944 7440',
}[param]
expected = stem.control.AccountingStats(
1410723598.276578,
'awake',
datetime.datetime(2014, 9, 14, 19, 41),
62,
4837, 102944, 107781,
2050, 7440, 9490,
)
self.assertEqual(expected, self.controller.get_accounting_stats())
get_info_mock.side_effect = ControllerError('nope, too bad')
self.assertRaises(ControllerError, self.controller.get_accounting_stats)
self.assertEqual('my default', self.controller.get_accounting_stats('my default'))
@patch('stem.connection.get_protocolinfo')
def test_get_protocolinfo(self, get_protocolinfo_mock):
"""
Exercises the get_protocolinfo() method.
"""
# use the handy mocked protocolinfo response
protocolinfo_msg = ControlMessage.from_str('250-PROTOCOLINFO 1\r\n250 OK\r\n', 'PROTOCOLINFO')
get_protocolinfo_mock.return_value = protocolinfo_msg
# compare the str representation of these object, because the class
# does not have, nor need, a direct comparison operator
self.assertEqual(
str(protocolinfo_msg),
str(self.controller.get_protocolinfo())
)
# raise an exception in the stem.connection.get_protocolinfo() call
get_protocolinfo_mock.side_effect = ProtocolError
# get a default value when the call fails
self.assertEqual(
'default returned',
self.controller.get_protocolinfo(default = 'default returned')
)
# no default value, accept the error
self.assertRaises(ProtocolError, self.controller.get_protocolinfo)
@patch('stem.socket.ControlSocket.is_localhost', Mock(return_value = False))
def test_get_user_remote(self):
"""
Exercise the get_user() method for a non-local socket.
"""
self.assertRaises(ValueError, self.controller.get_user)
self.assertEqual(123, self.controller.get_user(123))
@patch('stem.socket.ControlSocket.is_localhost', Mock(return_value = True))
@patch('stem.control.Controller.get_info', Mock(return_value = 'atagar'))
def test_get_user_by_getinfo(self):
"""
Exercise the get_user() resolution via its getinfo option.
"""
self.assertEqual('atagar', self.controller.get_user())
@patch('stem.socket.ControlSocket.is_localhost', Mock(return_value = True))
@patch('stem.util.system.pid_by_name', Mock(return_value = 432))
@patch('stem.util.system.user', Mock(return_value = 'atagar'))
def test_get_user_by_system(self):
"""
Exercise the get_user() resolution via the system module.
"""
self.assertEqual('atagar', self.controller.get_user())
@patch('stem.socket.ControlSocket.is_localhost', Mock(return_value = False))
def test_get_pid_remote(self):
"""
Exercise the get_pid() method for a non-local socket.
"""
self.assertRaises(ValueError, self.controller.get_pid)
self.assertEqual(123, self.controller.get_pid(123))
@patch('stem.socket.ControlSocket.is_localhost', Mock(return_value = True))
@patch('stem.control.Controller.get_info', Mock(return_value = '321'))
def test_get_pid_by_getinfo(self):
"""
Exercise the get_pid() resolution via its getinfo option.
"""
self.assertEqual(321, self.controller.get_pid())
@patch('stem.socket.ControlSocket.is_localhost', Mock(return_value = True))
@patch('stem.control.Controller.get_conf')
@patch('stem.control.open', create = True)
def test_get_pid_by_pid_file(self, open_mock, get_conf_mock):
"""
Exercise the get_pid() resolution via a PidFile.
"""
get_conf_mock.return_value = '/tmp/pid_file'
open_mock.return_value = io.BytesIO(b'432')
self.assertEqual(432, self.controller.get_pid())
open_mock.assert_called_once_with('/tmp/pid_file')
@patch('stem.socket.ControlSocket.is_localhost', Mock(return_value = True))
@patch('stem.util.system.pid_by_name', Mock(return_value = 432))
def test_get_pid_by_name(self):
"""
Exercise the get_pid() resolution via the process name.
"""
self.assertEqual(432, self.controller.get_pid())
@patch('stem.control.Controller.get_info')
def test_get_network_status_for_ourselves(self, get_info_mock):
"""
Exercises the get_network_status() method for getting our own relay.
"""
# when there's an issue getting our fingerprint
get_info_mock.side_effect = ControllerError('nope, too bad')
exc_msg = 'Unable to determine our own fingerprint: nope, too bad'
self.assertRaisesRegexp(ControllerError, exc_msg, self.controller.get_network_status)
self.assertEqual('boom', self.controller.get_network_status(default = 'boom'))
# successful request
desc = NS_DESC % ('moria1', '/96bKo4soysolMgKn5Hex2nyFSY')
get_info_mock.side_effect = lambda param, **kwargs: {
'fingerprint': '9695DFC35FFEB861329B9F1AB04C46397020CE31',
'ns/id/9695DFC35FFEB861329B9F1AB04C46397020CE31': desc,
}[param]
self.assertEqual(stem.descriptor.router_status_entry.RouterStatusEntryV3(desc), self.controller.get_network_status())
@patch('stem.control.Controller.get_info')
def test_get_network_status_when_unavailable(self, get_info_mock):
"""
Exercises the get_network_status() method.
"""
get_info_mock.side_effect = InvalidArguments(None, 'GETINFO request contained unrecognized keywords: ns/id/5AC9C5AA75BA1F18D8459B326B4B8111A856D290')
exc_msg = "Tor was unable to provide the descriptor for '5AC9C5AA75BA1F18D8459B326B4B8111A856D290'"
self.assertRaisesRegexp(DescriptorUnavailable, exc_msg, self.controller.get_network_status, '5AC9C5AA75BA1F18D8459B326B4B8111A856D290')
@patch('stem.control.Controller.get_info')
def test_get_network_status(self, get_info_mock):
"""
Exercises the get_network_status() method.
"""
# build a single router status entry
nickname = 'Beaver'
fingerprint = '/96bKo4soysolMgKn5Hex2nyFSY'
desc = NS_DESC % (nickname, fingerprint)
router = stem.descriptor.router_status_entry.RouterStatusEntryV3(desc)
# always return the same router status entry
get_info_mock.return_value = desc
# pretend to get the router status entry with its name
self.assertEqual(router, self.controller.get_network_status(nickname))
# pretend to get the router status entry with its fingerprint
hex_fingerprint = stem.descriptor.router_status_entry._base64_to_hex(fingerprint, False)
self.assertEqual(router, self.controller.get_network_status(hex_fingerprint))
# mangle hex fingerprint and try again
hex_fingerprint = hex_fingerprint[2:]
self.assertRaises(ValueError, self.controller.get_network_status, hex_fingerprint)
# raise an exception in the get_info() call
get_info_mock.side_effect = InvalidArguments
# get a default value when the call fails
self.assertEqual(
'default returned',
self.controller.get_network_status(nickname, default = 'default returned')
)
# no default value, accept the error
self.assertRaises(InvalidArguments, self.controller.get_network_status, nickname)
@patch('stem.control.Controller.is_authenticated', Mock(return_value = True))
@patch('stem.control.Controller._attach_listeners', Mock(return_value = ([], [])))
@patch('stem.control.Controller.get_version')
def test_event_listening(self, get_version_mock):
"""
Exercises the add_event_listener and remove_event_listener methods.
"""
# set up for failure to create any events
get_version_mock.return_value = stem.version.Version('0.1.0.14')
self.assertRaises(InvalidRequest, self.controller.add_event_listener, Mock(), EventType.BW)
# set up to only fail newer events
get_version_mock.return_value = stem.version.Version('0.2.0.35')
# EventType.BW is one of the earliest events
self.controller.add_event_listener(Mock(), EventType.BW)
# EventType.SIGNAL was added in tor version 0.2.3.1-alpha
self.assertRaises(InvalidRequest, self.controller.add_event_listener, Mock(), EventType.SIGNAL)
def test_get_streams(self):
"""
Exercises the get_streams() method.
"""
# get a list of fake, but good looking, streams
valid_streams = (
('1', 'NEW', '4', '10.10.10.1:80'),
('2', 'SUCCEEDED', '4', '10.10.10.1:80'),
('3', 'SUCCEEDED', '4', '10.10.10.1:80')
)
response = ''.join(['%s\r\n' % ' '.join(entry) for entry in valid_streams])
with patch('stem.control.Controller.get_info', Mock(return_value = response)):
streams = self.controller.get_streams()
self.assertEqual(len(valid_streams), len(streams))
for index, stream in enumerate(streams):
self.assertEqual(valid_streams[index][0], stream.id)
self.assertEqual(valid_streams[index][1], stream.status)
self.assertEqual(valid_streams[index][2], stream.circ_id)
self.assertEqual(valid_streams[index][3], stream.target)
def test_attach_stream(self):
"""
Exercises the attach_stream() method.
"""
# Response when the stream is in a state where it can't be attached (for
# instance, it's already open).
response = stem.response.ControlMessage.from_str('555 Connection is not managed by controller.\r\n')
with patch('stem.control.Controller.msg', Mock(return_value = response)):
self.assertRaises(UnsatisfiableRequest, self.controller.attach_stream, 'stream_id', 'circ_id')
def test_parse_circ_path(self):
"""
Exercises the _parse_circ_path() helper function.
"""
# empty input
self.assertEqual([], _parse_circ_path(None))
self.assertEqual([], _parse_circ_path(''))
# check the pydoc examples
pydoc_examples = {
'$999A226EBED397F331B612FE1E4CFAE5C1F201BA=piyaz':
[('999A226EBED397F331B612FE1E4CFAE5C1F201BA', 'piyaz')],
'$E57A476CD4DFBD99B4EE52A100A58610AD6E80B9,hamburgerphone,PrivacyRepublic14':
[
('E57A476CD4DFBD99B4EE52A100A58610AD6E80B9', None),
(None, 'hamburgerphone'),
(None, 'PrivacyRepublic14'),
],
}
for test_input, expected in pydoc_examples.items():
self.assertEqual(expected, _parse_circ_path(test_input))
# exercise with some invalid inputs
malformed_inputs = [
'=piyaz', # no fingerprint
'999A226EBED397F331B612FE1E4CFAE5C1F201BA=piyaz', # fingerprint missing prefix
'$999A226EBED397F331B612FE1E4CFAE5C1F201BAA=piyaz', # fingerprint too long
'$999A226EBED397F331B612FE1E4CFAE5C1F201B=piyaz', # fingerprint too short
'$999A226EBED397F331B612FE1E4CFAE5C1F201Bz=piyaz', # invalid character in fingerprint
'$999A226EBED397F331B612FE1E4CFAE5C1F201BA=', # no nickname
]
for test_input in malformed_inputs:
self.assertRaises(ProtocolError, _parse_circ_path, test_input)
@patch('stem.control.Controller.get_conf')
def test_get_effective_rate(self, get_conf_mock):
"""
Exercise the get_effective_rate() method.
"""
# check default if nothing was set
get_conf_mock.side_effect = lambda param, **kwargs: {
'BandwidthRate': '1073741824',
'BandwidthBurst': '1073741824',
'RelayBandwidthRate': '0',
'RelayBandwidthBurst': '0',
'MaxAdvertisedBandwidth': '1073741824',
}[param]
self.assertEqual(1073741824, self.controller.get_effective_rate())
self.assertEqual(1073741824, self.controller.get_effective_rate(burst = True))
get_conf_mock.side_effect = ControllerError('nope, too bad')
self.assertRaises(ControllerError, self.controller.get_effective_rate)
self.assertEqual('my_default', self.controller.get_effective_rate('my_default'))
@patch('stem.control.Controller.get_version')
def test_drop_guards(self, get_version_mock):
"""
Exercises the drop_guards() method.
"""
get_version_mock.return_value = stem.version.Version('0.1.0.14')
self.assertRaises(UnsatisfiableRequest, self.controller.drop_guards)
with patch('stem.control.Controller.msg', Mock(return_value = None)):
get_version_mock.return_value = stem.version.Version('0.2.5.2')
self.controller.drop_guards()
stem-1.6.0/test/task.py 0000664 0001750 0001750 00000022012 13176650724 015513 0 ustar atagar atagar 0000000 0000000 # Copyright 2012-2017, Damian Johnson and The Tor Project
# See LICENSE for licensing information
"""
:class:`~test.task.Task` that can be ran with :func:`~test.task.run_tasks` to initialize our tests. tasks are...
::
Initialization Tasks
|- STEM_VERSION - checks our version of stem
|- TOR_VERSION - checks our version of tor
|- PYTHON_VERSION - checks our version of python
|- CRYPTO_VERSION - checks our version of cryptography
|- PYNACL_VERSION - checks our version of pynacl
|- MOCK_VERSION - checks our version of mock
|- PYFLAKES_VERSION - checks our version of pyflakes
|- PYCODESTYLE_VERSION - checks our version of pycodestyle
|- CLEAN_PYC - removes any *.pyc without a corresponding *.py
|- IMPORT_TESTS - ensure all test modules have been imported
|- UNUSED_TESTS - checks to see if any tests are missing from our settings
|- PYFLAKES_TASK - static checks
+- PYCODESTYLE_TASK - style checks
"""
import os
import re
import sys
import time
import stem
import stem.prereq
import stem.util.conf
import stem.util.system
import stem.util.test_tools
import stem.version
import test
import test.output
from test.output import STATUS, ERROR, NO_NL, println
try:
# TODO: remove check when dropping python 2.6 support
import importlib
HAS_IMPORTLIB = True
except ImportError:
HAS_IMPORTLIB = False
CONFIG = stem.util.conf.config_dict('test', {
'integ.test_directory': './test/data',
'test.unit_tests': '',
'test.integ_tests': '',
})
SRC_PATHS = [os.path.join(test.STEM_BASE, path) for path in (
'stem',
'test',
'run_tests.py',
'cache_manual.py',
'cache_fallback_directories.py',
'setup.py',
'tor-prompt',
os.path.join('docs', 'republish.py'),
os.path.join('docs', 'roles.py'),
)]
PYFLAKES_UNAVAILABLE = 'Static error checking requires pyflakes version 0.7.3 or later. Please install it from ...\n http://pypi.python.org/pypi/pyflakes\n'
PYCODESTYLE_UNAVAILABLE = 'Style checks require pycodestyle version 1.4.2 or later. Please install it from...\n http://pypi.python.org/pypi/pycodestyle\n'
def _check_tor_version(tor_path):
return str(test.tor_version(tor_path)).split()[0]
def _clean_orphaned_pyc(paths):
"""
Deletes any file with a *.pyc extention without a corresponding *.py.
:param list paths: paths to search for orphaned pyc files
"""
return ['removed %s' % path for path in stem.util.test_tools.clean_orphaned_pyc(paths)]
def _import_tests():
"""
Ensure all tests have been imported. This is important so tests can
register if they're asynchronous.
"""
if not HAS_IMPORTLIB:
return
for module in (CONFIG['test.unit_tests'].splitlines() + CONFIG['test.integ_tests'].splitlines()):
importlib.import_module(module.rsplit('.', 1)[0])
def _check_for_unused_tests(paths):
"""
The 'test.unit_tests' and 'test.integ_tests' in our settings.cfg defines the
tests that we run. We do it this way so that we can control the order in
which our tests are run but there's a disadvantage: when we add new test
modules we can easily forget to add it there.
Checking to see if we have any unittest.TestCase subclasses not covered by
our settings.
:param list paths: paths to search for unused tests
"""
unused_tests = []
for path in paths:
for py_path in stem.util.system.files_with_suffix(path, '.py'):
if os.path.normpath(CONFIG['integ.test_directory']) in py_path:
continue
with open(py_path) as f:
file_contents = f.read()
test_match = re.search('^class (\S*)\(unittest.TestCase\):$', file_contents, re.MULTILINE)
if test_match:
class_name = test_match.groups()[0]
module_name = py_path.replace(os.path.sep, '.')[len(test.STEM_BASE) + 1:-3] + '.' + class_name
if not (module_name in CONFIG['test.unit_tests'] or module_name in CONFIG['test.integ_tests']):
unused_tests.append(module_name)
if unused_tests:
raise ValueError('Test modules are missing from our test/settings.cfg:\n%s' % '\n'.join(unused_tests))
def run(category, *tasks):
"""
Runs a series of :class:`test.Task` instances. This simply prints 'done'
or 'failed' for each unless we fail one that is marked as being required. If
that happens then we print its error message and call sys.exit().
:param str category: label for the series of tasks
:param list tasks: **Task** instances to be ran
"""
test.output.print_divider(category, True)
for task in tasks:
if task is None:
continue
task.run()
if task.is_required and task.error:
println('\n%s\n' % task.error, ERROR)
sys.exit(1)
println()
class Task(object):
"""
Task we can process while running our tests. The runner can return either a
message or list of strings for its results.
"""
def __init__(self, label, runner, args = None, is_required = True, print_result = True, print_runtime = False, background = False):
super(Task, self).__init__()
self.label = label
self.runner = runner
self.args = args
self.is_required = is_required
self.print_result = print_result
self.print_runtime = print_runtime
self.error = None
self.is_successful = False
self.result = None
self._is_background_task = background
self._background_process = None
def run(self):
start_time = time.time()
println(' %s...' % self.label, STATUS, NO_NL)
padding = 50 - len(self.label)
println(' ' * padding, NO_NL)
try:
if self._is_background_task:
self._background_process = stem.util.system.DaemonTask(self.runner, self.args, start = True)
else:
self.result = self.runner(*self.args) if self.args else self.runner()
self.is_successful = True
output_msg = 'running' if self._is_background_task else 'done'
if self.result and self.print_result and isinstance(self.result, str):
output_msg = self.result
elif self.print_runtime:
output_msg += ' (%0.1fs)' % (time.time() - start_time)
println(output_msg, STATUS)
if self.print_result and isinstance(self.result, (list, tuple)):
for line in self.result:
println(' %s' % line, STATUS)
except Exception as exc:
output_msg = str(exc)
if not output_msg or self.is_required:
output_msg = 'failed'
println(output_msg, ERROR)
self.error = exc
def join(self):
if self._background_process:
self.result = self._background_process.join()
class ModuleVersion(Task):
def __init__(self, label, modules, prereq_check = None):
if isinstance(modules, str):
modules = [modules] # normalize to a list
def version_check():
if prereq_check is None or prereq_check():
for module in modules:
if HAS_IMPORTLIB and stem.util.test_tools._module_exists(module):
return importlib.import_module(module).__version__
return 'missing'
super(ModuleVersion, self).__init__(label, version_check)
class StaticCheckTask(Task):
def __init__(self, label, runner, args = None, is_available = None, unavailable_msg = None, background = True):
super(StaticCheckTask, self).__init__(label, runner, args, is_required = False, print_result = False, print_runtime = not background, background = background)
self.is_available = is_available
self.unavailable_msg = unavailable_msg
def run(self):
if self.is_available:
return super(StaticCheckTask, self).run()
else:
println(' %s...' % self.label, STATUS, NO_NL)
println(' ' * (50 - len(self.label)), NO_NL)
println('unavailable', STATUS)
STEM_VERSION = Task('checking stem version', lambda: stem.__version__)
TOR_VERSION = Task('checking tor version', _check_tor_version)
PYTHON_VERSION = Task('checking python version', lambda: '.'.join(map(str, sys.version_info[:3])))
CRYPTO_VERSION = ModuleVersion('checking cryptography version', 'cryptography', stem.prereq.is_crypto_available)
PYNACL_VERSION = ModuleVersion('checking pynacl version', 'nacl', stem.prereq._is_pynacl_available)
MOCK_VERSION = ModuleVersion('checking mock version', ['unittest.mock', 'mock'], stem.prereq.is_mock_available)
PYFLAKES_VERSION = ModuleVersion('checking pyflakes version', 'pyflakes')
PYCODESTYLE_VERSION = ModuleVersion('checking pycodestyle version', ['pycodestyle', 'pep8'])
CLEAN_PYC = Task('checking for orphaned .pyc files', _clean_orphaned_pyc, (SRC_PATHS,), print_runtime = True)
IMPORT_TESTS = Task('importing test modules', _import_tests, print_runtime = True)
UNUSED_TESTS = Task('checking for unused tests', _check_for_unused_tests, [(
os.path.join(test.STEM_BASE, 'test', 'unit'),
os.path.join(test.STEM_BASE, 'test', 'integ'),
)], print_runtime = True)
PYFLAKES_TASK = StaticCheckTask(
'running pyflakes',
stem.util.test_tools.pyflakes_issues,
args = (SRC_PATHS,),
is_available = stem.util.test_tools.is_pyflakes_available(),
unavailable_msg = PYFLAKES_UNAVAILABLE,
)
PYCODESTYLE_TASK = StaticCheckTask(
'running pycodestyle',
stem.util.test_tools.stylistic_issues,
args = (SRC_PATHS, True, True, True),
is_available = stem.util.test_tools.is_pycodestyle_available(),
unavailable_msg = PYCODESTYLE_UNAVAILABLE,
)
stem-1.6.0/test/integ/ 0000775 0001750 0001750 00000000000 13177674754 015322 5 ustar atagar atagar 0000000 0000000 stem-1.6.0/test/integ/manual.py 0000664 0001750 0001750 00000035763 13177427502 017152 0 ustar atagar atagar 0000000 0000000 """
Integ testing for the stem.manual module, fetching the latest man page from the
tor git repository and checking for new additions.
"""
import codecs
import os
import tempfile
import unittest
import stem.manual
import stem.util.system
import test
import test.runner
from stem.manual import Category
EXPECTED_CATEGORIES = set([
'NAME',
'SYNOPSIS',
'DESCRIPTION',
'COMMAND-LINE OPTIONS',
'THE CONFIGURATION FILE FORMAT',
'GENERAL OPTIONS',
'CLIENT OPTIONS',
'SERVER OPTIONS',
'DIRECTORY SERVER OPTIONS',
'DIRECTORY AUTHORITY SERVER OPTIONS',
'HIDDEN SERVICE OPTIONS',
'TESTING NETWORK OPTIONS',
'NON-PERSISTENT OPTIONS',
'SIGNALS',
'FILES',
'SEE ALSO',
'BUGS',
'AUTHORS',
])
EXPECTED_CLI_OPTIONS = set(['-f FILE', '--hash-password PASSWORD', '--ignore-missing-torrc', '--defaults-torrc FILE', '--key-expiration [purpose]', '--list-fingerprint', '--list-deprecated-options', '--allow-missing-torrc', '--nt-service', '--verify-config', '--service remove|start|stop', '--passphrase-fd FILEDES', '--keygen [--newpass]', '--list-torrc-options', '--service install [--options command-line options]', '--quiet|--hush', '--version', '-h, -help'])
EXPECTED_SIGNALS = set(['SIGTERM', 'SIGINT', 'SIGHUP', 'SIGUSR1', 'SIGUSR2', 'SIGCHLD', 'SIGPIPE', 'SIGXFSZ'])
EXPECTED_DESCRIPTION = """
Tor is a connection-oriented anonymizing communication service. Users choose a source-routed path through a set of nodes, and negotiate a "virtual circuit" through the network, in which each node knows its predecessor and successor, but no others. Traffic flowing down the circuit is unwrapped by a symmetric key at each node, which reveals the downstream node.
Basically, Tor provides a distributed network of servers or relays ("onion routers"). Users bounce their TCP streams -- web traffic, ftp, ssh, etc. -- around the network, and recipients, observers, and even the relays themselves have difficulty tracking the source of the stream.
By default, tor will act as a client only. To help the network by providing bandwidth as a relay, change the ORPort configuration option -- see below. Please also consult the documentation on the Tor Project's website.
""".strip()
EXPECTED_FILE_DESCRIPTION = 'Specify a new configuration file to contain further Tor configuration options OR pass - to make Tor read its configuration from standard input. (Default: @CONFDIR@/torrc, or $HOME/.torrc if that file is not found)'
EXPECTED_BANDWIDTH_RATE_DESCRIPTION = 'A token bucket limits the average incoming bandwidth usage on this node to the specified number of bytes per second, and the average outgoing bandwidth usage to that same value. If you want to run a relay in the public network, this needs to be at the very least 75 KBytes for a relay (that is, 600 kbits) or 50 KBytes for a bridge (400 kbits) -- but of course, more is better; we recommend at least 250 KBytes (2 mbits) if possible. (Default: 1 GByte)\n\nNote that this option, and other bandwidth-limiting options, apply to TCP data only: They do not count TCP headers or DNS traffic.\n\nWith this option, and in other options that take arguments in bytes, KBytes, and so on, other formats are also supported. Notably, "KBytes" can also be written as "kilobytes" or "kb"; "MBytes" can be written as "megabytes" or "MB"; "kbits" can be written as "kilobits"; and so forth. Tor also accepts "byte" and "bit" in the singular. The prefixes "tera" and "T" are also recognized. If no units are given, we default to bytes. To avoid confusion, we recommend writing "bytes" or "bits" explicitly, since it\'s easy to forget that "B" means bytes, not bits.'
EXPECTED_EXIT_POLICY_DESCRIPTION = """
Set an exit policy for this server. Each policy is of the form "accept[6]|reject[6] ADDR[/MASK][:PORT]". If /MASK is omitted then this policy just applies to the host given. Instead of giving a host or network you can also use "*" to denote the universe (0.0.0.0/0 and ::/128), or *4 to denote all IPv4 addresses, and *6 to denote all IPv6 addresses. PORT can be a single port number, an interval of ports "FROM_PORT-TO_PORT", or "*". If PORT is omitted, that means "*".
For example, "accept 18.7.22.69:*,reject 18.0.0.0/8:*,accept *:*" would reject any IPv4 traffic destined for MIT except for web.mit.edu, and accept any other IPv4 or IPv6 traffic.
Tor also allows IPv6 exit policy entries. For instance, "reject6 [FC00::]/7:*" rejects all destinations that share 7 most significant bit prefix with address FC00::. Respectively, "accept6 [C000::]/3:*" accepts all destinations that share 3 most significant bit prefix with address C000::.
accept6 and reject6 only produce IPv6 exit policy entries. Using an IPv4 address with accept6 or reject6 is ignored and generates a warning. accept/reject allows either IPv4 or IPv6 addresses. Use *4 as an IPv4 wildcard address, and *6 as an IPv6 wildcard address. accept/reject * expands to matching IPv4 and IPv6 wildcard address rules.
To specify all IPv4 and IPv6 internal and link-local networks (including 0.0.0.0/8, 169.254.0.0/16, 127.0.0.0/8, 192.168.0.0/16, 10.0.0.0/8, 172.16.0.0/12, [::]/8, [FC00::]/7, [FE80::]/10, [FEC0::]/10, [FF00::]/8, and [::]/127), you can use the "private" alias instead of an address. ("private" always produces rules for IPv4 and IPv6 addresses, even when used with accept6/reject6.)
Private addresses are rejected by default (at the beginning of your exit policy), along with any configured primary public IPv4 and IPv6 addresses. These private addresses are rejected unless you set the ExitPolicyRejectPrivate config option to 0. For example, once you've done that, you could allow HTTP to 127.0.0.1 and block all other connections to internal networks with "accept 127.0.0.1:80,reject private:*", though that may also allow connections to your own computer that are addressed to its public (external) IP address. See RFC 1918 and RFC 3330 for more details about internal and reserved IP address space. See ExitPolicyRejectLocalInterfaces if you want to block every address on the relay, even those that aren't advertised in the descriptor.
This directive can be specified multiple times so you don't have to put it all on one line.
Policies are considered first to last, and the first match wins. If you want to allow the same ports on IPv4 and IPv6, write your rules using accept/reject *. If you want to allow different ports on IPv4 and IPv6, write your IPv6 rules using accept6/reject6 *6, and your IPv4 rules using accept/reject *4. If you want to _replace_ the default exit policy, end your exit policy with either a reject *:* or an accept *:*. Otherwise, you're _augmenting_ (prepending to) the default exit policy. The default exit policy is:
reject *:25
reject *:119
reject *:135-139
reject *:445
reject *:563
reject *:1214
reject *:4661-4666
reject *:6346-6429
reject *:6699
reject *:6881-6999
accept *:*
Since the default exit policy uses accept/reject *, it applies to both IPv4 and IPv6 addresses.
""".strip()
class TestManual(unittest.TestCase):
# TODO: remove when dropping support for python 2.6
skip_reason = 'setUpClass() unsupported in python 2.6'
@classmethod
def setUpClass(self):
self.man_path = None
self.man_content = None
self.skip_reason = None
self.download_error = None
if stem.util.system.is_windows():
self.skip_reason = '(unavailable on windows)'
elif test.Target.ONLINE not in test.runner.get_runner().attribute_targets:
self.skip_reason = '(requires online target)'
elif not stem.util.system.is_available('a2x'):
self.skip_reason = '(requires asciidoc)'
else:
try:
with tempfile.NamedTemporaryFile(prefix = 'tor_man_page.', delete = False) as tmp:
stem.manual.download_man_page(file_handle = tmp)
self.man_path = tmp.name
man_cmd = 'man %s -P cat %s' % ('' if not stem.manual.HAS_ENCODING_ARG else '--encoding=ascii', self.man_path)
self.man_content = stem.util.system.call(man_cmd, env = {'MANWIDTH': '10000000'})
except Exception as exc:
self.download_error = 'Unable to download the man page: %s' % exc
@classmethod
def tearDownClass(self):
if self.man_path and os.path.exists(self.man_path):
os.remove(self.man_path)
def requires_downloaded_manual(self):
if self.skip_reason:
self.skipTest(self.skip_reason)
return True
elif self.download_error:
self.fail(self.download_error)
return False
def test_escapes_non_ascii(self):
"""
Check that our manual parser escapes all non-ascii characters. If this
fails then that means someone probably added a new type of non-ascii
character. Easy to fix: please simply add an escape for it in
stem/manual.py's _get_categories().
"""
if self.requires_downloaded_manual():
return
def check(content):
try:
codecs.ascii_encode(content, 'strict')
except UnicodeEncodeError as exc:
self.fail("Unable to read '%s' as ascii: %s" % (content, exc))
categories = stem.manual._get_categories(self.man_content)
for category, lines in categories.items():
check(category)
for line in lines:
check(line)
def test_parsing_with_indented_lines(self):
"""
Our ExitPolicy's description is an interesting one for our parser in that
it has indented lines within it. Ensure we parse this correctly.
"""
if self.requires_downloaded_manual():
return
manual = stem.manual.Manual.from_man(self.man_path)
self.assertEqual(EXPECTED_EXIT_POLICY_DESCRIPTION, manual.config_options['ExitPolicy'].description)
def test_that_cache_is_up_to_date(self):
"""
Check if the cached manual information bundled with Stem is up to date or not.
"""
if self.requires_downloaded_manual():
return
cached_manual = stem.manual.Manual.from_cache()
latest_manual = stem.manual.Manual.from_man(self.man_path)
if cached_manual != latest_manual:
self.fail("Stem's cached manual information is out of date. Please run 'cache_manual.py'...\n\n%s" % stem.manual._manual_differences(cached_manual, latest_manual))
def test_attributes(self):
"""
General assertions against a few manual fields. If you update tor's manual
then go ahead and simply update these assertions.
"""
if self.requires_downloaded_manual():
return
def assert_equal(category, expected, actual):
if expected != actual:
self.fail("Changed tor's man page? The %s changed as follows...\n\nexpected: %s\n\nactual: %s" % (category, expected, actual))
manual = stem.manual.Manual.from_man(self.man_path)
assert_equal('name', 'tor - The second-generation onion router', manual.name)
assert_equal('synopsis', 'tor [OPTION value]...', manual.synopsis)
assert_equal('description', EXPECTED_DESCRIPTION, manual.description)
assert_equal('commandline options', EXPECTED_CLI_OPTIONS, set(manual.commandline_options.keys()))
assert_equal('help option', 'Display a short help message and exit.', manual.commandline_options['-h, -help'])
assert_equal('file option', EXPECTED_FILE_DESCRIPTION, manual.commandline_options['-f FILE'])
assert_equal('signals', EXPECTED_SIGNALS, set(manual.signals.keys()))
assert_equal('sighup description', 'Tor will catch this, clean up and sync to disk if necessary, and exit.', manual.signals['SIGTERM'])
assert_equal('number of files', 50, len(manual.files))
assert_equal('lib path description', 'The tor process stores keys and other data here.', manual.files['@LOCALSTATEDIR@/lib/tor/'])
for category in Category:
if len([entry for entry in manual.config_options.values() if entry.category == category]) == 0 and category != Category.UNKNOWN:
self.fail('We had an empty %s section, did we intentionally drop it?' % category)
unknown_options = [entry for entry in manual.config_options.values() if entry.category == Category.UNKNOWN]
if unknown_options:
self.fail("We don't recognize the category for the %s options. Maybe a new man page section? If so then please update the Category enum in stem/manual.py." % ', '.join(unknown_options))
option = manual.config_options['BandwidthRate']
self.assertEqual(Category.GENERAL, option.category)
self.assertEqual('BandwidthRate', option.name)
self.assertEqual('N bytes|KBytes|MBytes|GBytes|TBytes|KBits|MBits|GBits|TBits', option.usage)
self.assertEqual('Average bandwidth usage limit', option.summary)
self.assertEqual(EXPECTED_BANDWIDTH_RATE_DESCRIPTION, option.description)
def test_has_all_categories(self):
"""
Check that the categories in tor's manual matches what we expect. If these
change then we likely want to add/remove attributes from Stem's Manual
class to match.
"""
if self.requires_downloaded_manual():
return
categories = stem.manual._get_categories(self.man_content)
present = set(categories.keys())
missing_categories = EXPECTED_CATEGORIES.difference(present)
extra_categories = present.difference(EXPECTED_CATEGORIES)
if missing_categories:
self.fail("Changed tor's man page? We expected the %s man page sections but they're no longer around. Might need to update our Manual class." % ', '.join(missing_categories))
elif extra_categories:
self.fail("Changed tor's man page? We weren't expecting the %s man page sections. Might need to update our Manual class." % ', '.join(extra_categories))
self.assertEqual(['tor - The second-generation onion router'], categories['NAME'])
self.assertEqual(['tor [OPTION value]...'], categories['SYNOPSIS'])
def test_has_all_tor_config_options(self):
"""
Check that all the configuration options tor supports are in the man page.
"""
if self.requires_downloaded_manual():
return
with test.runner.get_runner().get_tor_controller() as controller:
config_options_in_tor = set([line.split()[0] for line in controller.get_info('config/names').splitlines() if line.split()[1] != 'Virtual'])
# options starting with an underscore are hidden by convention
for name in list(config_options_in_tor):
if name.startswith('_'):
config_options_in_tor.remove(name)
# TODO: Looks like options we should remove from tor...
#
# https://trac.torproject.org/projects/tor/ticket/17665
for option in ('SchedulerMaxFlushCells__', 'SchedulerLowWaterMark__', 'SchedulerHighWaterMark__'):
if option in config_options_in_tor:
config_options_in_tor.remove(option)
manual = stem.manual.Manual.from_man(self.man_path)
config_options_in_manual = set(manual.config_options.keys())
missing_from_manual = config_options_in_tor.difference(config_options_in_manual)
if missing_from_manual:
self.fail("The %s config options supported by tor isn't in its man page. Maybe we need to add them?" % ', '.join(missing_from_manual))
extra_in_manual = config_options_in_manual.difference(config_options_in_tor)
if extra_in_manual:
self.fail("The %s config options in our man page aren't presently supported by tor. Are we using the latest git commit of tor? If so, maybe we need to remove them?" % ', '.join(extra_in_manual))
stem-1.6.0/test/integ/__init__.py 0000664 0001750 0001750 00000000252 13115423200 017374 0 ustar atagar atagar 0000000 0000000 """
Integration tests for the stem library.
"""
__all__ = [
'connection',
'control',
'descriptor',
'response',
'socket',
'util',
'process',
'version',
]
stem-1.6.0/test/integ/version.py 0000664 0001750 0001750 00000002757 13124757510 017354 0 ustar atagar atagar 0000000 0000000 """
Tests that the stem.version functions can handle the tor instance we're
running with.
"""
import unittest
import stem.prereq
import stem.version
import test.require
import test.runner
class TestVersion(unittest.TestCase):
@test.require.command('tor')
def test_get_system_tor_version(self):
"""
Basic verification checks for the get_system_tor_version() function.
"""
# Since tor is in our path we should expect to be able to get the version
# that way, though this might not belong to our test instance (if we're
# running against a specific tor binary).
stem.version.get_system_tor_version()
# try running against a command that exists, but isn't tor
self.assertRaises(IOError, stem.version.get_system_tor_version, 'ls')
# try running against a command that doesn't exist
self.assertRaises(IOError, stem.version.get_system_tor_version, 'blarg')
@test.require.controller
def test_getinfo_version_parsing(self):
"""
Issues a 'GETINFO version' query to our test instance and makes sure that
we can parse it.
"""
control_socket = test.runner.get_runner().get_tor_socket()
control_socket.send('GETINFO version')
version_response = control_socket.recv()
control_socket.close()
# the getinfo response looks like...
# 250-version=0.2.3.10-alpha-dev (git-65420e4cb5edcd02)
# 250 OK
tor_version = list(version_response)[0]
tor_version = tor_version[8:].split(' ', 1)[0]
stem.version.Version(tor_version)
stem-1.6.0/test/integ/response/ 0000775 0001750 0001750 00000000000 13177674754 017160 5 ustar atagar atagar 0000000 0000000 stem-1.6.0/test/integ/response/__init__.py 0000664 0001750 0001750 00000000111 13115423200 021224 0 ustar atagar atagar 0000000 0000000 """
Integration tests for stem.response.
"""
__all__ = ['protocolinfo']
stem-1.6.0/test/integ/response/protocolinfo.py 0000664 0001750 0001750 00000012414 13124757510 022231 0 ustar atagar atagar 0000000 0000000 """
Integration tests for the stem.response.protocolinfo.ProtocolInfoResponse class
and related functions.
"""
import unittest
import stem.connection
import stem.socket
import stem.util.system
import stem.version
import test
import test.integ.util.system
import test.require
import test.runner
try:
# added in python 3.3
from unittest.mock import Mock, patch
except ImportError:
from mock import Mock, patch
class TestProtocolInfo(unittest.TestCase):
@test.require.controller
def test_parsing(self):
"""
Makes a PROTOCOLINFO query and processes the response for our control
connection.
"""
control_socket = test.runner.get_runner().get_tor_socket(False)
control_socket.send('PROTOCOLINFO 1')
protocolinfo_response = control_socket.recv()
stem.response.convert('PROTOCOLINFO', protocolinfo_response)
control_socket.close()
# according to the control spec the following _could_ differ or be
# undefined but if that actually happens then it's gonna make people sad
self.assertEqual(1, protocolinfo_response.protocol_version)
self.assertNotEqual(None, protocolinfo_response.tor_version)
self.assertNotEqual(None, protocolinfo_response.auth_methods)
self.assert_matches_test_config(protocolinfo_response)
@test.require.controller
@patch('stem.util.proc.is_available', Mock(return_value = False))
@patch('stem.util.system.is_available', Mock(return_value = True))
def test_get_protocolinfo_path_expansion(self):
"""
If we're running with the 'RELATIVE' target then test_parsing() will
exercise cookie path expansion when we're able to query the pid by our
prcess name. This test selectively disables system.call() so we exercise
the expansion via our control port or socket file.
This test is largely redundant with test_parsing() if we aren't running
with the 'RELATIVE' target.
"""
if test.runner.Torrc.PORT in test.runner.get_runner().get_options():
lookup_prefixes = (
stem.util.system.GET_PID_BY_PORT_NETSTAT,
stem.util.system.GET_PID_BY_PORT_SOCKSTAT % '',
stem.util.system.GET_PID_BY_PORT_LSOF,
stem.util.system.GET_CWD_PWDX % '',
'lsof -a -p ')
control_socket = stem.socket.ControlPort(port = test.runner.CONTROL_PORT)
else:
lookup_prefixes = (
stem.util.system.GET_PID_BY_FILE_LSOF % '',
stem.util.system.GET_CWD_PWDX % '',
'lsof -a -p ')
control_socket = stem.socket.ControlSocketFile(test.runner.CONTROL_SOCKET_PATH)
call_replacement = test.integ.util.system.filter_system_call(lookup_prefixes)
with patch('stem.util.system.call') as call_mock:
call_mock.side_effect = call_replacement
protocolinfo_response = stem.connection.get_protocolinfo(control_socket)
self.assert_matches_test_config(protocolinfo_response)
# we should have a usable socket at this point
self.assertTrue(control_socket.is_alive())
control_socket.close()
@test.require.controller
def test_multiple_protocolinfo_calls(self):
"""
Tests making repeated PROTOCOLINFO queries. This use case is interesting
because tor will shut down the socket and stem should transparently
re-establish it.
"""
with test.runner.get_runner().get_tor_socket(False) as control_socket:
for _ in range(5):
protocolinfo_response = stem.connection.get_protocolinfo(control_socket)
self.assert_matches_test_config(protocolinfo_response)
@test.require.controller
def test_pre_disconnected_query(self):
"""
Tests making a PROTOCOLINFO query when previous use of the socket had
already disconnected it.
"""
with test.runner.get_runner().get_tor_socket(False) as control_socket:
# makes a couple protocolinfo queries outside of get_protocolinfo first
control_socket.send('PROTOCOLINFO 1')
control_socket.recv()
control_socket.send('PROTOCOLINFO 1')
control_socket.recv()
protocolinfo_response = stem.connection.get_protocolinfo(control_socket)
self.assert_matches_test_config(protocolinfo_response)
def assert_matches_test_config(self, protocolinfo_response):
"""
Makes assertions that the protocolinfo response's attributes match those of
the test configuration.
"""
runner = test.runner.get_runner()
tor_options = runner.get_options()
auth_methods, auth_cookie_path = [], None
if test.runner.Torrc.COOKIE in tor_options:
auth_methods.append(stem.response.protocolinfo.AuthMethod.COOKIE)
if test.tor_version() >= stem.version.Requirement.AUTH_SAFECOOKIE:
auth_methods.append(stem.response.protocolinfo.AuthMethod.SAFECOOKIE)
chroot_path = runner.get_chroot()
auth_cookie_path = runner.get_auth_cookie_path()
if chroot_path and auth_cookie_path.startswith(chroot_path):
auth_cookie_path = auth_cookie_path[len(chroot_path):]
if test.runner.Torrc.PASSWORD in tor_options:
auth_methods.append(stem.response.protocolinfo.AuthMethod.PASSWORD)
if not auth_methods:
auth_methods.append(stem.response.protocolinfo.AuthMethod.NONE)
self.assertEqual((), protocolinfo_response.unknown_auth_methods)
self.assertEqual(tuple(auth_methods), protocolinfo_response.auth_methods)
self.assertEqual(auth_cookie_path, protocolinfo_response.cookie_path)
stem-1.6.0/test/integ/descriptor/ 0000775 0001750 0001750 00000000000 13177674754 017500 5 ustar atagar atagar 0000000 0000000 stem-1.6.0/test/integ/descriptor/microdescriptor.py 0000664 0001750 0001750 00000002176 13124757510 023250 0 ustar atagar atagar 0000000 0000000 """
Integration tests for stem.descriptor.microdescriptor.
"""
import os
import unittest
import stem.descriptor
import stem.util.test_tools
import test
from stem.util.test_tools import asynchronous
class TestMicrodescriptor(unittest.TestCase):
@staticmethod
def run_tests(args):
stem.util.test_tools.ASYNC_TESTS['test.integ.descriptor.microdescriptor.test_cached_microdescriptors'].run(args.test_dir, threaded = True)
@asynchronous
def test_cached_microdescriptors(test_dir):
"""
Parses the cached microdescriptor file in our data directory, checking that
it doesn't raise any validation issues and looking for unrecognized
descriptor additions.
"""
descriptor_path = os.path.join(test_dir, 'cached-microdescs')
if not os.path.exists(descriptor_path):
raise stem.util.test_tools.SkipTest('(no cached descriptors)')
with open(descriptor_path, 'rb') as descriptor_file:
for desc in stem.descriptor.parse_file(descriptor_file, 'microdescriptor 1.0', validate = True):
for line in desc.get_unrecognized_lines():
test.register_new_capability('Microdescriptor Line', line)
stem-1.6.0/test/integ/descriptor/__init__.py 0000664 0001750 0001750 00000000255 13124757510 021573 0 ustar atagar atagar 0000000 0000000 """
Integration tests for stem.descriptor.* contents.
"""
__all__ = [
'extrainfo_descriptor',
'microdescriptor',
'networkstatus',
'remote'
'server_descriptor',
]
stem-1.6.0/test/integ/descriptor/remote.py 0000664 0001750 0001750 00000022645 13124757510 021336 0 ustar atagar atagar 0000000 0000000 """
Integration tests for stem.descriptor.remote.
"""
import unittest
import stem.descriptor
import stem.descriptor.extrainfo_descriptor
import stem.descriptor.networkstatus
import stem.descriptor.remote
import stem.descriptor.router_status_entry
import stem.descriptor.server_descriptor
import test.require
class TestDescriptorDownloader(unittest.TestCase):
@test.require.only_run_once
@test.require.online
def test_shorthand_aliases(self):
"""
Quick sanity test that we can call our shorthand aliases for getting
descriptors.
"""
desc = list(stem.descriptor.remote.get_server_descriptors('9695DFC35FFEB861329B9F1AB04C46397020CE31').run())[0]
self.assertEqual('moria1', desc.nickname)
desc = list(stem.descriptor.remote.get_extrainfo_descriptors('9695DFC35FFEB861329B9F1AB04C46397020CE31').run())[0]
self.assertEqual('moria1', desc.nickname)
consensus = list(stem.descriptor.remote.get_consensus())
self.assertTrue(len(consensus) > 50)
@test.require.only_run_once
@test.require.online
def test_authorities_are_up_to_date(self):
"""
Check that our hardcoded directory authority data matches the present
consensus.
"""
downloader = stem.descriptor.remote.DescriptorDownloader()
consensus = downloader.get_consensus(document_handler = stem.descriptor.DocumentHandler.BARE_DOCUMENT).run()[0]
for auth in consensus.directory_authorities:
if auth.nickname == 'dannenberg-legacy':
continue # skip due to https://trac.torproject.org/projects/tor/ticket/17906
stem_auth = stem.descriptor.remote.get_authorities().get(auth.nickname)
if not stem_auth:
self.fail("%s isn't a recognized directory authority in stem" % auth.nickname)
for attr in ('v3ident', 'or_port', 'dir_port'):
if auth.nickname == 'moria1' and attr == 'address':
continue # skip due to https://trac.torproject.org/projects/tor/ticket/14955
if getattr(auth, attr) != getattr(stem_auth, attr):
self.fail('%s has %s %s, but we expected %s' % (auth.nickname, attr, getattr(auth, attr), getattr(stem_auth, attr)))
@test.require.only_run_once
@test.require.online
def test_using_authorities(self):
"""
Fetches a descriptor from each of the directory authorities. This is
intended to check that DIRECTORY_AUTHORITIES is still up to date (that
addresses and ports haven't changed).
This is hardcoded to fetch moria1's descriptor. If its fingerprint changes
then this test will need to be updated.
"""
queries = []
for nickname, authority in stem.descriptor.remote.get_authorities().items():
queries.append((stem.descriptor.remote.Query(
'/tor/server/fp/9695DFC35FFEB861329B9F1AB04C46397020CE31',
'server-descriptor 1.0',
endpoints = [(authority.address, authority.dir_port)],
timeout = 30,
validate = True,
), authority))
for query, authority in queries:
try:
descriptors = list(query.run())
except Exception as exc:
self.fail('Unable to use %s (%s:%s, %s): %s' % (authority.nickname, authority.address, authority.dir_port, type(exc), exc))
self.assertEqual(1, len(descriptors))
self.assertEqual('moria1', descriptors[0].nickname)
@test.require.only_run_once
@test.require.online
def test_use_directory_mirrors(self):
"""
Checks that we can fetch and use a list of directory mirrors.
"""
downloader = stem.descriptor.remote.DescriptorDownloader()
downloader.use_directory_mirrors()
self.assertTrue(len(downloader._endpoints) > 50)
@test.require.only_run_once
@test.require.online
def test_get_server_descriptors(self):
"""
Exercises the downloader's get_server_descriptors() method.
"""
downloader = stem.descriptor.remote.DescriptorDownloader(validate = True)
# Fetch a single descriptor and a batch. I'd love to also exercise
# retrieving all descriptors, but that adds roughly a minute to the runtime
# of this test and adds an appreciable load to directory authorities.
single_query = downloader.get_server_descriptors('9695DFC35FFEB861329B9F1AB04C46397020CE31')
multiple_query = downloader.get_server_descriptors([
'9695DFC35FFEB861329B9F1AB04C46397020CE31',
'847B1F850344D7876491A54892F904934E4EB85D',
])
# Explicitly running the queries so they'll provide a useful error if
# unsuccessful.
single_query.run()
multiple_query.run()
single_query_results = list(single_query)
self.assertEqual(1, len(single_query_results))
self.assertEqual('moria1', single_query_results[0].nickname)
self.assertTrue(isinstance(single_query_results[0], stem.descriptor.stem.descriptor.server_descriptor.ServerDescriptor))
self.assertEqual(2, len(list(multiple_query)))
@test.require.only_run_once
@test.require.online
def test_get_extrainfo_descriptors(self):
"""
Exercises the downloader's get_extrainfo_descriptors() method.
"""
downloader = stem.descriptor.remote.DescriptorDownloader(validate = True)
single_query = downloader.get_extrainfo_descriptors('9695DFC35FFEB861329B9F1AB04C46397020CE31')
multiple_query = downloader.get_extrainfo_descriptors([
'9695DFC35FFEB861329B9F1AB04C46397020CE31',
'847B1F850344D7876491A54892F904934E4EB85D',
])
single_query.run()
multiple_query.run()
single_query_results = list(single_query)
self.assertEqual(1, len(single_query_results))
self.assertEqual('moria1', single_query_results[0].nickname)
self.assertTrue(isinstance(single_query_results[0], stem.descriptor.extrainfo_descriptor.ExtraInfoDescriptor))
self.assertEqual(2, len(list(multiple_query)))
@test.require.only_run_once
@test.require.online
def test_get_consensus(self):
"""
Exercises the downloader's get_consensus() method.
"""
downloader = stem.descriptor.remote.DescriptorDownloader(validate = True)
consensus_query = downloader.get_consensus()
consensus_query.run()
consensus = list(consensus_query)
self.assertTrue(len(consensus) > 50)
self.assertTrue(isinstance(consensus[0], stem.descriptor.router_status_entry.RouterStatusEntryV3))
@test.require.only_run_once
@test.require.online
def test_get_microdescriptor_consensus(self):
"""
Exercises the downloader's get_consensus() method for fetching a
microdescriptor consensus.
"""
downloader = stem.descriptor.remote.DescriptorDownloader(validate = True)
consensus_query = downloader.get_consensus(microdescriptor = True)
consensus_query.run()
consensus = list(consensus_query)
self.assertTrue(len(consensus) > 50)
self.assertTrue(isinstance(consensus[0], stem.descriptor.router_status_entry.RouterStatusEntryMicroV3))
@test.require.only_run_once
@test.require.online
def test_get_key_certificates(self):
"""
Exercises the downloader's get_key_certificates() method.
"""
downloader = stem.descriptor.remote.DescriptorDownloader(validate = True)
single_query = downloader.get_key_certificates('D586D18309DED4CD6D57C18FDB97EFA96D330566')
multiple_query = downloader.get_key_certificates([
'D586D18309DED4CD6D57C18FDB97EFA96D330566',
'14C131DFC5C6F93646BE72FA1401C02A8DF2E8B4',
])
single_query.run()
multiple_query.run()
single_query_results = list(single_query)
self.assertEqual(1, len(single_query_results))
self.assertEqual('D586D18309DED4CD6D57C18FDB97EFA96D330566', single_query_results[0].fingerprint)
self.assertTrue(isinstance(single_query_results[0], stem.descriptor.networkstatus.KeyCertificate))
self.assertEqual(2, len(list(multiple_query)))
@test.require.online
def test_that_cache_is_up_to_date(self):
"""
Check if the cached fallback directories bundled with Stem are up to date
or not.
"""
cached_fallback_directories = stem.descriptor.remote.FallbackDirectory.from_cache()
latest_fallback_directories = stem.descriptor.remote.FallbackDirectory.from_remote()
if cached_fallback_directories != latest_fallback_directories:
self.fail("Stem's cached fallback directories are out of date. Please run 'cache_fallback_directories.py'...\n\n%s" % stem.descriptor.remote._fallback_directory_differences(cached_fallback_directories, latest_fallback_directories))
@test.require.online
def test_fallback_directory_reachability(self):
"""
Fetch information from each fallback directory to confirm that it's
available.
"""
# Don't run this test by default. Once upon a time it was fine, but tor has
# added so many fallbacks now that this takes a looong time. :(
self.skipTest('(skipped by default)')
return
unsuccessful = {}
downloader = stem.descriptor.remote.DescriptorDownloader()
moria1_v3ident = stem.descriptor.remote.get_authorities()['moria1'].v3ident
for fallback_directory in stem.descriptor.remote.FallbackDirectory.from_cache().values():
try:
downloader.get_key_certificates(authority_v3idents = moria1_v3ident, endpoints = [(fallback_directory.address, fallback_directory.dir_port)]).run()
except Exception as exc:
unsuccessful[fallback_directory] = exc
if unsuccessful:
lines = ['We were unable to contact the following fallback directories...\n']
for fallback_directory, exc in unsuccessful.items():
lines.append('* %s:%s (%s): %s' % (fallback_directory.address, fallback_directory.dir_port, fallback_directory.fingerprint, exc))
self.fail('\n'.join(lines))
stem-1.6.0/test/integ/descriptor/server_descriptor.py 0000664 0001750 0001750 00000002573 13124757510 023605 0 ustar atagar atagar 0000000 0000000 """
Integration tests for stem.descriptor.server_descriptor.
"""
import os
import unittest
import stem.descriptor
import stem.util.test_tools
import test
from stem.util.test_tools import asynchronous
class TestServerDescriptor(unittest.TestCase):
@staticmethod
def run_tests(args):
stem.util.test_tools.ASYNC_TESTS['test.integ.descriptor.server_descriptor.test_cached_descriptor'].run(args.test_dir, threaded = True)
@asynchronous
def test_cached_descriptor(test_dir):
"""
Parses the cached descriptor file in our data directory, checking that it
doesn't raise any validation issues and looking for unrecognized descriptor
additions.
"""
descriptor_path = os.path.join(test_dir, 'cached-descriptors')
if not os.path.exists(descriptor_path):
raise stem.util.test_tools.SkipTest('(no cached descriptors)')
with open(descriptor_path, 'rb') as descriptor_file:
for desc in stem.descriptor.parse_file(descriptor_file, 'server-descriptor 1.0', validate = True):
# the following attributes should be deprecated, and not appear in the wild
if desc.read_history_end or desc.write_history_end or desc.eventdns or desc.socks_port:
raise AssertionError('deprecated attribute appeared on: %s' % desc)
for line in desc.get_unrecognized_lines():
test.register_new_capability('Server Descriptor Line', line)
stem-1.6.0/test/integ/descriptor/extrainfo_descriptor.py 0000664 0001750 0001750 00000003633 13124757510 024274 0 ustar atagar atagar 0000000 0000000 """
Integration tests for stem.descriptor.extrainfo_descriptor.
"""
import os
import unittest
import stem.descriptor
import stem.util.test_tools
import test
from stem.util.test_tools import asynchronous
class TestExtraInfoDescriptor(unittest.TestCase):
@staticmethod
def run_tests(args):
stem.util.test_tools.ASYNC_TESTS['test.integ.descriptor.extrainfo_descriptor.test_cached_descriptor'].run(args.test_dir, threaded = True)
@asynchronous
def test_cached_descriptor(test_dir):
"""
Parses the cached descriptor file in our data directory, checking that it
doesn't raise any validation issues and looking for unrecognized descriptor
additions.
"""
descriptor_path = os.path.join(test_dir, 'cached-extrainfo')
if not os.path.exists(descriptor_path):
raise stem.util.test_tools.SkipTest('(no cached descriptors)')
with open(descriptor_path, 'rb') as descriptor_file:
for desc in stem.descriptor.parse_file(descriptor_file, 'extra-info 1.0', validate = True):
for line in desc.get_unrecognized_lines():
test.register_new_capability('Extra-info Line', line)
if desc.dir_v2_responses_unknown:
raise AssertionError('Unrecognized statuses on dirreq-v2-resp lines: %s' % desc.dir_v2_responses_unknown)
elif desc.dir_v3_responses_unknown:
raise AssertionError('Unrecognized statuses on dirreq-v3-resp lines: %s' % desc.dir_v3_responses_unknown)
elif desc.dir_v2_direct_dl_unknown:
raise AssertionError('Unrecognized stats on dirreq-v2-direct-dl lines: %s' % desc.dir_v2_direct_dl_unknown)
elif desc.dir_v3_direct_dl_unknown:
raise AssertionError('Unrecognized stats on dirreq-v3-direct-dl lines: %s' % desc.dir_v2_direct_dl_unknown)
elif desc.dir_v2_tunneled_dl_unknown:
raise AssertionError('Unrecognized stats on dirreq-v2-tunneled-dl lines: %s' % desc.dir_v2_tunneled_dl_unknown)
stem-1.6.0/test/integ/descriptor/networkstatus.py 0000664 0001750 0001750 00000007010 13124757510 022765 0 ustar atagar atagar 0000000 0000000 """
Integration tests for stem.descriptor.networkstatus.
"""
import os
import unittest
import stem
import stem.descriptor
import stem.descriptor.remote
import stem.util.test_tools
import stem.version
import test
import test.require
import test.runner
from stem.util.test_tools import asynchronous
class TestNetworkStatus(unittest.TestCase):
@staticmethod
def run_tests(args):
stem.util.test_tools.ASYNC_TESTS['test.integ.descriptor.networkstatus.test_cached_consensus'].run(args.test_dir, threaded = True)
stem.util.test_tools.ASYNC_TESTS['test.integ.descriptor.networkstatus.test_cached_microdesc_consensus'].run(args.test_dir, threaded = True)
@test.require.only_run_once
@test.require.online
@test.require.cryptography
def test_signature_validation(self):
"""
The full consensus is pretty sizable so rather than storing a copy of it
using the remote module. Chekcing the signature on the current consensus.
"""
stem.descriptor.remote.get_consensus(document_handler = stem.descriptor.DocumentHandler.DOCUMENT, validate = True).run()
@asynchronous
def test_cached_consensus(test_dir):
"""
Parses the cached-consensus file in our data directory.
"""
consensus_path = os.path.join(test_dir, 'cached-consensus')
if not os.path.exists(consensus_path):
raise stem.util.test_tools.SkipTest('(no cached-consensus)')
elif stem.util.system.is_windows():
# Unable to check memory usage on windows, so can't prevent hanging the
# system if things go bad.
raise stem.util.test_tools.SkipTest('(unavailable on windows)')
count, reported_flags = 0, []
with open(consensus_path, 'rb') as descriptor_file:
for router in stem.descriptor.parse_file(descriptor_file, 'network-status-consensus-3 1.0', validate = True):
count += 1
for flag in router.flags:
if flag not in stem.Flag and flag not in reported_flags:
test.register_new_capability('Flag', flag)
reported_flags.append(flag)
for line in router.get_unrecognized_lines():
test.register_new_capability('Consensus Line', line, suppression_token = line.split()[0])
# Sanity test that there's at least a hundred relays. If that's not the
# case then this probably isn't a real, complete tor consensus.
if count < 100:
raise AssertionError('%s only included %s relays' % (consensus_path, count))
@asynchronous
def test_cached_microdesc_consensus(test_dir):
"""
Parses the cached-microdesc-consensus file in our data directory.
"""
consensus_path = os.path.join(test_dir, 'cached-microdesc-consensus')
if not os.path.exists(consensus_path):
raise stem.util.test_tools.SkipTest('(no cached-microdesc-consensus)')
elif stem.util.system.is_windows():
raise stem.util.test_tools.SkipTest('(unavailable on windows)')
count, reported_flags = 0, []
with open(consensus_path, 'rb') as descriptor_file:
for router in stem.descriptor.parse_file(descriptor_file, 'network-status-microdesc-consensus-3 1.0', validate = True):
count += 1
for flag in router.flags:
if flag not in stem.Flag:
test.register_new_capability('Flag (microdescriptor)', flag)
reported_flags.append(flag)
for line in router.get_unrecognized_lines():
test.register_new_capability('Microdescriptor Consensus Line', line, suppression_token = line.split()[0])
if count < 100:
raise AssertionError('%s only included %s relays' % (consensus_path, count))
stem-1.6.0/test/integ/process.py 0000664 0001750 0001750 00000053652 13176650724 017353 0 ustar atagar atagar 0000000 0000000 """
Tests the stem.process functions with various use cases.
"""
from __future__ import absolute_import
import binascii
import hashlib
import os
import random
import re
import shutil
import subprocess
import tempfile
import threading
import time
import unittest
import stem.prereq
import stem.process
import stem.socket
import stem.util.str_tools
import stem.util.system
import stem.util.test_tools
import stem.util.tor_tools
import stem.version
import test
import test.require
from contextlib import contextmanager
from stem.util.test_tools import asynchronous, assert_equal, assert_in, skip
try:
# added in python 3.3
from unittest.mock import patch, Mock
except ImportError:
from mock import patch, Mock
BASIC_RELAY_TORRC = """\
SocksPort 9089
ExtORPort 6001
Nickname stemIntegTest
ExitPolicy reject *:*
PublishServerDescriptor 0
DataDirectory %s
"""
TOR_CMD = 'tor'
def random_port():
while True:
port = random.randint(1024, 65535)
if stem.util.system.pid_by_port(port) is None:
return str(port)
@contextmanager
def tmp_directory():
tmp_dir = tempfile.mkdtemp()
try:
yield tmp_dir
finally:
shutil.rmtree(tmp_dir)
@contextmanager
def torrc():
with tmp_directory() as data_directory:
torrc_path = os.path.join(data_directory, 'torrc')
with open(torrc_path, 'w') as torrc_file:
torrc_file.write(BASIC_RELAY_TORRC % data_directory)
yield torrc_path
def run_tor(tor_cmd, *args, **kwargs):
# python doesn't allow us to have individual keyword arguments when there's
# an arbitrary number of positional arguments, so explicitly checking
expect_failure = kwargs.pop('expect_failure', False)
with_torrc = kwargs.pop('with_torrc', False)
stdin = kwargs.pop('stdin', None)
if kwargs:
raise ValueError('Got unexpected keyword arguments: %s' % kwargs)
with torrc() as torrc_path:
if with_torrc:
args = ['-f', torrc_path] + list(args)
args = [tor_cmd] + list(args)
tor_process = subprocess.Popen(args, stdin = subprocess.PIPE, stdout = subprocess.PIPE, stderr = subprocess.PIPE)
if stdin:
tor_process.stdin.write(stem.util.str_tools._to_bytes(stdin))
stdout = tor_process.communicate()[0]
exit_status = tor_process.poll()
if exit_status and not expect_failure:
raise AssertionError("Tor failed to start when we ran: %s\n%s" % (' '.join(args), stdout))
elif not exit_status and expect_failure:
raise AssertionError("Didn't expect tor to be able to start when we run: %s\n%s" % (' '.join(args), stdout))
return stem.util.str_tools._to_unicode(stdout) if stem.prereq.is_python_3() else stdout
class TestProcess(unittest.TestCase):
@staticmethod
def run_tests(args):
global TOR_CMD
TOR_CMD = args.tor_cmd
for func, async_test in stem.util.test_tools.ASYNC_TESTS.items():
if func.startswith('test.integ.process.'):
async_test.run(TOR_CMD)
@asynchronous
def test_version_argument(tor_cmd):
"""
Check that 'tor --version' matches 'GETINFO version'.
"""
assert_equal('Tor version %s.\n' % test.tor_version(), run_tor(tor_cmd, '--version'))
@asynchronous
def test_help_argument(tor_cmd):
"""
Check that 'tor --help' provides the expected output.
"""
help_output = run_tor(tor_cmd, '--help')
if not help_output.startswith('Copyright (c) 2001') or not help_output.endswith('tor -f [args]\nSee man page for options, or https://www.torproject.org/ for documentation.\n'):
raise AssertionError("Help output didn't have the expected strings: %s" % help_output)
assert_equal(help_output, run_tor(tor_cmd, '-h'), "'tor -h' should simply be an alias for 'tor --help'")
@asynchronous
def test_quiet_argument(tor_cmd):
"""
Check that we don't provide anything on stdout when running 'tor --quiet'.
"""
quiet_output = run_tor(tor_cmd, '--quiet', '--invalid_argument', 'true', expect_failure = True)
assert_equal('', quiet_output, 'No output should be provided with the --quiet argument')
@asynchronous
def test_hush_argument(tor_cmd):
"""
Check that we only get warnings and errors when running 'tor --hush'.
"""
output = run_tor(tor_cmd, '--hush', '--invalid_argument', expect_failure = True)
assert_in("[warn] Command-line option '--invalid_argument' with no value. Failing.", output)
output = run_tor(tor_cmd, '--hush', '--invalid_argument', 'true', expect_failure = True)
assert_in("[warn] Failed to parse/validate config: Unknown option 'invalid_argument'. Failing.", output)
@asynchronous
def test_hash_password(tor_cmd):
"""
Hash a controller password. It's salted so can't assert that we get a
particular value. Also, tor's output is unnecessarily verbose so including
hush to cut it down.
"""
output = run_tor(tor_cmd, '--hush', '--hash-password', 'my_password').splitlines()[-1]
if not re.match('^16:[0-9A-F]{58}$', output):
raise AssertionError("Unexpected response from 'tor --hash-password my_password': %s" % output)
# I'm not gonna even pretend to understand the following. Ported directly
# from tor's test_cmdline_args.py.
if stem.prereq.is_python_3():
output_hex = binascii.a2b_hex(stem.util.str_tools._to_bytes(output).strip()[3:])
salt, how, hashed = output_hex[:8], output_hex[8], output_hex[9:]
else:
output_hex = binascii.a2b_hex(output.strip()[3:])
salt, how, hashed = output_hex[:8], ord(output_hex[8]), output_hex[9:]
count = (16 + (how & 15)) << ((how >> 4) + 6)
stuff = salt + b'my_password'
repetitions = count // len(stuff) + 1
inp = (stuff * repetitions)[:count]
assert_equal(hashlib.sha1(inp).digest(), hashed)
@asynchronous
def test_hash_password_requires_argument(tor_cmd):
"""
Check that 'tor --hash-password' balks if not provided with something to
hash.
"""
output = run_tor(tor_cmd, '--hash-password', expect_failure = True)
assert_in("[warn] Command-line option '--hash-password' with no value. Failing.", output)
@asynchronous
def test_dump_config_argument(tor_cmd):
"""
Exercises our 'tor --dump-config' arugments.
"""
short_output = run_tor(tor_cmd, '--dump-config', 'short', with_torrc = True)
non_builtin_output = run_tor(tor_cmd, '--dump-config', 'non-builtin', with_torrc = True)
full_output = run_tor(tor_cmd, '--dump-config', 'full', with_torrc = True)
run_tor(tor_cmd, '--dump-config', 'invalid_option', with_torrc = True, expect_failure = True)
assert_in('Nickname stemIntegTest', short_output)
assert_in('Nickname stemIntegTest', non_builtin_output)
assert_in('Nickname stemIntegTest', full_output)
@asynchronous
def test_validate_config_argument(tor_cmd):
"""
Exercises our 'tor --validate-config' argument.
"""
valid_output = run_tor(tor_cmd, '--verify-config', with_torrc = True)
assert_in('Configuration was valid\n', valid_output, 'Expected configuration to be valid')
run_tor(tor_cmd, '--verify-config', '-f', __file__, expect_failure = True)
@asynchronous
def test_list_fingerprint_argument(tor_cmd):
"""
Exercise our 'tor --list-fingerprint' argument.
"""
# This command should only work with a relay (which our test instance isn't).
output = run_tor(tor_cmd, '--list-fingerprint', with_torrc = True, expect_failure = True)
assert_in("Clients don't have long-term identity keys. Exiting.", output, 'Should fail to start due to lacking an ORPort')
with tmp_directory() as data_directory:
torrc_path = os.path.join(data_directory, 'torrc')
with open(torrc_path, 'w') as torrc_file:
torrc_file.write(BASIC_RELAY_TORRC % data_directory + '\nORPort 6954')
output = run_tor(tor_cmd, '--list-fingerprint', '-f', torrc_path)
nickname, fingerprint_with_spaces = output.splitlines()[-1].split(' ', 1)
fingerprint = fingerprint_with_spaces.replace(' ', '')
assert_equal('stemIntegTest', nickname)
assert_equal(49, len(fingerprint_with_spaces))
if not stem.util.tor_tools.is_valid_fingerprint(fingerprint):
raise AssertionError('We should have a valid fingerprint: %s' % fingerprint)
with open(os.path.join(data_directory, 'fingerprint')) as fingerprint_file:
expected = 'stemIntegTest %s\n' % fingerprint
assert_equal(expected, fingerprint_file.read())
@asynchronous
def test_list_torrc_options_argument(tor_cmd):
"""
Exercise our 'tor --list-torrc-options' argument.
"""
output = run_tor(tor_cmd, '--list-torrc-options')
if len(output.splitlines()) < 50:
raise AssertionError("'tor --list-torrc-options' should have numerous entries, but only had %i" % len(output.splitlines()))
elif 'UseBridges' not in output or 'SocksPort' not in output:
raise AssertionError("'tor --list-torrc-options' didn't have options we expect")
@asynchronous
def test_no_orphaned_process(tor_cmd):
"""
Check that when an exception arises in the middle of spawning tor that we
don't leave a lingering process.
"""
if not stem.util.system.is_available('sleep'):
skip('(sleep unavailable)')
with patch('re.compile', Mock(side_effect = KeyboardInterrupt('nope'))):
# We don't need to actually run tor for this test. Rather, any process will
# do the trick. Picking sleep so this'll clean itself up if our test fails.
mock_tor_process = subprocess.Popen(['sleep', '60'])
with patch('subprocess.Popen', Mock(return_value = mock_tor_process)):
try:
stem.process.launch_tor(tor_cmd)
raise AssertionError("tor shoudn't have started")
except KeyboardInterrupt as exc:
if os.path.exists('/proc/%s' % mock_tor_process.pid):
raise AssertionError('launch_tor() left a lingering tor process')
assert_equal('nope', str(exc))
@asynchronous
def test_torrc_arguments(tor_cmd):
"""
Pass configuration options on the commandline.
"""
with torrc() as torrc_path:
config_args = [
'+SocksPort', '9090', # append an extra SocksPort
'/ExtORPort', # drops our ExtORPort
'/TransPort', # drops a port we didn't originally have
'+ControlPort', '9005', # appends a ControlPort where we didn't have any before
]
output = run_tor(tor_cmd, '-f', torrc_path, '--dump-config', 'short', *config_args)
result = [line for line in output.splitlines() if not line.startswith('DataDirectory')]
expected = [
'ControlPort 9005',
'ExitPolicy reject *:*',
'Nickname stemIntegTest',
'PublishServerDescriptor 0',
'SocksPort 9089',
'SocksPort 9090',
]
assert_equal(expected, result)
@asynchronous
def test_torrc_arguments_via_stdin(tor_cmd):
"""
Pass configuration options via stdin.
"""
if test.tor_version() < stem.version.Requirement.TORRC_VIA_STDIN:
skip('(requires %s)' % stem.version.Requirement.TORRC_VIA_STDIN)
with tmp_directory() as data_directory:
torrc = BASIC_RELAY_TORRC % data_directory
output = run_tor(tor_cmd, '-f', '-', '--dump-config', 'short', stdin = torrc)
assert_equal(sorted(torrc.splitlines()), sorted(output.splitlines()))
@asynchronous
def test_with_missing_torrc(tor_cmd):
"""
Provide a torrc path that doesn't exist.
"""
output = run_tor(tor_cmd, '-f', '/path/that/really/shouldnt/exist', '--verify-config', expect_failure = True)
assert_in('[warn] Unable to open configuration file "/path/that/really/shouldnt/exist".', output, 'Tor should refuse to read a non-existant torrc file')
output = run_tor(tor_cmd, '-f', '/path/that/really/shouldnt/exist', '--verify-config', '--ignore-missing-torrc')
assert_in('[notice] Configuration file "/path/that/really/shouldnt/exist" not present, using reasonable defaults.', output, 'Missing torrc should be allowed with --ignore-missing-torrc')
@asynchronous
def test_unanonymous_hidden_service_config_must_match(tor_cmd):
"""
Checking that startup fails if HiddenServiceNonAnonymousMode and
HiddenServiceSingleHopMode don't match.
"""
try:
stem.process.launch_tor_with_config(
tor_cmd = tor_cmd,
config = {'HiddenServiceNonAnonymousMode': '1'},
)
raise AssertionError("Tor shouldn't start with 'HiddenServiceNonAnonymousMode' set but not 'HiddenServiceSingleHopMode'")
except OSError as exc:
if test.tor_version() >= stem.version.Requirement.ADD_ONION_NON_ANONYMOUS:
assert_equal('Process terminated: HiddenServiceNonAnonymousMode does not provide any server anonymity. It must be used with HiddenServiceSingleHopMode set to 1.', str(exc))
else:
assert_equal("Process terminated: Unknown option 'HiddenServiceNonAnonymousMode'. Failing.", str(exc))
try:
stem.process.launch_tor_with_config(
tor_cmd = tor_cmd,
config = {'HiddenServiceSingleHopMode': '1'},
)
raise AssertionError("Tor shouldn't start with 'HiddenServiceSingleHopMode' set but not 'HiddenServiceNonAnonymousMode'")
except OSError as exc:
if test.tor_version() >= stem.version.Requirement.ADD_ONION_NON_ANONYMOUS:
assert_equal('Process terminated: HiddenServiceSingleHopMode does not provide any server anonymity. It must be used with HiddenServiceNonAnonymousMode set to 1.', str(exc))
else:
assert_equal("Process terminated: Unknown option 'HiddenServiceSingleHopMode'. Failing.", str(exc))
@asynchronous
def test_can_run_multithreaded(tor_cmd):
"""
Our launch_tor() function uses signal to support its timeout argument.
This only works in the main thread so ensure we give a useful message when
it isn't.
"""
with tmp_directory() as data_directory:
# Tries running tor in another thread with the given timeout argument. This
# issues an invalid torrc so we terminate right away if we get to the point
# of actually invoking tor.
#
# Returns None if launching tor is successful, and otherwise returns the
# exception we raised.
def launch_async_with_timeout(timeout_arg):
raised_exc = [None]
def short_launch():
try:
stem.process.launch_tor_with_config(
tor_cmd = tor_cmd,
config = {
'SocksPort': 'invalid',
'DataDirectory': data_directory,
},
completion_percent = 100,
timeout = timeout_arg,
)
except Exception as exc:
raised_exc[0] = exc
t = threading.Thread(target = short_launch)
t.start()
t.join()
if 'Invalid SocksPort' in str(raised_exc[0]):
return None # got to the point of invoking tor
else:
return raised_exc[0]
exc = launch_async_with_timeout(0.5)
assert_equal(OSError, type(exc))
assert_equal('Launching tor with a timeout can only be done in the main thread', str(exc))
# We should launch successfully if no timeout is specified or we specify it
# to be 'None'.
if launch_async_with_timeout(None) is not None:
raise AssertionError('Launching tor without a timeout should be successful')
if launch_async_with_timeout(stem.process.DEFAULT_INIT_TIMEOUT) is not None:
raise AssertionError('Launching tor with the default timeout should be successful')
@asynchronous
def test_launch_tor_with_config_via_file(tor_cmd):
"""
Exercises launch_tor_with_config when we write a torrc to disk.
"""
with tmp_directory() as data_directory:
control_port = random_port()
control_socket, tor_process = None, None
try:
# Launch tor without a torrc, but with a control port. Confirms that this
# works by checking that we're still able to access the new instance.
with patch('stem.version.get_system_tor_version', Mock(return_value = stem.version.Version('0.0.0.1'))):
tor_process = stem.process.launch_tor_with_config(
tor_cmd = tor_cmd,
config = {
'SocksPort': random_port(),
'ControlPort': control_port,
'DataDirectory': data_directory,
},
completion_percent = 5
)
control_socket = stem.socket.ControlPort(port = int(control_port))
stem.connection.authenticate(control_socket)
# exercises the socket
control_socket.send('GETCONF ControlPort')
getconf_response = control_socket.recv()
assert_equal('ControlPort=%s' % control_port, str(getconf_response))
finally:
if control_socket:
control_socket.close()
if tor_process:
tor_process.kill()
tor_process.wait()
@asynchronous
def test_launch_tor_with_config_via_stdin(tor_cmd):
"""
Exercises launch_tor_with_config when we provide our torrc via stdin.
"""
if test.tor_version() < stem.version.Requirement.TORRC_VIA_STDIN:
skip('(requires %s)' % stem.version.Requirement.TORRC_VIA_STDIN)
with tmp_directory() as data_directory:
control_port = random_port()
control_socket, tor_process = None, None
try:
tor_process = stem.process.launch_tor_with_config(
tor_cmd = tor_cmd,
config = {
'SocksPort': random_port(),
'ControlPort': control_port,
'DataDirectory': data_directory,
},
completion_percent = 5
)
control_socket = stem.socket.ControlPort(port = int(control_port))
stem.connection.authenticate(control_socket)
# exercises the socket
control_socket.send('GETCONF ControlPort')
getconf_response = control_socket.recv()
assert_equal('ControlPort=%s' % control_port, str(getconf_response))
finally:
if control_socket:
control_socket.close()
if tor_process:
tor_process.kill()
tor_process.wait()
@asynchronous
def test_with_invalid_config(tor_cmd):
"""
Spawn a tor process with a configuration that should make it dead on arrival.
"""
# Set the same SocksPort and ControlPort, this should fail with...
#
# [warn] Failed to parse/validate config: Failed to bind one of the listener ports.
# [err] Reading config failed--see warnings above.
with tmp_directory() as data_directory:
both_ports = random_port()
try:
stem.process.launch_tor_with_config(
tor_cmd = tor_cmd,
config = {
'SocksPort': both_ports,
'ControlPort': both_ports,
'DataDirectory': data_directory,
},
)
raise AssertionError('Tor should fail to launch')
except OSError as exc:
assert_equal('Process terminated: Failed to bind one of the listener ports.', str(exc))
def test_launch_tor_with_timeout(self):
"""
Runs launch_tor where it times out before completing.
"""
with tmp_directory() as data_directory:
start_time = time.time()
try:
stem.process.launch_tor_with_config(
tor_cmd = TOR_CMD,
timeout = 0.05,
config = {
'SocksPort': random_port(),
'DataDirectory': data_directory,
},
)
raise AssertionError('Tor should fail to launch')
except OSError:
runtime = time.time() - start_time
if not (runtime > 0.05 and runtime < 3):
raise AssertionError('Test should have taken 0.05-3 seconds, took %0.1f instead' % runtime)
@asynchronous
def test_take_ownership_via_pid(tor_cmd):
"""
Checks that the tor process quits after we do if we set take_ownership. To
test this we spawn a process and trick tor into thinking that it is us.
"""
if not stem.util.system.is_available('sleep'):
skip('(sleep unavailable)')
elif test.tor_version() < stem.version.Requirement.TAKEOWNERSHIP:
skip('(requires %s)' % stem.version.Requirement.TAKEOWNERSHIP)
with tmp_directory() as data_directory:
sleep_process = subprocess.Popen(['sleep', '60'])
tor_process = stem.process.launch_tor_with_config(
tor_cmd = tor_cmd,
config = {
'SocksPort': random_port(),
'ControlPort': random_port(),
'DataDirectory': data_directory,
'__OwningControllerProcess': str(sleep_process.pid),
},
completion_percent = 5,
)
# Kill the sleep command. Tor should quit shortly after.
sleep_process.kill()
sleep_process.communicate()
# tor polls for the process every fifteen seconds so this may take a
# while...
#
# https://trac.torproject.org/projects/tor/ticket/21281
start_time = time.time()
while time.time() - start_time < 30:
if tor_process.poll() == 0:
return # tor exited
time.sleep(0.01)
raise AssertionError("tor didn't quit after the process that owned it terminated")
@asynchronous
def test_take_ownership_via_controller(tor_cmd):
"""
Checks that the tor process quits after the controller that owns it
connects, then disconnects..
"""
if test.tor_version() < stem.version.Requirement.TAKEOWNERSHIP:
skip('(requires %s)' % stem.version.Requirement.TAKEOWNERSHIP)
with tmp_directory() as data_directory:
control_port = random_port()
tor_process = stem.process.launch_tor_with_config(
tor_cmd = tor_cmd,
config = {
'SocksPort': random_port(),
'ControlPort': control_port,
'DataDirectory': data_directory,
},
completion_percent = 5,
take_ownership = True,
)
# We're the controlling process. Just need to connect then disconnect.
controller = stem.control.Controller.from_port(port = int(control_port))
controller.authenticate()
controller.close()
# give tor a few seconds to quit
start_time = time.time()
while time.time() - start_time < 5:
if tor_process.poll() == 0:
return # tor exited
time.sleep(0.01)
raise AssertionError("tor didn't quit after the controller that owned it disconnected")
stem-1.6.0/test/integ/util/ 0000775 0001750 0001750 00000000000 13177674754 016277 5 ustar atagar atagar 0000000 0000000 stem-1.6.0/test/integ/util/conf.py 0000664 0001750 0001750 00000007264 13115423200 017551 0 ustar atagar atagar 0000000 0000000 """
Integration tests for the stem.util.conf class and functions.
"""
import os
import unittest
import stem.util.conf
import test.runner
CONF_HEADER = """# Demo configuration for integration tests to run against. Nothing to see here,
# move along, move along.
"""
EXAMPLE_CONF = """
destination.ip 1.2.3.4
destination.port blarg
startup.run export PATH=$PATH:~/bin
startup.run alias l=ls
"""
MULTILINE_CONF = """
multiline.entry.simple
|la de da
|and a ho hum
multiline.entry.leading_whitespace
|la de da
|and a ho hum
multiline.entry.empty
multiline.entry.squashed_top
|la de da
|and a ho hum
multiline.entry.squashed_bottom
|la de da
|and a ho hum
"""
HERALD_POEM = """
What a beautiful morning,
what a beautiful day.
Why are those arrows",
coming my way?!?"""
def _get_test_config_path():
return test.runner.get_runner().get_test_dir('integ_test_cfg')
def _make_config(contents):
"""
Writes a test configuration to disk, returning the path where it is located.
"""
test_config_path = _get_test_config_path()
test_conf_file = open(test_config_path, 'w')
test_conf_file.write(CONF_HEADER)
test_conf_file.write(contents)
test_conf_file.close()
return test_config_path
class TestConf(unittest.TestCase):
def tearDown(self):
# clears the config contents
test_config = stem.util.conf.get_config('integ_testing')
test_config.clear()
test_config.clear_listeners()
# cleans up test configurations we made
test_config_path = _get_test_config_path()
if os.path.exists(test_config_path):
os.remove(test_config_path)
def test_example(self):
"""
Checks that the pydoc example is correct.
"""
ssh_config = stem.util.conf.config_dict('integ_testing', {
'login.user': 'atagar',
'login.password': 'pepperjack_is_awesome!',
'destination.ip': '127.0.0.1',
'destination.port': 22,
'startup.run': [],
})
test_config_path = _make_config(EXAMPLE_CONF)
user_config = stem.util.conf.get_config('integ_testing')
user_config.load(test_config_path)
self.assertEqual('atagar', ssh_config['login.user'])
self.assertEqual('pepperjack_is_awesome!', ssh_config['login.password'])
self.assertEqual('1.2.3.4', ssh_config['destination.ip'])
self.assertEqual(22, ssh_config['destination.port'])
self.assertEqual(['export PATH=$PATH:~/bin', 'alias l=ls'], ssh_config['startup.run'])
def test_load_multiline(self):
"""
Tests the load method with multi-line configuration files.
"""
test_config_path = _make_config(MULTILINE_CONF)
test_config = stem.util.conf.get_config('integ_testing')
test_config.load(test_config_path)
for entry in ('simple', 'leading_whitespace', 'squashed_top', 'squashed_bottom'):
self.assertEqual('la de da\nand a ho hum', test_config.get('multiline.entry.%s' % entry))
self.assertEqual('', test_config.get('multiline.entry.empty'))
def test_save(self):
"""
Saves then reloads a configuration with several types of values.
"""
# makes a configuration with a variety of types
test_config = stem.util.conf.get_config('integ_testing')
test_config.set('single_value', "yup, I'm there")
test_config.set('multiple_values', 'a', False)
test_config.set('multiple_values', 'b', False)
test_config.set('multiple_values', 'c', False)
test_config.set('multiline_value', HERALD_POEM)
test_config.save(_get_test_config_path())
test_config.clear()
test_config.load()
self.assertEqual("yup, I'm there", test_config.get_value('single_value'))
self.assertEqual(['a', 'b', 'c'], test_config.get_value('multiple_values', multiple = True))
self.assertEqual(HERALD_POEM, test_config.get_value('multiline_value'))
stem-1.6.0/test/integ/util/__init__.py 0000664 0001750 0001750 00000000150 13115423200 020346 0 ustar atagar atagar 0000000 0000000 """
Integration tests for stem.util.* contents.
"""
__all__ = ['conf', 'connection', 'proc', 'system']
stem-1.6.0/test/integ/util/system.py 0000664 0001750 0001750 00000042336 13146346524 020170 0 ustar atagar atagar 0000000 0000000 """
Integration tests for the stem.util.system functions against the tor process
that we're running.
"""
import getpass
import os
import tempfile
import unittest
import stem.util.proc
import stem.util.system
import test.require
import test.runner
from stem.util.system import State, DaemonTask
try:
# added in python 3.3
from unittest.mock import Mock, patch
except ImportError:
from mock import Mock, patch
def filter_system_call(prefixes):
"""
Provides a functor that passes calls on to the stem.util.system.call()
function if it matches one of the prefixes, and acts as a no-op otherwise.
"""
original_call = stem.util.system.call
def _filter_system_call(command, default):
for prefix in prefixes:
if command.startswith(prefix):
real_call_function = original_call
return real_call_function(command)
return _filter_system_call
def _is_single_tor_running():
if stem.util.system.is_windows():
return True # TODO: not sure how to check for this on windows
elif not stem.util.system.is_bsd():
tor_cmd = test.runner.get_runner().get_tor_command(True)
pgrep_results = stem.util.system.call(stem.util.system.GET_PID_BY_NAME_PGREP % tor_cmd)
return len(pgrep_results) == 1
else:
ps_results = stem.util.system.call(stem.util.system.GET_PID_BY_NAME_PS_BSD)
results = [r for r in ps_results if r.endswith(' tor')]
return len(results) == 1
def _is_linux():
return not stem.util.system.is_bsd() and not stem.util.system.is_windows()
def _has_port():
"""
True if our test runner has a control port, False otherwise.
"""
return test.runner.Torrc.PORT in test.runner.get_runner().get_options()
require_single_tor_instance = test.require.needs(_is_single_tor_running, 'multiple tor instances')
require_control_port = test.require.needs(_has_port, 'test instance has no port')
require_linux = test.require.needs(_is_linux, 'linux only')
require_bsd = test.require.needs(stem.util.system.is_bsd, 'bsd only')
require_path = test.require.needs(lambda: 'PATH' in os.environ, 'requires PATH')
class TestSystem(unittest.TestCase):
def test_daemon_task_when_successful(self):
"""
Checks a simple, successfully DaemonTask that simply echos a value.
"""
task = DaemonTask(lambda arg: arg, ('hello world',))
self.assertEqual(None, task.result)
self.assertEqual(State.PENDING, task.status)
task.run()
self.assertEqual('hello world', task.join())
self.assertEqual(State.DONE, task.status)
self.assertTrue(0 < task.runtime < 1.0)
def test_daemon_task_on_failure(self):
"""
Checks DaemonTask when an exception is raised.
"""
def _test_task(arg):
raise RuntimeError(arg)
task = DaemonTask(_test_task, ('hello world',))
self.assertEqual(None, task.result)
self.assertEqual(State.PENDING, task.status)
task.run()
self.assertRaisesRegexp(RuntimeError, 'hello world', task.join)
self.assertEqual(State.FAILED, task.status)
self.assertTrue(0 < task.runtime < 1.0)
@require_path
def test_is_available(self):
"""
Checks the stem.util.system.is_available function.
"""
# I have yet to see a platform without 'ls'
if stem.util.system.is_windows():
self.assertTrue(stem.util.system.is_available('dir'))
else:
self.assertTrue(stem.util.system.is_available('ls'))
# but it would be kinda weird if this did...
self.assertFalse(stem.util.system.is_available('blarg_and_stuff'))
def test_is_running_by_pid(self):
"""
Checks the stem.util.system.is_running function with a pid.
"""
self.assertTrue(stem.util.system.is_running(test.runner.get_runner().get_pid()))
self.assertFalse(stem.util.system.is_running(528955))
@test.require.command('ps')
def test_is_running_by_name(self):
"""
Checks the stem.util.system.is_running function with a process name.
"""
# Check to see if the command we started tor with is running. The process
# might be running under another name so need to check for 'tor.real' too
# (#15449).
tor_cmd = test.runner.get_runner().get_tor_command(True)
self.assertTrue(stem.util.system.is_running(tor_cmd) or stem.util.system.is_running('tor.real'))
self.assertFalse(stem.util.system.is_running('blarg_and_stuff'))
@require_path
@require_single_tor_instance
def test_pid_by_name(self):
"""
Checks general usage of the stem.util.system.pid_by_name function. This
will fail if there's other tor instances running.
"""
tor_pid = test.runner.get_runner().get_pid()
tor_cmd = test.runner.get_runner().get_tor_command(True)
self.assertEqual(tor_pid, stem.util.system.pid_by_name(tor_cmd))
self.assertEqual(None, stem.util.system.pid_by_name('blarg_and_stuff'))
@require_single_tor_instance
@test.require.command('pgrep')
def test_pid_by_name_pgrep(self):
"""
Tests the pid_by_name function with a pgrep response.
"""
pgrep_prefix = stem.util.system.GET_PID_BY_NAME_PGREP % ''
call_replacement = filter_system_call([pgrep_prefix])
with patch('stem.util.system.call') as call_mock:
call_mock.side_effect = call_replacement
tor_pid = test.runner.get_runner().get_pid()
tor_cmd = test.runner.get_runner().get_tor_command(True)
self.assertEqual(tor_pid, stem.util.system.pid_by_name(tor_cmd))
@require_single_tor_instance
@test.require.command('pidof')
def test_pid_by_name_pidof(self):
"""
Tests the pid_by_name function with a pidof response.
"""
pidof_prefix = stem.util.system.GET_PID_BY_NAME_PIDOF % ''
call_replacement = filter_system_call([pidof_prefix])
with patch('stem.util.system.call') as call_mock:
call_mock.side_effect = call_replacement
tor_pid = test.runner.get_runner().get_pid()
tor_cmd = test.runner.get_runner().get_tor_command()
self.assertEqual(tor_pid, stem.util.system.pid_by_name(tor_cmd))
@require_linux
@require_single_tor_instance
@test.require.command('ps')
def test_pid_by_name_ps_linux(self):
"""
Tests the pid_by_name function with the linux variant of ps.
"""
ps_prefix = stem.util.system.GET_PID_BY_NAME_PS_LINUX % ''
call_replacement = filter_system_call([ps_prefix])
with patch('stem.util.system.call') as call_mock:
call_mock.side_effect = call_replacement
tor_pid = test.runner.get_runner().get_pid()
tor_cmd = test.runner.get_runner().get_tor_command(True)
self.assertEqual(tor_pid, stem.util.system.pid_by_name(tor_cmd))
@require_bsd
@require_single_tor_instance
@test.require.command('ps')
def test_pid_by_name_ps_bsd(self):
"""
Tests the pid_by_name function with the bsd variant of ps.
"""
ps_prefix = stem.util.system.GET_PID_BY_NAME_PS_BSD
call_replacement = filter_system_call([ps_prefix])
with patch('stem.util.system.call') as call_mock:
call_mock.side_effect = call_replacement
tor_pid = test.runner.get_runner().get_pid()
tor_cmd = test.runner.get_runner().get_tor_command(True)
self.assertEqual(tor_pid, stem.util.system.pid_by_name(tor_cmd))
@require_single_tor_instance
@test.require.ptrace
@test.require.command('lsof')
def test_pid_by_name_lsof(self):
"""
Tests the pid_by_name function with a lsof response.
"""
lsof_prefix = stem.util.system.GET_PID_BY_NAME_LSOF % ''
call_replacement = filter_system_call([lsof_prefix])
with patch('stem.util.system.call') as call_mock:
call_mock.side_effect = call_replacement
tor_cmd = test.runner.get_runner().get_tor_command(True)
our_tor_pid = test.runner.get_runner().get_pid()
all_tor_pids = stem.util.system.pid_by_name(tor_cmd, multiple = True)
if len(all_tor_pids) == 1:
self.assertEqual(our_tor_pid, all_tor_pids[0])
@require_single_tor_instance
@test.require.command('tasklist')
def test_pid_by_name_tasklist(self):
"""
Tests the pid_by_name function with a tasklist response.
"""
runner = test.runner.get_runner()
self.assertEqual(runner.get_pid(), stem.util.system.pid_by_name(runner.get_tor_command(True)))
@require_control_port
@test.require.ptrace
def test_pid_by_port(self):
"""
Checks general usage of the stem.util.system.pid_by_port function.
"""
if stem.util.system.is_windows():
self.skipTest('(unavailable on windows)')
return
elif stem.util.system.is_mac() or stem.util.system.is_gentoo():
self.skipTest('(resolvers unavailable)')
return
elif not (stem.util.system.is_available('netstat') or
stem.util.system.is_available('sockstat') or
stem.util.system.is_available('lsof')):
self.skipTest('(connection resolvers unavailable)')
return
runner = test.runner.get_runner()
tor_pid, tor_port = runner.get_pid(), test.runner.CONTROL_PORT
self.assertEqual(tor_pid, stem.util.system.pid_by_port(tor_port))
self.assertEqual(None, stem.util.system.pid_by_port(99999))
@require_linux
@require_control_port
@test.require.ptrace
@test.require.command('netstat')
def test_pid_by_port_netstat(self):
"""
Tests the pid_by_port function with a netstat response.
"""
if stem.util.system.is_gentoo():
self.skipTest('(unavailable on gentoo)')
return
netstat_prefix = stem.util.system.GET_PID_BY_PORT_NETSTAT
call_replacement = filter_system_call([netstat_prefix])
with patch('stem.util.system.call') as call_mock:
call_mock.side_effect = call_replacement
tor_pid = test.runner.get_runner().get_pid()
self.assertEqual(tor_pid, stem.util.system.pid_by_port(test.runner.CONTROL_PORT))
@require_bsd
@require_control_port
@test.require.ptrace
@test.require.command('sockstat')
def test_pid_by_port_sockstat(self):
"""
Tests the pid_by_port function with a sockstat response.
"""
sockstat_prefix = stem.util.system.GET_PID_BY_PORT_SOCKSTAT % ''
call_replacement = filter_system_call([sockstat_prefix])
with patch('stem.util.system.call') as call_mock:
call_mock.side_effect = call_replacement
tor_pid = test.runner.get_runner().get_pid()
self.assertEqual(tor_pid, stem.util.system.pid_by_port(test.runner.CONTROL_PORT))
@require_control_port
@test.require.ptrace
@test.require.command('lsof')
def test_pid_by_port_lsof(self):
"""
Tests the pid_by_port function with a lsof response.
"""
if stem.util.system.is_mac() or stem.util.system.is_gentoo():
self.skipTest('(resolvers unavailable)')
return
lsof_prefix = stem.util.system.GET_PID_BY_PORT_LSOF
call_replacement = filter_system_call([lsof_prefix])
with patch('stem.util.system.call') as call_mock:
call_mock.side_effect = call_replacement
tor_pid = test.runner.get_runner().get_pid()
self.assertEqual(tor_pid, stem.util.system.pid_by_port(test.runner.CONTROL_PORT))
def test_pid_by_open_file(self):
"""
Checks the stem.util.system.pid_by_open_file function.
"""
# check a directory that exists, but isn't claimed by any application
tmpdir = tempfile.mkdtemp()
self.assertEqual(None, stem.util.system.pid_by_open_file(tmpdir))
# check a directory that doesn't exist
os.rmdir(tmpdir)
self.assertEqual(None, stem.util.system.pid_by_open_file(tmpdir))
@require_path
def test_pids_by_user(self):
"""
Checks the stem.util.system.pids_by_user function.
"""
# our own pid should be among the processes for our user
pids = stem.util.system.pids_by_user(getpass.getuser())
self.assertTrue(os.getpid() in pids)
@test.require.ptrace
def test_cwd(self):
"""
Checks general usage of the stem.util.system.cwd function.
"""
if stem.util.system.is_windows():
self.skipTest('(unavailable on windows)')
return
runner = test.runner.get_runner()
runner_pid, tor_cwd = runner.get_pid(), runner.get_tor_cwd()
self.assertEqual(tor_cwd, stem.util.system.cwd(runner_pid))
self.assertEqual(None, stem.util.system.cwd(99999))
@test.require.ptrace
@test.require.command('pwdx')
def test_cwd_pwdx(self):
"""
Tests the pid_by_cwd function with a pwdx response.
"""
# filter the call function to only allow this command
pwdx_prefix = stem.util.system.GET_CWD_PWDX % ''
call_replacement = filter_system_call([pwdx_prefix])
with patch('stem.util.system.call') as call_mock:
call_mock.side_effect = call_replacement
runner = test.runner.get_runner()
runner_pid, tor_cwd = runner.get_pid(), runner.get_tor_cwd()
self.assertEqual(tor_cwd, stem.util.system.cwd(runner_pid))
@test.require.ptrace
@test.require.command('lsof')
def test_cwd_lsof(self):
"""
Tests the pid_by_cwd function with a lsof response.
"""
# filter the call function to only allow this command
lsof_prefix = 'lsof -a -p '
call_replacement = filter_system_call([lsof_prefix])
with patch('stem.util.system.call') as call_mock:
call_mock.side_effect = call_replacement
runner = test.runner.get_runner()
runner_pid, tor_cwd = runner.get_pid(), runner.get_tor_cwd()
self.assertEqual(tor_cwd, stem.util.system.cwd(runner_pid))
def test_user_none(self):
"""
Tests the user function when the process doesn't exist.
"""
self.assertEqual(None, stem.util.system.user(None))
self.assertEqual(None, stem.util.system.user(-5))
self.assertEqual(None, stem.util.system.start_time(98765))
@test.require.proc
def test_user_proc(self):
"""
Tests the user function with a proc response.
"""
call_replacement = filter_system_call(['ps '])
with patch('stem.util.system.call') as call_mock:
call_mock.side_effect = call_replacement
# we started our tor process so it should be running with the same user
pid = test.runner.get_runner().get_pid()
self.assertTrue(getpass.getuser(), stem.util.system.user(pid))
@test.require.command('ps')
@patch('stem.util.proc.is_available', Mock(return_value = False))
def test_user_ps(self):
"""
Tests the user function with a ps response.
"""
pid = test.runner.get_runner().get_pid()
self.assertTrue(getpass.getuser(), stem.util.system.user(pid))
def test_start_time_none(self):
"""
Tests the start_time function when the process doesn't exist.
"""
self.assertEqual(None, stem.util.system.start_time(None))
self.assertEqual(None, stem.util.system.start_time(-5))
self.assertEqual(None, stem.util.system.start_time(98765))
@test.require.proc
def test_start_time_proc(self):
"""
Tests the start_time function with a proc response.
"""
call_replacement = filter_system_call(['ps '])
with patch('stem.util.system.call') as call_mock:
call_mock.side_effect = call_replacement
pid = test.runner.get_runner().get_pid()
self.assertTrue(stem.util.system.start_time(pid) >= 0)
@test.require.command('ps')
@patch('stem.util.proc.is_available', Mock(return_value = False))
def test_start_time_ps(self):
"""
Tests the start_time function with a ps response.
"""
pid = test.runner.get_runner().get_pid()
self.assertTrue(stem.util.system.start_time(pid) >= 0)
def test_bsd_jail_id(self):
"""
Exercises the stem.util.system.bsd_jail_id function, running through
the failure case (since I'm not on BSD I can't really test this function
properly).
"""
self.assertEqual(0, stem.util.system.bsd_jail_id(99999))
def test_expand_path(self):
"""
Exercises the expand_path() method with actual runtime data.
"""
# Some of the following tests get confused when ran as root. For instance,
# in my case...
#
# >>> os.path.expanduser('~')
# '/home/atagar'
#
# >>> os.path.expanduser('~root')
# '/root'
if getpass.getuser() == 'root':
self.skipTest('(running as root)')
return
self.assertEqual(os.getcwd(), stem.util.system.expand_path('.'))
self.assertEqual(os.getcwd(), stem.util.system.expand_path('./'))
self.assertEqual(os.path.join(os.getcwd(), 'foo'), stem.util.system.expand_path('./foo'))
home_dir, username = os.path.expanduser('~'), getpass.getuser()
self.assertEqual(home_dir, stem.util.system.expand_path('~'))
self.assertEqual(home_dir, stem.util.system.expand_path('~/'))
self.assertEqual(home_dir, stem.util.system.expand_path('~%s' % username))
self.assertEqual(os.path.join(home_dir, 'foo'), stem.util.system.expand_path('~%s/foo' % username))
def test_call_timeout(self):
self.assertRaisesRegexp(stem.util.system.CallTimeoutError, "Process didn't finish after 0.0 seconds", stem.util.system.call, 'sleep 1', timeout = 0.001)
def test_call_time_tracked(self):
"""
Check that time taken in the call() function is tracked by SYSTEM_CALL_TIME.
"""
initial = stem.util.system.SYSTEM_CALL_TIME
stem.util.system.call('sleep 0.005')
self.assertTrue(stem.util.system.SYSTEM_CALL_TIME - initial > 0.004)
def test_set_process_name(self):
"""
Exercises the get_process_name() and set_process_name() methods.
"""
initial_name = stem.util.system.get_process_name()
self.assertTrue('run_tests.py' in initial_name)
try:
stem.util.system.set_process_name('stem_integ')
self.assertEqual('stem_integ', stem.util.system.get_process_name())
finally:
stem.util.system.set_process_name(initial_name)
stem-1.6.0/test/integ/util/connection.py 0000664 0001750 0001750 00000004651 13136657256 021007 0 ustar atagar atagar 0000000 0000000 """
Integration tests for stem.util.connection functions against the tor process
that we're running.
"""
import unittest
import stem.util.system
import test.require
import test.runner
from stem.util.connection import RESOLVER_COMMAND, Resolver, get_connections, system_resolvers
class TestConnection(unittest.TestCase):
@test.require.ptrace
def check_resolver(self, resolver):
runner = test.runner.get_runner()
if test.runner.Torrc.PORT not in runner.get_options():
self.skipTest('(no control port)')
return
elif resolver not in system_resolvers():
self.skipTest('(resolver unavailable on this platform)')
return
with runner.get_tor_socket():
connections = get_connections(resolver, process_pid = runner.get_pid())
for conn in connections:
if conn.local_address == '127.0.0.1' and conn.local_port == test.runner.CONTROL_PORT:
return
resolver_command = RESOLVER_COMMAND[resolver].format(pid = runner.get_pid())
resolver_output = stem.util.system.call(resolver_command)
self.fail('Unable to find our controller connection with %s (%s). Connections found were...\n\n%s\n\nCommand output was...\n\n%s' % (resolver, resolver_command, '\n'.join(map(str, connections)), resolver_output))
def test_connections_by_proc(self):
self.check_resolver(Resolver.PROC)
def test_connections_by_netstat(self):
self.check_resolver(Resolver.NETSTAT)
def test_connections_by_windows_netstat(self):
self.check_resolver(Resolver.NETSTAT_WINDOWS)
def test_connections_by_ss(self):
self.check_resolver(Resolver.SS)
def test_connections_by_lsof(self):
self.check_resolver(Resolver.LSOF)
def test_connections_by_bsd_sockstat(self):
self.check_resolver(Resolver.BSD_SOCKSTAT)
def test_connections_by_bsd_procstat(self):
self.check_resolver(Resolver.BSD_PROCSTAT)
def test_connections_by_bsd_fstat(self):
self.check_resolver(Resolver.BSD_FSTAT)
def test_that_we_are_checking_all_resolvers(self):
# Quick check to confirm that if we add a new Resolver, we include a test
# for it here.
recognized_resolvers = (
Resolver.PROC,
Resolver.NETSTAT,
Resolver.NETSTAT_WINDOWS,
Resolver.SS,
Resolver.LSOF,
Resolver.SOCKSTAT,
Resolver.BSD_SOCKSTAT,
Resolver.BSD_PROCSTAT,
Resolver.BSD_FSTAT,
)
for resolver in Resolver:
self.assertTrue(resolver in recognized_resolvers)
stem-1.6.0/test/integ/util/proc.py 0000664 0001750 0001750 00000004634 13124757510 017603 0 ustar atagar atagar 0000000 0000000 """
Integration tests for stem.util.proc functions against the tor process that
we're running.
"""
import os
import unittest
import test.require
import test.runner
from stem.util import proc
class TestProc(unittest.TestCase):
@test.require.proc
@test.require.ptrace
def test_cwd(self):
"""
Checks that stem.util.proc.cwd matches our tor instance's cwd.
"""
runner = test.runner.get_runner()
runner_pid, tor_cwd = runner.get_pid(), runner.get_tor_cwd()
self.assertEqual(tor_cwd, proc.cwd(runner_pid))
@test.require.proc
def test_uid(self):
"""
Checks that stem.util.proc.uid matches our tor instance's uid.
"""
tor_pid = test.runner.get_runner().get_pid()
self.assertEqual(os.geteuid(), proc.uid(tor_pid))
@test.require.proc
def test_memory_usage(self):
"""
Checks that stem.util.proc.memory_usage looks somewhat reasonable.
"""
tor_pid = test.runner.get_runner().get_pid()
res_size, vir_size = proc.memory_usage(tor_pid)
# checks that they're larger than a kilobyte
self.assertTrue(res_size > 1024)
self.assertTrue(vir_size > 1024)
@test.require.proc
def test_stats(self):
"""
Checks that stem.util.proc.stats looks somewhat reasonable.
"""
tor_cmd = test.runner.get_runner().get_tor_command(True)
tor_pid = test.runner.get_runner().get_pid()
command, utime, stime, start_time = proc.stats(tor_pid, 'command', 'utime', 'stime', 'start time')
self.assertEqual(tor_cmd, command)
self.assertTrue(float(utime) > 0)
self.assertTrue(float(stime) >= 0)
self.assertTrue(float(start_time) > proc.system_start_time())
@test.require.proc
@test.require.ptrace
def test_connections(self):
"""
Checks for our control port in the stem.util.proc.connections output if
we have one.
"""
runner = test.runner.get_runner()
if test.runner.Torrc.PORT not in runner.get_options():
self.skiTestp('(no control port)')
return
elif not os.access('/proc/net/tcp', os.R_OK) or not os.access('/proc/net/udp', os.R_OK):
self.skipTest('(proc lacks read permissions)')
return
# making a controller connection so that we have something to query for
with runner.get_tor_socket():
tor_pid = test.runner.get_runner().get_pid()
for conn in proc.connections(tor_pid):
if ('127.0.0.1', test.runner.CONTROL_PORT) == conn[:2]:
return
self.fail()
stem-1.6.0/test/integ/installation.py 0000664 0001750 0001750 00000012576 13165210535 020364 0 ustar atagar atagar 0000000 0000000 """
Tests installation of our library.
"""
import glob
import os
import shutil
import sys
import tarfile
import time
import unittest
import stem
import stem.util.system
import stem.util.test_tools
import test
from stem.util.test_tools import asynchronous
BASE_INSTALL_PATH = '/tmp/stem_test'
DIST_PATH = os.path.join(test.STEM_BASE, 'dist')
PYTHON_EXE = sys.executable if sys.executable else 'python'
INSTALL_MISMATCH_MSG = "Running 'python setup.py sdist' doesn't match our git contents in the following way. The manifest in our setup.py may need to be updated...\n\n"
def _assert_has_all_files(path):
"""
Check that all the files in the stem directory are present in the
installation. This is a very common gotcha since our setup.py
requires us to remember to add new modules and non-source files.
:raises: **AssertionError** files don't match our content
"""
expected, installed = set(), set()
for root, dirnames, filenames in os.walk(os.path.join(test.STEM_BASE, 'stem')):
for filename in filenames:
file_format = filename.split('.')[-1]
if file_format not in test.IGNORED_FILE_TYPES:
expected.add(os.path.join(root, filename)[len(test.STEM_BASE) + 1:])
for root, dirnames, filenames in os.walk(path):
for filename in filenames:
if not filename.endswith('.pyc') and not filename.endswith('egg-info'):
installed.add(os.path.join(root, filename)[len(path) + 1:])
missing = expected.difference(installed)
extra = installed.difference(expected)
if missing:
raise AssertionError("The following files were expected to be in our installation but weren't. Maybe our setup.py needs to be updated?\n\n%s" % '\n'.join(missing))
elif extra:
raise AssertionError("The following files weren't expected to be in our installation.\n\n%s" % '\n'.join(extra))
class TestInstallation(unittest.TestCase):
@staticmethod
def run_tests(args):
test_install = stem.util.test_tools.ASYNC_TESTS['test.integ.installation.test_install']
test_install.run()
stem.util.test_tools.ASYNC_TESTS['test.integ.installation.test_sdist'].run(test_install.pid())
@asynchronous
def test_install():
"""
Installs with 'python setup.py install' and checks we can use what we
install.
"""
try:
try:
stem.util.system.call('%s setup.py install --prefix %s' % (PYTHON_EXE, BASE_INSTALL_PATH), timeout = 60, cwd = test.STEM_BASE)
stem.util.system.call('%s setup.py clean --all' % PYTHON_EXE, timeout = 60, cwd = test.STEM_BASE) # tidy up the build directory
site_packages_paths = glob.glob('%s/lib*/*/site-packages' % BASE_INSTALL_PATH)
except Exception as exc:
raise AssertionError("Unable to install with 'python setup.py install': %s" % exc)
if len(site_packages_paths) != 1:
raise AssertionError('We should only have a single site-packages directory, but instead had: %s' % site_packages_paths)
install_path = site_packages_paths[0]
version_output = stem.util.system.call([PYTHON_EXE, '-c', "import sys;sys.path.insert(0, '%s');import stem;print(stem.__version__)" % install_path])[0]
if stem.__version__ != version_output:
raise AssertionError('We expected the installed version to be %s but was %s' % (stem.__version__, version_output))
_assert_has_all_files(install_path)
finally:
if os.path.exists(BASE_INSTALL_PATH):
shutil.rmtree(BASE_INSTALL_PATH)
@asynchronous
def test_sdist(dependency_pid):
"""
Creates a source distribution tarball with 'python setup.py sdist' and
checks that it matches the content of our git repository. This primarily is
meant to test that our MANIFEST.in is up to date.
"""
while stem.util.system.is_running(dependency_pid):
time.sleep(0.1) # we need to run these tests serially
git_dir = os.path.join(test.STEM_BASE, '.git')
if not stem.util.system.is_available('git'):
raise stem.util.test_tools.SkipTest('(git unavailable)')
elif not os.path.exists(git_dir):
raise stem.util.test_tools.SkipTest('(not a git checkout)')
if os.path.exists(DIST_PATH):
raise AssertionError("%s already exists, maybe you manually ran 'python setup.py sdist'?" % DIST_PATH)
try:
try:
stem.util.system.call('%s setup.py sdist --dryrun' % PYTHON_EXE, timeout = 60, cwd = test.STEM_BASE)
except Exception as exc:
raise AssertionError("Unable to run 'python setup.py sdist': %s" % exc)
git_contents = [line.split()[-1] for line in stem.util.system.call('git --git-dir=%s ls-tree --full-tree -r HEAD' % git_dir)]
# tarball has a prefix 'stem-[verion]' directory so stipping that out
dist_tar = tarfile.open(os.path.join(DIST_PATH, 'stem-dry-run-%s.tar.gz' % stem.__version__))
tar_contents = ['/'.join(info.name.split('/')[1:]) for info in dist_tar.getmembers() if info.isfile()]
issues = []
for path in git_contents:
if path not in tar_contents and path not in ['.gitignore', '.travis.yml']:
issues.append(' * %s is missing from our release tarball' % path)
for path in tar_contents:
if path not in git_contents and path not in ['MANIFEST.in', 'PKG-INFO']:
issues.append(" * %s isn't expected in our release tarball" % path)
if issues:
raise AssertionError(INSTALL_MISMATCH_MSG + '\n'.join(issues))
finally:
if os.path.exists(DIST_PATH):
shutil.rmtree(DIST_PATH)
stem-1.6.0/test/integ/connection/ 0000775 0001750 0001750 00000000000 13177674754 017461 5 ustar atagar atagar 0000000 0000000 stem-1.6.0/test/integ/connection/__init__.py 0000664 0001750 0001750 00000000126 13115423200 021533 0 ustar atagar atagar 0000000 0000000 """
Integration tests for stem.connection.
"""
__all__ = ['authenticate', 'connect']
stem-1.6.0/test/integ/connection/authentication.py 0000664 0001750 0001750 00000040106 13124757510 023033 0 ustar atagar atagar 0000000 0000000 """
Integration tests for authenticating to the control socket via
stem.connection.authenticate* functions.
"""
import os
import unittest
import stem.connection
import stem.socket
import stem.version
import test
import test.require
import test.runner
# Responses given by tor for various authentication failures. These may change
# in the future and if they do then this test should be updated.
COOKIE_AUTH_FAIL = 'Authentication failed: Wrong length on authentication cookie.'
SAFECOOKIE_AUTH_FAIL = 'Authentication failed: Wrong length for safe cookie response.'
PASSWORD_AUTH_FAIL = 'Authentication failed: Password did not match HashedControlPassword value from configuration. Maybe you tried a plain text password? If so, the standard requires that you put it in double quotes.'
MULTIPLE_AUTH_FAIL = 'Authentication failed: Password did not match HashedControlPassword *or* authentication cookie.'
SAFECOOKIE_AUTHCHALLENGE_FAIL = 'Cookie authentication is disabled'
# this only arises in cookie-only or password-only auth when we authenticate
# with the wrong value
INCORRECT_COOKIE_FAIL = 'Authentication failed: Authentication cookie did not match expected value.'
INCORRECT_SAFECOOKIE_FAIL = 'Authentication failed: Safe cookie response did not match expected value.'
INCORRECT_PASSWORD_FAIL = 'Authentication failed: Password did not match HashedControlPassword value from configuration'
def _can_authenticate(auth_type):
"""
Checks if a given authentication method can authenticate to our control
socket.
:param stem.connection.AuthMethod auth_type: authentication method to check
:returns: bool that's True if we should be able to authenticate and False otherwise
"""
runner = test.runner.get_runner()
tor_options = runner.get_options()
password_auth = test.runner.Torrc.PASSWORD in tor_options
cookie_auth = test.runner.Torrc.COOKIE in tor_options
safecookie_auth = cookie_auth and test.tor_version() >= stem.version.Requirement.AUTH_SAFECOOKIE
if not password_auth and not cookie_auth:
# open socket, anything but safecookie will work
return auth_type != stem.connection.AuthMethod.SAFECOOKIE
elif auth_type == stem.connection.AuthMethod.PASSWORD:
return password_auth
elif auth_type == stem.connection.AuthMethod.COOKIE:
return cookie_auth
elif auth_type == stem.connection.AuthMethod.SAFECOOKIE:
return safecookie_auth
else:
return False
def _get_auth_failure_message(auth_type):
"""
Provides the message that tor will respond with if our current method of
authentication fails. Note that this test will need to be updated if tor
changes its rejection reponse.
:param stem.connection.AuthMethod auth_type: authentication method to check
:returns: string with the rejection message that tor would provide
"""
tor_options = test.runner.get_runner().get_options()
password_auth = test.runner.Torrc.PASSWORD in tor_options
cookie_auth = test.runner.Torrc.COOKIE in tor_options
if cookie_auth and password_auth:
return MULTIPLE_AUTH_FAIL
elif cookie_auth:
if auth_type == stem.connection.AuthMethod.COOKIE:
return INCORRECT_COOKIE_FAIL
elif auth_type == stem.connection.AuthMethod.SAFECOOKIE:
return INCORRECT_SAFECOOKIE_FAIL
else:
return COOKIE_AUTH_FAIL
elif password_auth:
if auth_type == stem.connection.AuthMethod.PASSWORD:
return INCORRECT_PASSWORD_FAIL
else:
return PASSWORD_AUTH_FAIL
else:
# The only way that we should fail to authenticate to an open control
# socket is if we attempt via safecookie (since we get an 'unsupported'
# response via the AUTHCHALLENGE call rather than AUTHENTICATE). For
# anything else if we get here it indicates that this test has a bug.
if auth_type == stem.connection.AuthMethod.SAFECOOKIE:
return SAFECOOKIE_AUTHCHALLENGE_FAIL
raise ValueError("No methods of authentication. If this is an open socket then auth shouldn't fail.")
class TestAuthenticate(unittest.TestCase):
def setUp(self):
self.cookie_auth_methods = [stem.connection.AuthMethod.COOKIE]
if test.tor_version() >= stem.version.Requirement.AUTH_SAFECOOKIE:
self.cookie_auth_methods.append(stem.connection.AuthMethod.SAFECOOKIE)
@test.require.controller
def test_authenticate_general_socket(self):
"""
Tests that the authenticate function can authenticate to our socket.
"""
runner = test.runner.get_runner()
with runner.get_tor_socket(False) as control_socket:
stem.connection.authenticate(control_socket, test.runner.CONTROL_PASSWORD, runner.get_chroot())
test.runner.exercise_controller(self, control_socket)
@test.require.controller
def test_authenticate_general_controller(self):
"""
Tests that the authenticate function can authenticate via a Controller.
"""
runner = test.runner.get_runner()
with runner.get_tor_controller(False) as controller:
stem.connection.authenticate(controller, test.runner.CONTROL_PASSWORD, runner.get_chroot())
test.runner.exercise_controller(self, controller)
@test.require.controller
def test_authenticate_general_example(self):
"""
Tests the authenticate function with something like its pydoc example.
"""
runner = test.runner.get_runner()
tor_options = runner.get_options()
try:
control_socket = stem.socket.ControlPort(port = test.runner.CONTROL_PORT)
except stem.SocketError:
# assert that we didn't have a socket to connect to
self.assertFalse(test.runner.Torrc.PORT in tor_options)
return
try:
# this authenticate call should work for everything but password-only auth
stem.connection.authenticate(control_socket, chroot_path = runner.get_chroot())
test.runner.exercise_controller(self, control_socket)
except stem.connection.IncorrectSocketType:
self.fail()
except stem.connection.MissingPassword:
self.assertTrue(test.runner.Torrc.PASSWORD in tor_options)
controller_password = test.runner.CONTROL_PASSWORD
try:
stem.connection.authenticate_password(control_socket, controller_password)
test.runner.exercise_controller(self, control_socket)
except stem.connection.PasswordAuthFailed:
self.fail()
except stem.connection.AuthenticationFailure:
self.fail()
finally:
control_socket.close()
@test.require.controller
def test_authenticate_general_password(self):
"""
Tests the authenticate function's password argument.
"""
# this is a much better test if we're just using password auth, since
# authenticate will work reguardless if there's something else to
# authenticate with
runner = test.runner.get_runner()
tor_options = runner.get_options()
is_password_only = test.runner.Torrc.PASSWORD in tor_options and test.runner.Torrc.COOKIE not in tor_options
# tests without a password
with runner.get_tor_socket(False) as control_socket:
if is_password_only:
self.assertRaises(stem.connection.MissingPassword, stem.connection.authenticate, control_socket)
else:
stem.connection.authenticate(control_socket, chroot_path = runner.get_chroot())
test.runner.exercise_controller(self, control_socket)
# tests with the incorrect password
with runner.get_tor_socket(False) as control_socket:
if is_password_only:
self.assertRaises(stem.connection.IncorrectPassword, stem.connection.authenticate, control_socket, 'blarg')
else:
stem.connection.authenticate(control_socket, 'blarg', runner.get_chroot())
test.runner.exercise_controller(self, control_socket)
# tests with the right password
with runner.get_tor_socket(False) as control_socket:
stem.connection.authenticate(control_socket, test.runner.CONTROL_PASSWORD, runner.get_chroot())
test.runner.exercise_controller(self, control_socket)
@test.require.controller
def test_authenticate_general_cookie(self):
"""
Tests the authenticate function with only cookie authentication methods.
This manipulates our PROTOCOLINFO response to test each method
individually.
"""
runner = test.runner.get_runner()
tor_options = runner.get_options()
is_cookie_only = test.runner.Torrc.COOKIE in tor_options and test.runner.Torrc.PASSWORD not in tor_options
# test both cookie authentication mechanisms
with runner.get_tor_socket(False) as control_socket:
if is_cookie_only:
for method in (stem.connection.AuthMethod.COOKIE, stem.connection.AuthMethod.SAFECOOKIE):
protocolinfo_response = stem.connection.get_protocolinfo(control_socket)
if method in protocolinfo_response.auth_methods:
# narrow to *only* use cookie auth or safecooke, so we exercise
# both independently
protocolinfo_response.auth_methods = (method, )
stem.connection.authenticate(control_socket, chroot_path = runner.get_chroot(), protocolinfo_response = protocolinfo_response)
@test.require.controller
def test_authenticate_none(self):
"""
Tests the authenticate_none function.
"""
auth_type = stem.connection.AuthMethod.NONE
if _can_authenticate(auth_type):
self._check_auth(auth_type)
else:
self.assertRaises(stem.connection.OpenAuthRejected, self._check_auth, auth_type)
@test.require.controller
def test_authenticate_password(self):
"""
Tests the authenticate_password function.
"""
auth_type = stem.connection.AuthMethod.PASSWORD
auth_value = test.runner.CONTROL_PASSWORD
if _can_authenticate(auth_type):
self._check_auth(auth_type, auth_value)
else:
self.assertRaises(stem.connection.PasswordAuthRejected, self._check_auth, auth_type, auth_value)
# Check with an empty, invalid, and quoted password. These should work if
# we have no authentication, and fail otherwise.
for auth_value in ('', 'blarg', 'this has a " in it'):
if _can_authenticate(stem.connection.AuthMethod.NONE):
self._check_auth(auth_type, auth_value)
else:
if _can_authenticate(stem.connection.AuthMethod.PASSWORD):
exc_type = stem.connection.IncorrectPassword
else:
exc_type = stem.connection.PasswordAuthRejected
self.assertRaises(exc_type, self._check_auth, auth_type, auth_value)
@test.require.controller
def test_wrong_password_with_controller(self):
"""
We ran into a race condition where providing the wrong password to the
Controller caused inconsistent responses. Checking for that...
https://trac.torproject.org/projects/tor/ticket/22679
"""
runner = test.runner.get_runner()
if test.runner.Torrc.PASSWORD not in runner.get_options() or test.runner.Torrc.COOKIE in runner.get_options():
self.skipTest('(requires only password auth)')
return
for i in range(10):
with runner.get_tor_controller(False) as controller:
self.assertRaises(stem.connection.IncorrectPassword, controller.authenticate, 'wrong_password')
@test.require.controller
def test_authenticate_cookie(self):
"""
Tests the authenticate_cookie function.
"""
auth_value = test.runner.get_runner().get_auth_cookie_path()
for auth_type in self.cookie_auth_methods:
if not os.path.exists(auth_value):
# If the authentication cookie doesn't exist then we'll be getting an
# error for that rather than rejection. This will even fail if
# _can_authenticate is true because we *can* authenticate with cookie
# auth but the function will short circuit with failure due to the
# missing file.
self.assertRaises(stem.connection.UnreadableCookieFile, self._check_auth, auth_type, auth_value, False)
elif _can_authenticate(auth_type):
self._check_auth(auth_type, auth_value)
else:
self.assertRaises(stem.connection.CookieAuthRejected, self._check_auth, auth_type, auth_value, False)
@test.require.controller
def test_authenticate_cookie_invalid(self):
"""
Tests the authenticate_cookie function with a properly sized but incorrect
value.
"""
auth_value = test.runner.get_runner().get_test_dir('fake_cookie')
# we need to create a 32 byte cookie file to load from
fake_cookie = open(auth_value, 'w')
fake_cookie.write('0' * 32)
fake_cookie.close()
for auth_type in self.cookie_auth_methods:
if _can_authenticate(stem.connection.AuthMethod.NONE):
# authentication will work anyway unless this is safecookie
if auth_type == stem.connection.AuthMethod.COOKIE:
self._check_auth(auth_type, auth_value)
elif auth_type == stem.connection.AuthMethod.SAFECOOKIE:
exc_type = stem.connection.CookieAuthRejected
self.assertRaises(exc_type, self._check_auth, auth_type, auth_value)
else:
if auth_type == stem.connection.AuthMethod.SAFECOOKIE:
if _can_authenticate(auth_type):
exc_type = stem.connection.AuthSecurityFailure
else:
exc_type = stem.connection.CookieAuthRejected
elif _can_authenticate(auth_type):
exc_type = stem.connection.IncorrectCookieValue
else:
exc_type = stem.connection.CookieAuthRejected
self.assertRaises(exc_type, self._check_auth, auth_type, auth_value, False)
os.remove(auth_value)
@test.require.controller
def test_authenticate_cookie_missing(self):
"""
Tests the authenticate_cookie function with a path that really, really
shouldn't exist.
"""
for auth_type in self.cookie_auth_methods:
auth_value = "/if/this/exists/then/they're/asking/for/a/failure"
self.assertRaises(stem.connection.UnreadableCookieFile, self._check_auth, auth_type, auth_value, False)
@test.require.controller
def test_authenticate_cookie_wrong_size(self):
"""
Tests the authenticate_cookie function with our torrc as an auth cookie.
This is to confirm that we won't read arbitrary files to the control
socket.
"""
auth_value = test.runner.get_runner().get_torrc_path(True)
for auth_type in self.cookie_auth_methods:
if os.path.getsize(auth_value) == 32:
# Weird coincidence? Fail so we can pick another file to check against.
self.fail('Our torrc is 32 bytes, preventing the test_authenticate_cookie_wrong_size test from running.')
else:
self.assertRaises(stem.connection.IncorrectCookieSize, self._check_auth, auth_type, auth_value, False)
def _check_auth(self, auth_type, auth_arg = None, check_message = True):
"""
Attempts to use the given type of authentication against tor's control
socket. If it succeeds then we check that the socket can then be used. If
not then we check that this gives a message that we'd expect then raises
the exception.
:param stem.connection.AuthMethod auth_type: method by which we should authentiate to the control socket
:param str auth_arg: argument to be passed to the authentication function
:param bool check_message: checks that failure messages are what we'd expect
:raises: :class:`stem.connection.AuthenticationFailure` if the authentication fails
"""
with test.runner.get_runner().get_tor_socket(False) as control_socket:
# run the authentication, re-raising if there's a problem
try:
if auth_type == stem.connection.AuthMethod.NONE:
stem.connection.authenticate_none(control_socket)
elif auth_type == stem.connection.AuthMethod.PASSWORD:
stem.connection.authenticate_password(control_socket, auth_arg)
elif auth_type == stem.connection.AuthMethod.COOKIE:
stem.connection.authenticate_cookie(control_socket, auth_arg)
elif auth_type == stem.connection.AuthMethod.SAFECOOKIE:
stem.connection.authenticate_safecookie(control_socket, auth_arg)
test.runner.exercise_controller(self, control_socket)
except stem.connection.AuthenticationFailure as exc:
# authentication functions should re-attach on failure
self.assertTrue(control_socket.is_alive())
# check that we got the failure message that we'd expect
if check_message:
failure_msg = _get_auth_failure_message(auth_type)
self.assertEqual(failure_msg, str(exc))
raise exc
stem-1.6.0/test/integ/connection/connect.py 0000664 0001750 0001750 00000006045 13146346524 021454 0 ustar atagar atagar 0000000 0000000 """
Integration tests for the connect_* convenience functions.
"""
import unittest
import stem.connection
import test.require
import test.runner
try:
from StringIO import StringIO
except ImportError:
from io import StringIO
try:
# added in python 3.3
from unittest.mock import patch
except ImportError:
from mock import patch
class TestConnect(unittest.TestCase):
@test.require.controller
@patch('sys.stdout', new_callable = StringIO)
def test_connect(self, stdout_mock):
"""
Basic sanity checks for the connect function.
"""
runner = test.runner.get_runner()
control_socket = stem.connection.connect(
control_port = ('127.0.0.1', test.runner.CONTROL_PORT),
control_socket = test.runner.CONTROL_SOCKET_PATH,
password = test.runner.CONTROL_PASSWORD,
chroot_path = runner.get_chroot(),
controller = None)
test.runner.exercise_controller(self, control_socket)
self.assertEqual('', stdout_mock.getvalue())
@test.require.controller
@patch('sys.stdout', new_callable = StringIO)
def test_connect_port(self, stdout_mock):
"""
Basic sanity checks for the connect_port function.
"""
runner = test.runner.get_runner()
control_socket = stem.connection.connect_port(
port = test.runner.CONTROL_PORT,
password = test.runner.CONTROL_PASSWORD,
chroot_path = runner.get_chroot(),
controller = None)
if test.runner.Torrc.PORT in runner.get_options():
test.runner.exercise_controller(self, control_socket)
control_socket.close()
self.assertEqual('', stdout_mock.getvalue())
else:
self.assertEqual(control_socket, None)
@test.require.controller
@patch('sys.stdout', new_callable = StringIO)
def test_connect_socket_file(self, stdout_mock):
"""
Basic sanity checks for the connect_socket_file function.
"""
runner = test.runner.get_runner()
control_socket = stem.connection.connect_socket_file(
path = test.runner.CONTROL_SOCKET_PATH,
password = test.runner.CONTROL_PASSWORD,
chroot_path = runner.get_chroot(),
controller = None)
if test.runner.Torrc.SOCKET in runner.get_options():
test.runner.exercise_controller(self, control_socket)
control_socket.close()
self.assertEqual('', stdout_mock.getvalue())
else:
self.assertEqual(control_socket, None)
@test.require.controller
@patch('sys.stdout', new_callable = StringIO)
def test_connect_to_socks_port(self, stdout_mock):
"""
Common user gotcha is connecting to the SocksPort or ORPort rather than the
ControlPort. Testing that connecting to the SocksPort errors in a
reasonable way.
"""
runner = test.runner.get_runner()
control_socket = stem.connection.connect_port(
port = test.runner.SOCKS_PORT,
chroot_path = runner.get_chroot(),
controller = None)
self.assertEqual(None, control_socket)
self.assertEqual('Please check in your torrc that 1112 is the ControlPort. Maybe you\nconfigured it to be the ORPort or SocksPort instead?\n', stdout_mock.getvalue())
stem-1.6.0/test/integ/control/ 0000775 0001750 0001750 00000000000 13177674754 017002 5 ustar atagar atagar 0000000 0000000 stem-1.6.0/test/integ/control/base_controller.py 0000664 0001750 0001750 00000020421 13124757510 022510 0 ustar atagar atagar 0000000 0000000 """
Integration tests for the stem.control.BaseController class.
"""
import os
import hashlib
import re
import threading
import time
import unittest
import stem.control
import stem.socket
import stem.util.system
import test.require
import test.runner
class StateObserver(object):
"""
Simple container for listening to ControlSocket state changes and
rembembering them for the test.
"""
controller = None
state = None
timestamp = None
def reset(self):
self.controller = None
self.state = None
self.timestamp = None
def listener(self, controller, state, timestamp):
self.controller = controller
self.state = state
self.timestamp = timestamp
class TestBaseController(unittest.TestCase):
@test.require.controller
def test_connect_repeatedly(self):
"""
Connects and closes the socket repeatedly. This is a simple attempt to
trigger concurrency issues.
"""
if stem.util.system.is_mac():
self.skipTest('(ticket #6235)')
return
with test.runner.get_runner().get_tor_socket() as control_socket:
controller = stem.control.BaseController(control_socket)
for _ in range(50):
controller.connect()
controller.close()
@test.require.controller
def test_msg(self):
"""
Tests a basic query with the msg() method.
"""
with test.runner.get_runner().get_tor_socket() as control_socket:
controller = stem.control.BaseController(control_socket)
test.runner.exercise_controller(self, controller)
@test.require.controller
def test_msg_invalid(self):
"""
Tests the msg() method against an invalid controller command.
"""
with test.runner.get_runner().get_tor_socket() as control_socket:
controller = stem.control.BaseController(control_socket)
response = controller.msg('invalid')
self.assertEqual('Unrecognized command "invalid"', str(response))
@test.require.controller
def test_msg_invalid_getinfo(self):
"""
Tests the msg() method against a non-existant GETINFO option.
"""
with test.runner.get_runner().get_tor_socket() as control_socket:
controller = stem.control.BaseController(control_socket)
response = controller.msg('GETINFO blarg')
self.assertEqual('Unrecognized key "blarg"', str(response))
@test.require.controller
def test_msg_repeatedly(self):
"""
Connects, sends a burst of messages, and closes the socket repeatedly. This
is a simple attempt to trigger concurrency issues.
"""
if stem.util.system.is_mac():
self.skipTest('(ticket #6235)')
return
with test.runner.get_runner().get_tor_socket() as control_socket:
controller = stem.control.BaseController(control_socket)
def run_getinfo():
for _ in range(50):
try:
controller.msg('GETINFO version')
controller.msg('GETINFO blarg')
controller.msg('blarg')
except stem.ControllerError:
pass
message_threads = []
for _ in range(5):
msg_thread = threading.Thread(target = run_getinfo)
message_threads.append(msg_thread)
msg_thread.setDaemon(True)
msg_thread.start()
for index in range(50):
controller.connect()
controller.close()
for msg_thread in message_threads:
msg_thread.join()
@test.require.controller
def test_asynchronous_event_handling(self):
"""
Check that we can both receive asynchronous events while hammering our
socket with queries, and checks that when a controller is closed the
listeners will still receive all of the enqueued events.
"""
class ControlledListener(stem.control.BaseController):
"""
Controller that blocks event handling until told to do so.
"""
def __init__(self, control_socket):
stem.control.BaseController.__init__(self, control_socket)
self.received_events = []
self.receive_notice = threading.Event()
def _handle_event(self, event_message):
self.receive_notice.wait()
self.received_events.append(event_message)
with test.runner.get_runner().get_tor_socket() as control_socket:
controller = ControlledListener(control_socket)
controller.msg('SETEVENTS CONF_CHANGED')
for i in range(10):
fingerprint = hashlib.sha1(os.urandom(20)).hexdigest().upper()
controller.msg('SETCONF NodeFamily=%s' % fingerprint)
test.runner.exercise_controller(self, controller)
controller.msg('SETEVENTS')
controller.msg('RESETCONF NodeFamily')
# Concurrently shut down the controller. We need to do this in another
# thread because it'll block on the event handling, which in turn is
# currently blocking on the reveive_notice.
close_thread = threading.Thread(target = controller.close, name = 'Closing controller')
close_thread.setDaemon(True)
close_thread.start()
# Finally start handling the BW events that we've received. We should
# have at least a couple of them.
controller.receive_notice.set()
close_thread.join()
self.assertTrue(len(controller.received_events) >= 2)
for conf_changed_event in controller.received_events:
self.assertTrue(re.match('CONF_CHANGED\nNodeFamily=*', str(conf_changed_event)))
self.assertTrue(conf_changed_event.raw_content().startswith('650-CONF_CHANGED\r\n650-NodeFamily='))
self.assertEqual(('650', '-'), conf_changed_event.content()[0][:2])
@test.require.controller
def test_get_latest_heartbeat(self):
"""
Basic check for get_latest_heartbeat().
"""
# makes a getinfo query, then checks that the heartbeat is close to now
with test.runner.get_runner().get_tor_socket() as control_socket:
controller = stem.control.BaseController(control_socket)
controller.msg('GETINFO version')
self.assertTrue((time.time() - controller.get_latest_heartbeat()) < 5)
@test.require.controller
def test_status_notifications(self):
"""
Checks basic functionality of the add_status_listener() and
remove_status_listener() methods.
"""
state_observer = StateObserver()
with test.runner.get_runner().get_tor_socket(False) as control_socket:
controller = stem.control.BaseController(control_socket)
controller.add_status_listener(state_observer.listener, False)
controller.close()
self.assertEqual(controller, state_observer.controller)
self.assertEqual(stem.control.State.CLOSED, state_observer.state)
self.assertTrue(state_observer.timestamp <= time.time())
self.assertTrue(state_observer.timestamp > time.time() - 1.0)
state_observer.reset()
controller.connect()
self.assertEqual(controller, state_observer.controller)
self.assertEqual(stem.control.State.INIT, state_observer.state)
self.assertTrue(state_observer.timestamp <= time.time())
self.assertTrue(state_observer.timestamp > time.time() - 1.0)
state_observer.reset()
# cause the socket to shut down without calling close()
controller.msg('Blarg!')
self.assertRaises(stem.SocketClosed, controller.msg, 'blarg')
self.assertEqual(controller, state_observer.controller)
self.assertEqual(stem.control.State.CLOSED, state_observer.state)
self.assertTrue(state_observer.timestamp <= time.time())
self.assertTrue(state_observer.timestamp > time.time() - 1.0)
state_observer.reset()
# remove listener and make sure we don't get further notices
controller.remove_status_listener(state_observer.listener)
controller.connect()
self.assertEqual(None, state_observer.controller)
self.assertEqual(None, state_observer.state)
self.assertEqual(None, state_observer.timestamp)
state_observer.reset()
# add with spawn as true, we need a little delay on this since we then
# get the notice asynchronously
controller.add_status_listener(state_observer.listener, True)
controller.close()
time.sleep(0.001) # not much work going on so this doesn't need to be much
self.assertEqual(controller, state_observer.controller)
self.assertEqual(stem.control.State.CLOSED, state_observer.state)
self.assertTrue(state_observer.timestamp <= time.time())
self.assertTrue(state_observer.timestamp > time.time() - 1.0)
state_observer.reset()
stem-1.6.0/test/integ/control/__init__.py 0000664 0001750 0001750 00000000131 13115423200 021050 0 ustar atagar atagar 0000000 0000000 """
Integration tests for stem.control.
"""
__all__ = ['base_controller', 'controller']
stem-1.6.0/test/integ/control/controller.py 0000664 0001750 0001750 00000143534 13136412262 021524 0 ustar atagar atagar 0000000 0000000 """
Integration tests for the stem.control.Controller class.
"""
import os
import shutil
import socket
import tempfile
import threading
import time
import unittest
import stem.connection
import stem.control
import stem.descriptor.reader
import stem.descriptor.router_status_entry
import stem.response.protocolinfo
import stem.socket
import stem.util.str_tools
import stem.version
import test
import test.network
import test.require
import test.runner
from stem import Flag, Signal
from stem.control import EventType, Listener, State
from stem.exit_policy import ExitPolicy
from stem.version import Requirement
# Router status entry for a relay with a nickname other than 'Unnamed'. This is
# used for a few tests that need to look up a relay.
TEST_ROUTER_STATUS_ENTRY = None
class TestController(unittest.TestCase):
@test.require.only_run_once
@test.require.controller
def test_missing_capabilities(self):
"""
Check to see if tor supports any events, signals, or features that we
don't.
"""
with test.runner.get_runner().get_tor_controller() as controller:
for event in controller.get_info('events/names').split():
if event not in EventType:
test.register_new_capability('Event', event)
for signal in controller.get_info('signal/names').split():
if signal not in Signal:
test.register_new_capability('Signal', signal)
# new features should simply be added to enable_feature()'s docs
for feature in controller.get_info('features/names').split():
if feature not in ('EXTENDED_EVENTS', 'VERBOSE_NAMES'):
test.register_new_capability('Feature', feature)
def test_from_port(self):
"""
Basic sanity check for the from_port constructor.
"""
if test.runner.Torrc.PORT in test.runner.get_runner().get_options():
with stem.control.Controller.from_port(port = test.runner.CONTROL_PORT) as controller:
self.assertTrue(isinstance(controller, stem.control.Controller))
else:
self.assertRaises(stem.SocketError, stem.control.Controller.from_port, '127.0.0.1', test.runner.CONTROL_PORT)
def test_from_socket_file(self):
"""
Basic sanity check for the from_socket_file constructor.
"""
if test.runner.Torrc.SOCKET in test.runner.get_runner().get_options():
with stem.control.Controller.from_socket_file(path = test.runner.CONTROL_SOCKET_PATH) as controller:
self.assertTrue(isinstance(controller, stem.control.Controller))
else:
self.assertRaises(stem.SocketError, stem.control.Controller.from_socket_file, test.runner.CONTROL_SOCKET_PATH)
@test.require.controller
@test.require.version(Requirement.EVENT_SIGNAL)
def test_reset_notification(self):
"""
Checks that a notificiation listener is... well, notified of SIGHUPs.
"""
with test.runner.get_runner().get_tor_controller() as controller:
received_events = []
def status_listener(my_controller, state, timestamp):
received_events.append((my_controller, state, timestamp))
controller.add_status_listener(status_listener)
before = time.time()
controller.signal(Signal.HUP)
# I really hate adding a sleep here, but signal() is non-blocking.
while len(received_events) == 0:
if (time.time() - before) > 2:
self.fail("We've waited a couple seconds for SIGHUP to generate an event, but it didn't come")
time.sleep(0.001)
after = time.time()
self.assertEqual(1, len(received_events))
state_controller, state_type, state_timestamp = received_events[0]
self.assertEqual(controller, state_controller)
self.assertEqual(State.RESET, state_type)
self.assertTrue(state_timestamp > before and state_timestamp < after)
controller.reset_conf('__OwningControllerProcess')
@test.require.controller
def test_event_handling(self):
"""
Add a couple listeners for various events and make sure that they receive
them. Then remove the listeners.
"""
event_notice1, event_notice2 = threading.Event(), threading.Event()
event_buffer1, event_buffer2 = [], []
def listener1(event):
event_buffer1.append(event)
event_notice1.set()
def listener2(event):
event_buffer2.append(event)
event_notice2.set()
runner = test.runner.get_runner()
with runner.get_tor_controller() as controller:
controller.add_event_listener(listener1, EventType.CONF_CHANGED)
controller.add_event_listener(listener2, EventType.CONF_CHANGED, EventType.DEBUG)
# The NodeFamily is a harmless option we can toggle
controller.set_conf('NodeFamily', 'FD4CC275C5AA4D27A487C6CA29097900F85E2C33')
# Wait for the event. Assert that we get it within 10 seconds
event_notice1.wait(10)
self.assertEqual(len(event_buffer1), 1)
event_notice1.clear()
event_notice2.wait(10)
self.assertTrue(len(event_buffer2) >= 1)
event_notice2.clear()
# Checking that a listener's no longer called after being removed.
controller.remove_event_listener(listener2)
buffer2_size = len(event_buffer2)
controller.set_conf('NodeFamily', 'A82F7EFDB570F6BC801805D0328D30A99403C401')
event_notice1.wait(10)
self.assertEqual(len(event_buffer1), 2)
event_notice1.clear()
self.assertEqual(buffer2_size, len(event_buffer2))
for event in event_buffer1:
self.assertTrue(isinstance(event, stem.response.events.Event))
self.assertEqual(0, len(event.positional_args))
self.assertEqual({}, event.keyword_args)
self.assertTrue(isinstance(event, stem.response.events.ConfChangedEvent))
controller.reset_conf('NodeFamily')
@test.require.controller
def test_reattaching_listeners(self):
"""
Checks that event listeners are re-attached when a controller disconnects
then reconnects to tor.
"""
event_notice = threading.Event()
event_buffer = []
def listener(event):
event_buffer.append(event)
event_notice.set()
runner = test.runner.get_runner()
with runner.get_tor_controller() as controller:
controller.add_event_listener(listener, EventType.CONF_CHANGED)
# trigger an event
controller.set_conf('NodeFamily', 'FD4CC275C5AA4D27A487C6CA29097900F85E2C33')
event_notice.wait(4)
self.assertTrue(len(event_buffer) >= 1)
# disconnect, then reconnect and check that we get events again
controller.close()
event_notice.clear()
event_buffer = []
controller.connect()
controller.authenticate(password = test.runner.CONTROL_PASSWORD)
self.assertTrue(len(event_buffer) == 0)
controller.set_conf('NodeFamily', 'A82F7EFDB570F6BC801805D0328D30A99403C401')
event_notice.wait(4)
self.assertTrue(len(event_buffer) >= 1)
controller.reset_conf('NodeFamily')
@test.require.controller
def test_getinfo(self):
"""
Exercises GETINFO with valid and invalid queries.
"""
runner = test.runner.get_runner()
with runner.get_tor_controller() as controller:
# successful single query
torrc_path = runner.get_torrc_path()
self.assertEqual(torrc_path, controller.get_info('config-file'))
self.assertEqual(torrc_path, controller.get_info('config-file', 'ho hum'))
expected = {'config-file': torrc_path}
self.assertEqual(expected, controller.get_info(['config-file']))
self.assertEqual(expected, controller.get_info(['config-file'], 'ho hum'))
# successful batch query, we don't know the values so just checking for
# the keys
getinfo_params = set(['version', 'config-file', 'config/names'])
self.assertEqual(getinfo_params, set(controller.get_info(['version', 'config-file', 'config/names']).keys()))
# non-existant option
self.assertRaises(stem.ControllerError, controller.get_info, 'blarg')
self.assertEqual('ho hum', controller.get_info('blarg', 'ho hum'))
# empty input
self.assertRaises(stem.ControllerError, controller.get_info, '')
self.assertEqual('ho hum', controller.get_info('', 'ho hum'))
self.assertEqual({}, controller.get_info([]))
self.assertEqual({}, controller.get_info([], {}))
@test.require.controller
def test_get_version(self):
"""
Test that the convenient method get_version() works.
"""
runner = test.runner.get_runner()
with runner.get_tor_controller() as controller:
version = controller.get_version()
self.assertTrue(isinstance(version, stem.version.Version))
self.assertEqual(version, test.tor_version())
@test.require.controller
def test_get_exit_policy(self):
"""
Sanity test for get_exit_policy(). We have the default policy (no
ExitPolicy set) which is a little... long due to the boilerplate.
"""
expected = ExitPolicy(
'reject 0.0.0.0/8:*',
'reject 169.254.0.0/16:*',
'reject 127.0.0.0/8:*',
'reject 192.168.0.0/16:*',
'reject 10.0.0.0/8:*',
'reject 172.16.0.0/12:*',
# this is where 'reject [public_addr]:*' may or may not be
'reject *:25',
'reject *:119',
'reject *:135-139',
'reject *:445',
'reject *:563',
'reject *:1214',
'reject *:4661-4666',
'reject *:6346-6429',
'reject *:6699',
'reject *:6881-6999',
'accept *:*',
)
runner = test.runner.get_runner()
with runner.get_tor_controller() as controller:
# We can't simply compare the policies because the tor policy may or may
# not have a reject entry for our public address. Hence, stripping it
# from the policy's string, then comparing those.
policy_str = str(controller.get_exit_policy())
public_addr_start = policy_str.find('reject 172.16.0.0/12:*') + 22
public_addr_end = policy_str.find(', reject *:25')
policy_str = policy_str[:public_addr_start] + policy_str[public_addr_end:]
self.assertEqual(str(expected), policy_str)
@test.require.controller
def test_authenticate(self):
"""
Test that the convenient method authenticate() works.
"""
runner = test.runner.get_runner()
with runner.get_tor_controller(False) as controller:
controller.authenticate(test.runner.CONTROL_PASSWORD)
test.runner.exercise_controller(self, controller)
@test.require.controller
def test_protocolinfo(self):
"""
Test that the convenient method protocolinfo() works.
"""
runner = test.runner.get_runner()
with runner.get_tor_controller(False) as controller:
protocolinfo = controller.get_protocolinfo()
self.assertTrue(isinstance(protocolinfo, stem.response.protocolinfo.ProtocolInfoResponse))
# Doing a sanity test on the ProtocolInfoResponse instance returned.
tor_options = runner.get_options()
auth_methods = []
if test.runner.Torrc.COOKIE in tor_options:
auth_methods.append(stem.response.protocolinfo.AuthMethod.COOKIE)
if test.tor_version() >= stem.version.Requirement.AUTH_SAFECOOKIE:
auth_methods.append(stem.response.protocolinfo.AuthMethod.SAFECOOKIE)
if test.runner.Torrc.PASSWORD in tor_options:
auth_methods.append(stem.response.protocolinfo.AuthMethod.PASSWORD)
if not auth_methods:
auth_methods.append(stem.response.protocolinfo.AuthMethod.NONE)
self.assertEqual(tuple(auth_methods), protocolinfo.auth_methods)
@test.require.controller
def test_getconf(self):
"""
Exercises GETCONF with valid and invalid queries.
"""
runner = test.runner.get_runner()
with runner.get_tor_controller() as controller:
control_socket = controller.get_socket()
if isinstance(control_socket, stem.socket.ControlPort):
connection_value = str(control_socket.get_port())
config_key = 'ControlPort'
elif isinstance(control_socket, stem.socket.ControlSocketFile):
connection_value = str(control_socket.get_socket_path())
config_key = 'ControlSocket'
# successful single query
self.assertEqual(connection_value, controller.get_conf(config_key))
self.assertEqual(connection_value, controller.get_conf(config_key, 'la-di-dah'))
# succeessful batch query
expected = {config_key: [connection_value]}
self.assertEqual(expected, controller.get_conf_map([config_key]))
self.assertEqual(expected, controller.get_conf_map([config_key], 'la-di-dah'))
request_params = ['ControlPORT', 'dirport', 'datadirectory']
reply_params = controller.get_conf_map(request_params, multiple=False).keys()
self.assertEqual(set(request_params), set(reply_params))
# queries an option that is unset
self.assertEqual(None, controller.get_conf('HTTPSProxy'))
self.assertEqual('la-di-dah', controller.get_conf('HTTPSProxy', 'la-di-dah'))
self.assertEqual([], controller.get_conf('HTTPSProxy', [], multiple = True))
# non-existant option(s)
self.assertRaises(stem.InvalidArguments, controller.get_conf, 'blarg')
self.assertEqual('la-di-dah', controller.get_conf('blarg', 'la-di-dah'))
self.assertRaises(stem.InvalidArguments, controller.get_conf_map, 'blarg')
self.assertEqual({'blarg': 'la-di-dah'}, controller.get_conf_map('blarg', 'la-di-dah'))
self.assertRaises(stem.InvalidRequest, controller.get_conf_map, ['blarg', 'huadf'], multiple = True)
self.assertEqual({'erfusdj': 'la-di-dah', 'afiafj': 'la-di-dah'}, controller.get_conf_map(['erfusdj', 'afiafj'], 'la-di-dah', multiple = True))
# multivalue configuration keys
nodefamilies = [('abc', 'xyz', 'pqrs'), ('mno', 'tuv', 'wxyz')]
controller.msg('SETCONF %s' % ' '.join(['nodefamily="' + ','.join(x) + '"' for x in nodefamilies]))
self.assertEqual([','.join(n) for n in nodefamilies], controller.get_conf('nodefamily', multiple = True))
controller.msg('RESETCONF NodeFamily')
# empty input
self.assertEqual(None, controller.get_conf(''))
self.assertEqual({}, controller.get_conf_map([]))
self.assertEqual({}, controller.get_conf_map(['']))
self.assertEqual(None, controller.get_conf(' '))
self.assertEqual({}, controller.get_conf_map([' ', ' ']))
self.assertEqual('la-di-dah', controller.get_conf('', 'la-di-dah'))
self.assertEqual({}, controller.get_conf_map('', 'la-di-dah'))
self.assertEqual({}, controller.get_conf_map([], 'la-di-dah'))
@test.require.controller
def test_is_set(self):
"""
Exercises our is_set() method.
"""
runner = test.runner.get_runner()
with runner.get_tor_controller() as controller:
custom_options = controller._get_custom_options()
self.assertTrue('ControlPort' in custom_options or 'ControlSocket' in custom_options)
self.assertEqual('1', custom_options['DownloadExtraInfo'])
self.assertEqual('1112', custom_options['SocksPort'])
self.assertTrue(controller.is_set('DownloadExtraInfo'))
self.assertTrue(controller.is_set('SocksPort'))
self.assertFalse(controller.is_set('CellStatistics'))
self.assertFalse(controller.is_set('ConnLimit'))
# check we update when setting and resetting values
controller.set_conf('ConnLimit', '1005')
self.assertTrue(controller.is_set('ConnLimit'))
controller.reset_conf('ConnLimit')
self.assertFalse(controller.is_set('ConnLimit'))
@test.require.controller
def test_hidden_services_conf(self):
"""
Exercises the hidden service family of methods (get_hidden_service_conf,
set_hidden_service_conf, create_hidden_service, and remove_hidden_service).
"""
runner = test.runner.get_runner()
test_dir = runner.get_test_dir()
service1_path = os.path.join(test_dir, 'test_hidden_service1')
service2_path = os.path.join(test_dir, 'test_hidden_service2')
service3_path = os.path.join(test_dir, 'test_hidden_service3')
service4_path = os.path.join(test_dir, 'test_hidden_service4')
with runner.get_tor_controller() as controller:
try:
# initially we shouldn't be running any hidden services
self.assertEqual({}, controller.get_hidden_service_conf())
# try setting a blank config, shouldn't have any impact
controller.set_hidden_service_conf({})
self.assertEqual({}, controller.get_hidden_service_conf())
# create a hidden service
initialconf = {
service1_path: {
'HiddenServicePort': [
(8020, '127.0.0.1', 8020),
(8021, '127.0.0.1', 8021),
],
'HiddenServiceVersion': '2',
},
service2_path: {
'HiddenServiceAuthorizeClient': 'stealth a, b',
'HiddenServicePort': [
(8030, '127.0.0.1', 8030),
(8031, '127.0.0.1', 8031),
(8032, '127.0.0.1', 8032),
]
},
}
controller.set_hidden_service_conf(initialconf)
self.assertEqual(initialconf, controller.get_hidden_service_conf())
# add already existing services, with/without explicit target
self.assertEqual(None, controller.create_hidden_service(service1_path, 8020))
self.assertEqual(None, controller.create_hidden_service(service1_path, 8021, target_port = 8021))
self.assertEqual(initialconf, controller.get_hidden_service_conf())
# add a new service, with/without explicit target
hs_path = os.path.join(os.getcwd(), service3_path)
hs_address1 = controller.create_hidden_service(hs_path, 8888).hostname
hs_address2 = controller.create_hidden_service(hs_path, 8989, target_port = 8021).hostname
self.assertEqual(hs_address1, hs_address2)
self.assertTrue(hs_address1.endswith('.onion'))
conf = controller.get_hidden_service_conf()
self.assertEqual(3, len(conf))
self.assertEqual(2, len(conf[hs_path]['HiddenServicePort']))
# remove a hidden service, the service dir should still be there
controller.remove_hidden_service(hs_path, 8888)
self.assertEqual(3, len(controller.get_hidden_service_conf()))
# remove a service completely, it should now be gone
controller.remove_hidden_service(hs_path, 8989)
self.assertEqual(2, len(controller.get_hidden_service_conf()))
# add a new service, this time with client authentication
hs_path = os.path.join(os.getcwd(), service4_path)
hs_attributes = controller.create_hidden_service(hs_path, 8888, auth_type = 'basic', client_names = ['c1', 'c2'])
self.assertEqual(2, len(hs_attributes.hostname.splitlines()))
self.assertEqual(2, len(hs_attributes.hostname_for_client))
self.assertTrue(hs_attributes.hostname_for_client['c1'].endswith('.onion'))
self.assertTrue(hs_attributes.hostname_for_client['c2'].endswith('.onion'))
conf = controller.get_hidden_service_conf()
self.assertEqual(3, len(conf))
self.assertEqual(1, len(conf[hs_path]['HiddenServicePort']))
# remove a hidden service
controller.remove_hidden_service(hs_path, 8888)
self.assertEqual(2, len(controller.get_hidden_service_conf()))
finally:
controller.set_hidden_service_conf({}) # drop hidden services created during the test
# clean up the hidden service directories created as part of this test
for path in (service1_path, service2_path, service3_path, service4_path):
try:
shutil.rmtree(path)
except:
pass
@test.require.controller
@test.require.version(Requirement.ADD_ONION)
def test_without_ephemeral_hidden_services(self):
"""
Exercises ephemeral hidden service methods when none are present.
"""
with test.runner.get_runner().get_tor_controller() as controller:
self.assertEqual([], controller.list_ephemeral_hidden_services())
self.assertEqual([], controller.list_ephemeral_hidden_services(detached = True))
self.assertEqual(False, controller.remove_ephemeral_hidden_service('gfzprpioee3hoppz'))
@test.require.controller
@test.require.version(Requirement.ADD_ONION)
def test_with_ephemeral_hidden_services(self):
"""
Exercises creating ephemeral hidden services and methods when they're
present.
"""
runner = test.runner.get_runner()
with runner.get_tor_controller() as controller:
# try creating a service with an invalid ports
for ports in (4567890, [4567, 4567890], {4567: '-:4567'}):
exc_msg = "ADD_ONION response didn't have an OK status: Invalid VIRTPORT/TARGET"
self.assertRaisesRegexp(stem.ProtocolError, exc_msg, controller.create_ephemeral_hidden_service, ports)
response = controller.create_ephemeral_hidden_service(4567)
self.assertEqual([response.service_id], controller.list_ephemeral_hidden_services())
self.assertTrue(response.private_key is not None)
self.assertEqual({}, response.client_auth)
# drop the service
self.assertEqual(True, controller.remove_ephemeral_hidden_service(response.service_id))
self.assertEqual([], controller.list_ephemeral_hidden_services())
# recreate the service with the same private key
recreate_response = controller.create_ephemeral_hidden_service(4567, key_type = response.private_key_type, key_content = response.private_key)
self.assertEqual([response.service_id], controller.list_ephemeral_hidden_services())
self.assertEqual(response.service_id, recreate_response.service_id)
# the response only includes the private key when making a new one
self.assertEqual(None, recreate_response.private_key)
self.assertEqual(None, recreate_response.private_key_type)
# create a service where we never see the private key
response = controller.create_ephemeral_hidden_service(4568, discard_key = True)
self.assertTrue(response.service_id in controller.list_ephemeral_hidden_services())
self.assertEqual(None, response.private_key)
self.assertEqual(None, response.private_key_type)
# other controllers shouldn't be able to see these hidden services
with runner.get_tor_controller() as second_controller:
self.assertEqual(2, len(controller.list_ephemeral_hidden_services()))
self.assertEqual(0, len(second_controller.list_ephemeral_hidden_services()))
@test.require.controller
@test.require.version(Requirement.ADD_ONION_BASIC_AUTH)
def test_with_ephemeral_hidden_services_basic_auth(self):
"""
Exercises creating ephemeral hidden services that uses basic authentication.
"""
runner = test.runner.get_runner()
with runner.get_tor_controller() as controller:
response = controller.create_ephemeral_hidden_service(4567, basic_auth = {'alice': 'nKwfvVPmTNr2k2pG0pzV4g', 'bob': None})
self.assertEqual([response.service_id], controller.list_ephemeral_hidden_services())
self.assertTrue(response.private_key is not None)
self.assertEqual(['bob'], list(response.client_auth.keys())) # newly created credentials were only created for bob
# drop the service
self.assertEqual(True, controller.remove_ephemeral_hidden_service(response.service_id))
self.assertEqual([], controller.list_ephemeral_hidden_services())
@test.require.controller
@test.require.version(Requirement.ADD_ONION_BASIC_AUTH)
def test_with_ephemeral_hidden_services_basic_auth_no_credentials(self):
"""
Exercises creating ephemeral hidden services when attempting to use basic
auth but not including any credentials.
"""
runner = test.runner.get_runner()
with runner.get_tor_controller() as controller:
exc_msg = "ADD_ONION response didn't have an OK status: No auth clients specified"
self.assertRaisesRegexp(stem.ProtocolError, exc_msg, controller.create_ephemeral_hidden_service, 4567, basic_auth = {})
@test.require.controller
@test.require.version(Requirement.ADD_ONION)
def test_with_detached_ephemeral_hidden_services(self):
"""
Exercises creating detached ephemeral hidden services and methods when
they're present.
"""
runner = test.runner.get_runner()
with runner.get_tor_controller() as controller:
response = controller.create_ephemeral_hidden_service(4567, detached = True)
self.assertEqual([], controller.list_ephemeral_hidden_services())
self.assertEqual([response.service_id], controller.list_ephemeral_hidden_services(detached = True))
# drop and recreate the service
self.assertEqual(True, controller.remove_ephemeral_hidden_service(response.service_id))
self.assertEqual([], controller.list_ephemeral_hidden_services(detached = True))
controller.create_ephemeral_hidden_service(4567, key_type = response.private_key_type, key_content = response.private_key, detached = True)
self.assertEqual([response.service_id], controller.list_ephemeral_hidden_services(detached = True))
# other controllers should be able to see this service, and drop it
with runner.get_tor_controller() as second_controller:
self.assertEqual([response.service_id], second_controller.list_ephemeral_hidden_services(detached = True))
self.assertEqual(True, second_controller.remove_ephemeral_hidden_service(response.service_id))
self.assertEqual([], controller.list_ephemeral_hidden_services(detached = True))
# recreate the service and confirms that it outlives this controller
response = second_controller.create_ephemeral_hidden_service(4567, detached = True)
self.assertEqual([response.service_id], controller.list_ephemeral_hidden_services(detached = True))
controller.remove_ephemeral_hidden_service(response.service_id)
@test.require.controller
@test.require.version(Requirement.ADD_ONION)
def test_rejecting_unanonymous_hidden_services_creation(self):
"""
Attempt to create a non-anonymous hidden service despite not setting
HiddenServiceSingleHopMode and HiddenServiceNonAnonymousMode.
"""
runner = test.runner.get_runner()
with runner.get_tor_controller() as controller:
self.assertEqual('Tor is in anonymous hidden service mode', str(controller.msg('ADD_ONION NEW:BEST Flags=NonAnonymous Port=4567')))
@test.require.controller
def test_set_conf(self):
"""
Exercises set_conf(), reset_conf(), and set_options() methods with valid
and invalid requests.
"""
runner = test.runner.get_runner()
tmpdir = tempfile.mkdtemp()
with runner.get_tor_controller() as controller:
try:
# successfully set a single option
connlimit = int(controller.get_conf('ConnLimit'))
controller.set_conf('connlimit', str(connlimit - 1))
self.assertEqual(connlimit - 1, int(controller.get_conf('ConnLimit')))
# successfully set a single list option
exit_policy = ['accept *:7777', 'reject *:*']
controller.set_conf('ExitPolicy', exit_policy)
self.assertEqual(exit_policy, controller.get_conf('ExitPolicy', multiple = True))
# fail to set a single option
try:
controller.set_conf('invalidkeyboo', 'abcde')
self.fail()
except stem.InvalidArguments as exc:
self.assertEqual(['invalidkeyboo'], exc.arguments)
# resets configuration parameters
controller.reset_conf('ConnLimit', 'ExitPolicy')
self.assertEqual(connlimit, int(controller.get_conf('ConnLimit')))
self.assertEqual(None, controller.get_conf('ExitPolicy'))
# successfully sets multiple config options
controller.set_options({
'connlimit': str(connlimit - 2),
'contactinfo': 'stem@testing',
})
self.assertEqual(connlimit - 2, int(controller.get_conf('ConnLimit')))
self.assertEqual('stem@testing', controller.get_conf('contactinfo'))
# fail to set multiple config options
try:
controller.set_options({
'contactinfo': 'stem@testing',
'bombay': 'vadapav',
})
self.fail()
except stem.InvalidArguments as exc:
self.assertEqual(['bombay'], exc.arguments)
# context-sensitive keys (the only retched things for which order matters)
controller.set_options((
('HiddenServiceDir', tmpdir),
('HiddenServicePort', '17234 127.0.0.1:17235'),
))
self.assertEqual(tmpdir, controller.get_conf('HiddenServiceDir'))
self.assertEqual('17234 127.0.0.1:17235', controller.get_conf('HiddenServicePort'))
finally:
# reverts configuration changes
controller.set_options((
('ExitPolicy', 'reject *:*'),
('ConnLimit', None),
('ContactInfo', None),
('HiddenServiceDir', None),
('HiddenServicePort', None),
), reset = True)
shutil.rmtree(tmpdir)
@test.require.controller
def test_set_conf_when_immutable(self):
"""
Issue a SETCONF for tor options that cannot be changed while running.
"""
with test.runner.get_runner().get_tor_controller() as controller:
self.assertRaisesRegexp(stem.InvalidArguments, "DisableAllSwap cannot be changed while tor's running", controller.set_conf, 'DisableAllSwap', '1')
self.assertRaisesRegexp(stem.InvalidArguments, "DisableAllSwap, User cannot be changed while tor's running", controller.set_options, {'User': 'atagar', 'DisableAllSwap': '1'})
@test.require.controller
@test.require.version(Requirement.LOADCONF)
def test_loadconf(self):
"""
Exercises Controller.load_conf with valid and invalid requests.
"""
runner = test.runner.get_runner()
with runner.get_tor_controller() as controller:
oldconf = runner.get_torrc_contents()
try:
# Check a request that changes our DataDir. Tor should rightfully balk
# at this...
#
# InvalidRequest: Transition not allowed: Failed to parse/validate
# config: While Tor is running, changing DataDirectory
# ("/home/atagar/Desktop/stem/test/data"->"/home/atagar/.tor") is not
# allowed.
self.assertRaises(stem.InvalidRequest, controller.load_conf, 'ContactInfo confloaded')
try:
controller.load_conf('Blahblah blah')
self.fail()
except stem.InvalidArguments as exc:
self.assertEqual(['Blahblah'], exc.arguments)
# valid config
controller.load_conf(runner.get_torrc_contents() + '\nContactInfo confloaded\n')
self.assertEqual('confloaded', controller.get_conf('ContactInfo'))
finally:
# reload original valid config
controller.load_conf(oldconf)
controller.reset_conf('__OwningControllerProcess')
@test.require.controller
def test_saveconf(self):
runner = test.runner.get_runner()
# only testing for success, since we need to run out of disk space to test
# for failure
with runner.get_tor_controller() as controller:
oldconf = runner.get_torrc_contents()
try:
controller.set_conf('ContactInfo', 'confsaved')
controller.save_conf()
with open(runner.get_torrc_path()) as torrcfile:
self.assertTrue('\nContactInfo confsaved\n' in torrcfile.read())
finally:
controller.load_conf(oldconf)
controller.save_conf()
controller.reset_conf('__OwningControllerProcess')
@test.require.controller
def test_get_ports(self):
"""
Test Controller.get_ports against a running tor instance.
"""
runner = test.runner.get_runner()
with runner.get_tor_controller() as controller:
self.assertEqual([], controller.get_ports(Listener.OR))
self.assertEqual([], controller.get_ports(Listener.DIR))
self.assertEqual([test.runner.SOCKS_PORT], controller.get_ports(Listener.SOCKS))
self.assertEqual([], controller.get_ports(Listener.TRANS))
self.assertEqual([], controller.get_ports(Listener.NATD))
self.assertEqual([], controller.get_ports(Listener.DNS))
if test.runner.Torrc.PORT in runner.get_options():
self.assertEqual([test.runner.CONTROL_PORT], controller.get_ports(Listener.CONTROL))
else:
self.assertEqual([], controller.get_ports(Listener.CONTROL))
@test.require.controller
def test_get_listeners(self):
"""
Test Controller.get_listeners against a running tor instance.
"""
runner = test.runner.get_runner()
with runner.get_tor_controller() as controller:
self.assertEqual([], controller.get_listeners(Listener.OR))
self.assertEqual([], controller.get_listeners(Listener.DIR))
self.assertEqual([('127.0.0.1', test.runner.SOCKS_PORT)], controller.get_listeners(Listener.SOCKS))
self.assertEqual([], controller.get_listeners(Listener.TRANS))
self.assertEqual([], controller.get_listeners(Listener.NATD))
self.assertEqual([], controller.get_listeners(Listener.DNS))
if test.runner.Torrc.PORT in runner.get_options():
self.assertEqual([('127.0.0.1', test.runner.CONTROL_PORT)], controller.get_listeners(Listener.CONTROL))
else:
self.assertEqual([], controller.get_listeners(Listener.CONTROL))
@test.require.controller
def test_get_socks_listeners(self):
"""
Test Controller.get_socks_listeners against a running tor instance.
"""
with test.runner.get_runner().get_tor_controller() as controller:
self.assertEqual([('127.0.0.1', 1112)], controller.get_socks_listeners())
@test.require.controller
@test.require.online
@test.require.version(stem.version.Version('0.1.2.2-alpha'))
def test_enable_feature(self):
"""
Test Controller.enable_feature with valid and invalid inputs.
"""
runner = test.runner.get_runner()
with runner.get_tor_controller() as controller:
self.assertTrue(controller.is_feature_enabled('VERBOSE_NAMES'))
self.assertTrue('VERBOSE_NAMES' in controller._enabled_features)
self.assertRaises(stem.InvalidArguments, controller.enable_feature, ['NOT', 'A', 'FEATURE'])
try:
controller.enable_feature(['NOT', 'A', 'FEATURE'])
except stem.InvalidArguments as exc:
self.assertEqual(['NOT'], exc.arguments)
else:
self.fail()
@test.require.controller
def test_signal(self):
"""
Test controller.signal with valid and invalid signals.
"""
with test.runner.get_runner().get_tor_controller() as controller:
# valid signal
controller.signal('CLEARDNSCACHE')
# invalid signals
self.assertRaises(stem.InvalidArguments, controller.signal, 'FOOBAR')
@test.require.controller
def test_newnym_availability(self):
"""
Test the is_newnym_available and get_newnym_wait methods.
"""
with test.runner.get_runner().get_tor_controller() as controller:
self.assertEqual(True, controller.is_newnym_available())
self.assertEqual(0.0, controller.get_newnym_wait())
controller.signal(stem.Signal.NEWNYM)
self.assertEqual(False, controller.is_newnym_available())
self.assertTrue(controller.get_newnym_wait() > 9.0)
@test.require.controller
@test.require.online
@test.require.version(Requirement.EXTENDCIRCUIT_PATH_OPTIONAL)
def test_extendcircuit(self):
with test.runner.get_runner().get_tor_controller() as controller:
circuit_id = controller.extend_circuit('0')
# check if our circuit was created
self.assertNotEqual(None, controller.get_circuit(circuit_id, None))
circuit_id = controller.new_circuit()
self.assertNotEqual(None, controller.get_circuit(circuit_id, None))
self.assertRaises(stem.InvalidRequest, controller.extend_circuit, 'foo')
self.assertRaises(stem.InvalidRequest, controller.extend_circuit, '0', 'thisroutershouldntexistbecausestemexists!@##$%#')
self.assertRaises(stem.InvalidRequest, controller.extend_circuit, '0', 'thisroutershouldntexistbecausestemexists!@##$%#', 'foo')
@test.require.controller
@test.require.online
@test.require.version(Requirement.EXTENDCIRCUIT_PATH_OPTIONAL)
def test_repurpose_circuit(self):
"""
Tests Controller.repurpose_circuit with valid and invalid input.
"""
runner = test.runner.get_runner()
with runner.get_tor_controller() as controller:
circ_id = controller.new_circuit()
controller.repurpose_circuit(circ_id, 'CONTROLLER')
circuit = controller.get_circuit(circ_id)
self.assertTrue(circuit.purpose == 'CONTROLLER')
controller.repurpose_circuit(circ_id, 'GENERAL')
circuit = controller.get_circuit(circ_id)
self.assertTrue(circuit.purpose == 'GENERAL')
self.assertRaises(stem.InvalidRequest, controller.repurpose_circuit, 'f934h9f3h4', 'fooo')
self.assertRaises(stem.InvalidRequest, controller.repurpose_circuit, '4', 'fooo')
@test.require.controller
@test.require.online
@test.require.version(Requirement.EXTENDCIRCUIT_PATH_OPTIONAL)
def test_close_circuit(self):
"""
Tests Controller.close_circuit with valid and invalid input.
"""
runner = test.runner.get_runner()
with runner.get_tor_controller() as controller:
circuit_id = controller.new_circuit()
controller.close_circuit(circuit_id)
circuit_output = controller.get_info('circuit-status')
circ = [x.split()[0] for x in circuit_output.splitlines()]
self.assertFalse(circuit_id in circ)
circuit_id = controller.new_circuit()
controller.close_circuit(circuit_id, 'IfUnused')
circuit_output = controller.get_info('circuit-status')
circ = [x.split()[0] for x in circuit_output.splitlines()]
self.assertFalse(circuit_id in circ)
circuit_id = controller.new_circuit()
self.assertRaises(stem.InvalidArguments, controller.close_circuit, circuit_id + '1024')
self.assertRaises(stem.InvalidRequest, controller.close_circuit, '')
@test.require.controller
@test.require.online
def test_get_streams(self):
"""
Tests Controller.get_streams().
"""
host = socket.gethostbyname('www.torproject.org')
port = 443
runner = test.runner.get_runner()
with runner.get_tor_controller() as controller:
# we only need one proxy port, so take the first
socks_listener = controller.get_socks_listeners()[0]
with test.network.Socks(socks_listener) as s:
s.settimeout(30)
s.connect((host, port))
streams = controller.get_streams()
# Because we do not get a stream id when opening a stream,
# try to match the target for which we asked a stream.
self.assertTrue('%s:%s' % (host, port) in [stream.target for stream in streams])
@test.require.controller
@test.require.online
def test_close_stream(self):
"""
Tests Controller.close_stream with valid and invalid input.
"""
runner = test.runner.get_runner()
with runner.get_tor_controller() as controller:
# use the first socks listener
socks_listener = controller.get_socks_listeners()[0]
with test.network.Socks(socks_listener) as s:
s.settimeout(30)
s.connect(('www.torproject.org', 443))
# There's only one stream right now. Right?
built_stream = controller.get_streams()[0]
# Make sure we have the stream for which we asked, otherwise
# the next assertion would be a false positive.
self.assertEqual([built_stream.id], [stream.id for stream in controller.get_streams()])
# Try to close our stream...
controller.close_stream(built_stream.id)
# ...which means there are zero streams.
self.assertEqual([], controller.get_streams())
# unknown stream
self.assertRaises(stem.InvalidArguments, controller.close_stream, 'blarg')
@test.require.controller
@test.require.online
def test_mapaddress(self):
runner = test.runner.get_runner()
with runner.get_tor_controller() as controller:
controller.map_address({'1.2.1.2': 'ifconfig.me'})
s = None
response = None
# try up to 10 times to rule out transient network failures
for _ in range(10):
try:
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.settimeout(30)
s.connect(('127.0.0.1', int(controller.get_conf('SocksPort'))))
test.network.negotiate_socks(s, '1.2.1.2', 80)
s.sendall(stem.util.str_tools._to_bytes(test.network.ip_request)) # make the http request for the ip address
response = s.recv(1000)
if response:
break
except (stem.ProtocolError, socket.timeout):
continue
finally:
if s:
s.close()
self.assertTrue(response)
# everything after the blank line is the 'data' in a HTTP response.
# The response data for our request for request should be an IP address + '\n'
ip_addr = response[response.find(b'\r\n\r\n'):].strip()
self.assertTrue(stem.util.connection.is_valid_ipv4_address(stem.util.str_tools._to_unicode(ip_addr)), "'%s' isn't an address" % ip_addr)
@test.require.controller
@test.require.online
@test.require.version(Requirement.MICRODESCRIPTOR_IS_DEFAULT)
def test_get_microdescriptor(self):
"""
Basic checks for get_microdescriptor().
"""
with test.runner.get_runner().get_tor_controller() as controller:
# we should balk at invalid content
self.assertRaises(ValueError, controller.get_microdescriptor, '')
self.assertRaises(ValueError, controller.get_microdescriptor, 5)
self.assertRaises(ValueError, controller.get_microdescriptor, 'z' * 30)
# try with a relay that doesn't exist
self.assertRaises(stem.ControllerError, controller.get_microdescriptor, 'blargg')
self.assertRaises(stem.ControllerError, controller.get_microdescriptor, '5' * 40)
test_relay = self._get_router_status_entry(controller)
md_by_fingerprint = controller.get_microdescriptor(test_relay.fingerprint)
md_by_nickname = controller.get_microdescriptor(test_relay.nickname)
self.assertEqual(md_by_fingerprint, md_by_nickname)
@test.require.controller
def test_get_microdescriptors(self):
"""
Fetches a few descriptors via the get_microdescriptors() method.
"""
runner = test.runner.get_runner()
if not os.path.exists(runner.get_test_dir('cached-descriptors')):
self.skipTest('(no cached microdescriptors)')
return
with runner.get_tor_controller() as controller:
count = 0
for desc in controller.get_microdescriptors():
self.assertTrue(desc.onion_key is not None)
count += 1
if count > 10:
break
@test.require.controller
def test_get_server_descriptor(self):
"""
Basic checks for get_server_descriptor().
"""
runner = test.runner.get_runner()
if test.tor_version() >= Requirement.MICRODESCRIPTOR_IS_DEFAULT:
self.skipTest('(requires server descriptors)')
return
with runner.get_tor_controller() as controller:
# we should balk at invalid content
self.assertRaises(ValueError, controller.get_server_descriptor, None)
self.assertRaises(ValueError, controller.get_server_descriptor, '')
self.assertRaises(ValueError, controller.get_server_descriptor, 5)
self.assertRaises(ValueError, controller.get_server_descriptor, 'z' * 30)
# try with a relay that doesn't exist
self.assertRaises(stem.ControllerError, controller.get_server_descriptor, 'blargg')
self.assertRaises(stem.ControllerError, controller.get_server_descriptor, '5' * 40)
test_relay = self._get_router_status_entry(controller)
desc_by_fingerprint = controller.get_server_descriptor(test_relay.fingerprint)
desc_by_nickname = controller.get_server_descriptor(test_relay.nickname)
self.assertEqual(desc_by_fingerprint, desc_by_nickname)
@test.require.controller
@test.require.online
def test_get_server_descriptors(self):
"""
Fetches a few descriptors via the get_server_descriptors() method.
"""
runner = test.runner.get_runner()
if test.tor_version() >= Requirement.MICRODESCRIPTOR_IS_DEFAULT:
self.skipTest('(requires server descriptors)')
return
with runner.get_tor_controller() as controller:
count = 0
for desc in controller.get_server_descriptors():
self.assertTrue(desc.fingerprint is not None)
self.assertTrue(desc.nickname is not None)
# Se don't want to take the time to read the whole thing. We already
# have another test that reads the full cached descriptors (and takes a
# while to do so).
count += 1
if count > 10:
break
@test.require.controller
@test.require.online
def test_get_network_status(self):
"""
Basic checks for get_network_status().
"""
with test.runner.get_runner().get_tor_controller() as controller:
# we should balk at invalid content
self.assertRaises(ValueError, controller.get_network_status, '')
self.assertRaises(ValueError, controller.get_network_status, 5)
self.assertRaises(ValueError, controller.get_network_status, 'z' * 30)
# try with a relay that doesn't exist
self.assertRaises(stem.ControllerError, controller.get_network_status, 'blargg')
self.assertRaises(stem.ControllerError, controller.get_network_status, '5' * 40)
test_relay = self._get_router_status_entry(controller)
desc_by_fingerprint = controller.get_network_status(test_relay.fingerprint)
desc_by_nickname = controller.get_network_status(test_relay.nickname)
self.assertEqual(desc_by_fingerprint, desc_by_nickname)
@test.require.controller
@test.require.online
def test_get_network_statuses(self):
"""
Fetches a few descriptors via the get_network_statuses() method.
"""
runner = test.runner.get_runner()
with runner.get_tor_controller() as controller:
count = 0
for desc in controller.get_network_statuses():
self.assertTrue(desc.fingerprint is not None)
self.assertTrue(desc.nickname is not None)
for line in desc.get_unrecognized_lines():
test.register_new_capability('Consensus Line', line)
count += 1
if count > 10:
break
@test.require.controller
@test.require.online
@test.require.version(Requirement.HSFETCH)
def test_get_hidden_service_descriptor(self):
"""
Fetches a few descriptors via the get_hidden_service_descriptor() method.
"""
runner = test.runner.get_runner()
with runner.get_tor_controller() as controller:
# fetch the descriptor for DuckDuckGo
desc = controller.get_hidden_service_descriptor('3g2upl4pq6kufc4m.onion')
self.assertTrue('MIGJAoGBAJ' in desc.permanent_key)
# try to fetch something that doesn't exist
exc_msg = 'No running hidden service at m4cfuk6qp4lpu2g3.onion'
self.assertRaisesRegexp(stem.DescriptorUnavailable, exc_msg, controller.get_hidden_service_descriptor, 'm4cfuk6qp4lpu2g3')
# ... but shouldn't fail if we have a default argument or aren't awaiting the descriptor
self.assertEqual('pop goes the weasel', controller.get_hidden_service_descriptor('m4cfuk6qp4lpu2g5', 'pop goes the weasel'))
self.assertEqual(None, controller.get_hidden_service_descriptor('m4cfuk6qp4lpu2g5', await_result = False))
@test.require.controller
@test.require.online
@test.require.version(Requirement.EXTENDCIRCUIT_PATH_OPTIONAL)
def test_attachstream(self):
host = socket.gethostbyname('www.torproject.org')
port = 80
circuit_id, streams = None, []
def handle_streamcreated(stream):
if stream.status == 'NEW' and circuit_id:
controller.attach_stream(stream.id, circuit_id)
with test.runner.get_runner().get_tor_controller() as controller:
# try 10 times to build a circuit we can connect through
for i in range(10):
controller.add_event_listener(handle_streamcreated, stem.control.EventType.STREAM)
controller.set_conf('__LeaveStreamsUnattached', '1')
try:
circuit_id = controller.new_circuit(await_build = True)
socks_listener = controller.get_socks_listeners()[0]
with test.network.Socks(socks_listener) as s:
s.settimeout(30)
s.connect((host, port))
streams = controller.get_streams()
break
except (stem.CircuitExtensionFailed, socket.timeout):
continue
finally:
controller.remove_event_listener(handle_streamcreated)
controller.reset_conf('__LeaveStreamsUnattached')
our_stream = [stream for stream in streams if stream.target_address == host][0]
self.assertTrue(our_stream.circ_id)
self.assertTrue(circuit_id)
self.assertEqual(our_stream.circ_id, circuit_id)
@test.require.controller
@test.require.online
@test.require.version(Requirement.EXTENDCIRCUIT_PATH_OPTIONAL)
def test_get_circuits(self):
"""
Fetches circuits via the get_circuits() method.
"""
with test.runner.get_runner().get_tor_controller() as controller:
new_circ = controller.new_circuit()
circuits = controller.get_circuits()
self.assertTrue(new_circ in [circ.id for circ in circuits])
@test.require.online
@test.require.controller
def test_transition_to_relay(self):
"""
Transitions Tor to turn into a relay, then back to a client. This helps to
catch transition issues such as the one cited in :trac:`14901`.
"""
with test.runner.get_runner().get_tor_controller() as controller:
self.assertEqual(None, controller.get_conf('OrPort'))
# DisableNetwork ensures no port is actually opened
controller.set_options({'OrPort': '9090', 'DisableNetwork': '1'})
# TODO once tor 0.2.7.x exists, test that we can generate a descriptor on demand.
self.assertEqual('9090', controller.get_conf('OrPort'))
controller.reset_conf('OrPort', 'DisableNetwork')
self.assertEqual(None, controller.get_conf('OrPort'))
def _get_router_status_entry(self, controller):
"""
Provides a router status entry for a relay with a nickname other than
'Unnamed'. This fails the test if unable to find one.
"""
global TEST_ROUTER_STATUS_ENTRY
if TEST_ROUTER_STATUS_ENTRY is None:
for desc in controller.get_network_statuses():
if desc.nickname != 'Unnamed' and Flag.NAMED in desc.flags:
TEST_ROUTER_STATUS_ENTRY = desc
break
if TEST_ROUTER_STATUS_ENTRY is None:
# this is only likely to occure if we can't get descriptors
self.skipTest('(no named relays)')
return
return TEST_ROUTER_STATUS_ENTRY
stem-1.6.0/test/integ/socket/ 0000775 0001750 0001750 00000000000 13177674754 016612 5 ustar atagar atagar 0000000 0000000 stem-1.6.0/test/integ/socket/__init__.py 0000664 0001750 0001750 00000000134 13115423200 020663 0 ustar atagar atagar 0000000 0000000 """
Integration tests for stem.socket.
"""
__all__ = ['control_message', 'control_socket']
stem-1.6.0/test/integ/socket/control_socket.py 0000664 0001750 0001750 00000012360 13124757510 022176 0 ustar atagar atagar 0000000 0000000 """
Integration tests for the stem.socket.ControlSocket subclasses. When ran these
test basic functionality for a ControlPort *or* ControlSocketFile, depending on
which can connect to our tor instance.
These tests share a similar domain with those for the ControlMessage, but where
those focus on parsing and correctness of the content these are more concerned
with the behavior of the socket itself.
"""
import time
import unittest
import stem.connection
import stem.control
import stem.socket
import test
import test.require
import test.runner
class TestControlSocket(unittest.TestCase):
@test.require.controller
def test_connection_time(self):
"""
Checks that our connection_time method tracks when our state's changed.
"""
test_start = time.time()
runner = test.runner.get_runner()
with runner.get_tor_socket() as control_socket:
connection_time = control_socket.connection_time()
# connection time should be between our tests start and now
self.assertTrue(test_start <= connection_time <= time.time())
# connection time should be absolute (shouldn't change as time goes on)
time.sleep(0.001)
self.assertEqual(connection_time, control_socket.connection_time())
# should change to the disconnection time if we detactch
control_socket.close()
disconnection_time = control_socket.connection_time()
self.assertTrue(connection_time < disconnection_time <= time.time())
# then change again if we reconnect
time.sleep(0.001)
control_socket.connect()
reconnection_time = control_socket.connection_time()
self.assertTrue(disconnection_time < reconnection_time <= time.time())
@test.require.controller
def test_send_buffered(self):
"""
Sends multiple requests before receiving back any of the replies.
"""
runner = test.runner.get_runner()
with runner.get_tor_socket() as control_socket:
for _ in range(100):
control_socket.send('GETINFO version')
for _ in range(100):
response = control_socket.recv()
self.assertTrue(str(response).startswith('version=%s' % test.tor_version()))
self.assertTrue(str(response).endswith('\nOK'))
@test.require.controller
def test_send_closed(self):
"""
Sends a message after we've closed the connection.
"""
with test.runner.get_runner().get_tor_socket() as control_socket:
self.assertTrue(control_socket.is_alive())
control_socket.close()
self.assertFalse(control_socket.is_alive())
self.assertRaises(stem.SocketClosed, control_socket.send, 'blarg')
@test.require.controller
def test_send_disconnected(self):
"""
Sends a message to a socket that has been disconnected by the other end.
Our behavior upon disconnection slightly differs based on if we're a port
or socket file based connection. With a control port we won't notice the
disconnect (is_alive() will return True) until we've made a failed recv()
call. With a file socket, however, we'll also fail when calling send().
"""
with test.runner.get_runner().get_tor_socket() as control_socket:
control_socket.send('QUIT')
self.assertEqual('closing connection', str(control_socket.recv()))
self.assertTrue(control_socket.is_alive())
# If we send another message to a port based socket then it will seem to
# succeed. However, a file based socket should report a failure.
if isinstance(control_socket, stem.socket.ControlPort):
control_socket.send('blarg')
self.assertTrue(control_socket.is_alive())
else:
self.assertRaises(stem.SocketClosed, control_socket.send, 'blarg')
self.assertFalse(control_socket.is_alive())
@test.require.controller
def test_recv_closed(self):
"""
Receives a message after we've closed the connection.
"""
with test.runner.get_runner().get_tor_socket() as control_socket:
self.assertTrue(control_socket.is_alive())
control_socket.close()
self.assertFalse(control_socket.is_alive())
self.assertRaises(stem.SocketClosed, control_socket.recv)
@test.require.controller
def test_recv_disconnected(self):
"""
Receives a message from a socket that has been disconnected by the other
end.
"""
with test.runner.get_runner().get_tor_socket() as control_socket:
control_socket.send('QUIT')
self.assertEqual('closing connection', str(control_socket.recv()))
# Neither a port or file based socket will know that tor has hung up on
# the connection at this point. We should know after calling recv(),
# however.
self.assertTrue(control_socket.is_alive())
self.assertRaises(stem.SocketClosed, control_socket.recv)
self.assertFalse(control_socket.is_alive())
@test.require.controller
def test_connect_repeatedly(self):
"""
Checks that we can reconnect, use, and disconnect a socket repeatedly.
"""
with test.runner.get_runner().get_tor_socket(False) as control_socket:
for _ in range(10):
# this will raise if the PROTOCOLINFO query fails
stem.connection.get_protocolinfo(control_socket)
control_socket.close()
self.assertRaises(stem.SocketClosed, control_socket.send, 'PROTOCOLINFO 1')
control_socket.connect()
stem-1.6.0/test/integ/socket/control_message.py 0000664 0001750 0001750 00000016252 13124757510 022336 0 ustar atagar atagar 0000000 0000000 """
Integration tests for the stem.response.ControlMessage class.
"""
import re
import unittest
import stem.socket
import stem.version
import test.require
import test.runner
class TestControlMessage(unittest.TestCase):
@test.require.controller
def test_unestablished_socket(self):
"""
Checks message parsing when we have a valid but unauthenticated socket.
"""
# If an unauthenticated connection gets a message besides AUTHENTICATE or
# PROTOCOLINFO then tor will give an 'Authentication required.' message and
# hang up.
control_socket = test.runner.get_runner().get_tor_socket(False)
control_socket.send('GETINFO version')
auth_required_response = control_socket.recv()
self.assertEqual('Authentication required.', str(auth_required_response))
self.assertEqual(['Authentication required.'], list(auth_required_response))
self.assertEqual('514 Authentication required.\r\n', auth_required_response.raw_content())
self.assertEqual([('514', ' ', 'Authentication required.')], auth_required_response.content())
# The socket's broken but doesn't realize it yet. These use cases are
# checked in more depth by the ControlSocket integ tests.
self.assertTrue(control_socket.is_alive())
self.assertRaises(stem.SocketClosed, control_socket.recv)
self.assertFalse(control_socket.is_alive())
# Additional socket usage should fail, and pulling more responses will fail
# with more closed exceptions.
self.assertRaises(stem.SocketError, control_socket.send, 'GETINFO version')
self.assertRaises(stem.SocketClosed, control_socket.recv)
self.assertRaises(stem.SocketClosed, control_socket.recv)
self.assertRaises(stem.SocketClosed, control_socket.recv)
# The socket connection is already broken so calling close shouldn't have
# an impact.
control_socket.close()
self.assertRaises(stem.SocketClosed, control_socket.send, 'GETINFO version')
self.assertRaises(stem.SocketClosed, control_socket.recv)
@test.require.controller
def test_invalid_command(self):
"""
Parses the response for a command which doesn't exist.
"""
with test.runner.get_runner().get_tor_socket() as control_socket:
control_socket.send('blarg')
unrecognized_command_response = control_socket.recv()
self.assertEqual('Unrecognized command "blarg"', str(unrecognized_command_response))
self.assertEqual(['Unrecognized command "blarg"'], list(unrecognized_command_response))
self.assertEqual('510 Unrecognized command "blarg"\r\n', unrecognized_command_response.raw_content())
self.assertEqual([('510', ' ', 'Unrecognized command "blarg"')], unrecognized_command_response.content())
@test.require.controller
def test_invalid_getinfo(self):
"""
Parses the response for a GETINFO query which doesn't exist.
"""
with test.runner.get_runner().get_tor_socket() as control_socket:
control_socket.send('GETINFO blarg')
unrecognized_key_response = control_socket.recv()
self.assertEqual('Unrecognized key "blarg"', str(unrecognized_key_response))
self.assertEqual(['Unrecognized key "blarg"'], list(unrecognized_key_response))
self.assertEqual('552 Unrecognized key "blarg"\r\n', unrecognized_key_response.raw_content())
self.assertEqual([('552', ' ', 'Unrecognized key "blarg"')], unrecognized_key_response.content())
@test.require.controller
def test_getinfo_config_file(self):
"""
Parses the 'GETINFO config-file' response.
"""
runner = test.runner.get_runner()
torrc_dst = runner.get_torrc_path()
with runner.get_tor_socket() as control_socket:
control_socket.send('GETINFO config-file')
config_file_response = control_socket.recv()
self.assertEqual('config-file=%s\nOK' % torrc_dst, str(config_file_response))
self.assertEqual(['config-file=%s' % torrc_dst, 'OK'], list(config_file_response))
self.assertEqual('250-config-file=%s\r\n250 OK\r\n' % torrc_dst, config_file_response.raw_content())
self.assertEqual([('250', '-', 'config-file=%s' % torrc_dst), ('250', ' ', 'OK')], config_file_response.content())
@test.require.controller
@test.require.version(stem.version.Requirement.GETINFO_CONFIG_TEXT)
def test_getinfo_config_text(self):
"""
Parses the 'GETINFO config-text' response.
"""
runner = test.runner.get_runner()
# We can't be certain of the order, and there may be extra config-text
# entries as per...
# https://trac.torproject.org/projects/tor/ticket/2362
#
# so we'll just check that the response is a superset of our config
torrc_contents = []
for line in runner.get_torrc_contents().splitlines():
line = line.strip()
if line and not line.startswith('#'):
torrc_contents.append(line)
with runner.get_tor_socket() as control_socket:
control_socket.send('GETINFO config-text')
config_text_response = control_socket.recv()
# the response should contain two entries, the first being a data response
self.assertEqual(2, len(list(config_text_response)))
self.assertEqual('OK', list(config_text_response)[1])
self.assertEqual(('250', ' ', 'OK'), config_text_response.content()[1])
self.assertTrue(config_text_response.raw_content().startswith('250+config-text=\r\n'))
self.assertTrue(config_text_response.raw_content().endswith('\r\n.\r\n250 OK\r\n'))
self.assertTrue(str(config_text_response).startswith('config-text=\n'))
self.assertTrue(str(config_text_response).endswith('\nOK'))
for torrc_entry in torrc_contents:
self.assertTrue('\n%s\n' % torrc_entry in str(config_text_response))
self.assertTrue(torrc_entry in list(config_text_response)[0])
self.assertTrue('%s\r\n' % torrc_entry in config_text_response.raw_content())
self.assertTrue('%s' % torrc_entry in config_text_response.content()[0][2])
@test.require.controller
def test_setconf_event(self):
"""
Issues 'SETEVENTS CONF_CHANGED' and parses an events.
"""
with test.runner.get_runner().get_tor_socket() as control_socket:
control_socket.send('SETEVENTS CONF_CHANGED')
setevents_response = control_socket.recv()
self.assertEqual('OK', str(setevents_response))
self.assertEqual(['OK'], list(setevents_response))
self.assertEqual('250 OK\r\n', setevents_response.raw_content())
self.assertEqual([('250', ' ', 'OK')], setevents_response.content())
# We'll receive both a CONF_CHANGED event and 'OK' response for the
# SETCONF, but not necessarily in any specific order.
control_socket.send('SETCONF NodeFamily=FD4CC275C5AA4D27A487C6CA29097900F85E2C33')
msg1 = control_socket.recv()
msg2 = control_socket.recv()
if msg1.content()[0][0] == '650':
conf_changed_event, setconf_response = msg1, msg2
else:
setconf_response, conf_changed_event = msg1, msg2
self.assertTrue(re.match('CONF_CHANGED\nNodeFamily=.*', str(conf_changed_event)))
self.assertTrue(re.match('650-CONF_CHANGED\r\n650-NodeFamily=.*\r\n650 OK', conf_changed_event.raw_content()))
self.assertEqual(('650', '-'), conf_changed_event.content()[0][:2])
self.assertEqual([('250', ' ', 'OK')], setconf_response.content())
stem-1.6.0/test/integ/interpreter.py 0000664 0001750 0001750 00000003170 13124757510 020220 0 ustar atagar atagar 0000000 0000000 """
Tests invocation of our interpreter.
"""
import os
import tempfile
import unittest
import stem.util.system
import test
import test.require
import test.runner
PROMPT_CMD = os.path.join(test.STEM_BASE, 'tor-prompt')
def _run_prompt(*args):
if test.runner.Torrc.SOCKET not in test.runner.get_runner().get_options():
return stem.util.system.call([PROMPT_CMD, '--interface', test.runner.CONTROL_PORT] + list(args))
else:
return stem.util.system.call([PROMPT_CMD, '--socket', test.runner.CONTROL_SOCKET_PATH] + list(args))
class TestInterpreter(unittest.TestCase):
@test.require.controller
def test_running_command(self):
# We'd need to provide the password to stdin. Fine test to add later but
# not gonna hassle for now.
if test.runner.Torrc.PASSWORD in test.runner.get_runner().get_options():
self.skipTest('password auth unsupported')
return
expected = ['250-config-file=%s' % test.runner.get_runner().get_torrc_path(), '250 OK']
self.assertEqual(expected, _run_prompt('--run', 'GETINFO config-file'))
@test.require.controller
def test_running_file(self):
if test.runner.Torrc.PASSWORD in test.runner.get_runner().get_options():
self.skipTest('password auth unsupported')
return
expected = [
'250-config-file=%s' % test.runner.get_runner().get_torrc_path(),
'250 OK',
'',
'250-version=%s' % test.tor_version(),
'250 OK',
]
with tempfile.NamedTemporaryFile(prefix = 'test_commands.') as tmp:
tmp.write(b'GETINFO config-file\nGETINFO version')
tmp.flush()
self.assertEqual(expected, _run_prompt('--run', tmp.name))
stem-1.6.0/test/arguments.py 0000664 0001750 0001750 00000010045 13124757510 016553 0 ustar atagar atagar 0000000 0000000 # Copyright 2015-2017, Damian Johnson and The Tor Project
# See LICENSE for licensing information
"""
Commandline argument parsing for our test runner.
"""
import collections
import getopt
import stem.util.conf
import stem.util.log
import test
LOG_TYPE_ERROR = """\
'%s' isn't a logging runlevel, use one of the following instead:
TRACE, DEBUG, INFO, NOTICE, WARN, ERROR
"""
CONFIG = stem.util.conf.config_dict('test', {
'msg.help': '',
'target.description': {},
'target.torrc': {},
})
DEFAULT_ARGS = {
'run_unit': False,
'run_integ': False,
'specific_test': None,
'logging_runlevel': None,
'tor_path': 'tor',
'run_targets': [test.Target.RUN_OPEN],
'attribute_targets': [],
'quiet': False,
'verbose': False,
'print_help': False,
}
OPT = 'auit:l:qvh'
OPT_EXPANDED = ['all', 'unit', 'integ', 'targets=', 'test=', 'log=', 'tor=', 'quiet', 'verbose', 'help']
def parse(argv):
"""
Parses our arguments, providing a named tuple with their values.
:param list argv: input arguments to be parsed
:returns: a **named tuple** with our parsed arguments
:raises: **ValueError** if we got an invalid argument
"""
args = dict(DEFAULT_ARGS)
try:
recognized_args, unrecognized_args = getopt.getopt(argv, OPT, OPT_EXPANDED)
if unrecognized_args:
error_msg = "aren't recognized arguments" if len(unrecognized_args) > 1 else "isn't a recognized argument"
raise getopt.GetoptError("'%s' %s" % ("', '".join(unrecognized_args), error_msg))
except Exception as exc:
raise ValueError('%s (for usage provide --help)' % exc)
for opt, arg in recognized_args:
if opt in ('-a', '--all'):
args['run_unit'] = True
args['run_integ'] = True
elif opt in ('-u', '--unit'):
args['run_unit'] = True
elif opt in ('-i', '--integ'):
args['run_integ'] = True
elif opt in ('-t', '--targets'):
run_targets, attribute_targets = [], []
integ_targets = arg.split(',')
all_run_targets = [t for t in test.Target if CONFIG['target.torrc'].get(t) is not None]
# validates the targets and split them into run and attribute targets
if not integ_targets:
raise ValueError('No targets provided')
for target in integ_targets:
if target not in test.Target:
raise ValueError('Invalid integration target: %s' % target)
elif target in all_run_targets:
run_targets.append(target)
else:
attribute_targets.append(target)
# check if we were told to use all run targets
if test.Target.RUN_ALL in attribute_targets:
attribute_targets.remove(test.Target.RUN_ALL)
run_targets = all_run_targets
# if no RUN_* targets are provided then keep the default (otherwise we
# won't have any tests to run)
if run_targets:
args['run_targets'] = run_targets
args['attribute_targets'] = attribute_targets
elif opt == '--test':
args['specific_test'] = arg
elif opt in ('-l', '--log'):
arg = arg.upper()
if arg not in stem.util.log.LOG_VALUES:
raise ValueError(LOG_TYPE_ERROR % arg)
args['logging_runlevel'] = arg
elif opt in ('--tor'):
args['tor_path'] = arg
elif opt in ('-q', '--quiet'):
args['quiet'] = True
elif opt in ('-v', '--verbose'):
args['verbose'] = True
elif opt in ('-h', '--help'):
args['print_help'] = True
# translates our args dict into a named tuple
Args = collections.namedtuple('Args', args.keys())
return Args(**args)
def get_help():
"""
Provides usage information, as provided by the '--help' argument. This
includes a listing of the valid integration targets.
:returns: **str** with our usage information
"""
help_msg = CONFIG['msg.help']
# gets the longest target length so we can show the entries in columns
target_name_length = max(map(len, test.Target))
description_format = '\n %%-%is - %%s' % target_name_length
for target in test.Target:
help_msg += description_format % (target, CONFIG['target.description'].get(target, ''))
help_msg += '\n'
return help_msg
stem-1.6.0/docs/ 0000775 0001750 0001750 00000000000 13177674754 014165 5 ustar atagar atagar 0000000 0000000 stem-1.6.0/docs/index.rst 0000664 0001750 0001750 00000004661 13177673130 016020 0 ustar atagar atagar 0000000 0000000 Welcome to Stem!
================
Stem is a Python controller library for `Tor `_. With it you can use Tor's `control protocol `_ to script against the Tor process, or build things such as `arm `_. Stem's latest version is **1.6.0** (released November 5th, 2017).
.. Main Stem Logo
Source: http://www.wpclipart.com/plants/assorted/P/plant_stem.png.html
Author: Jakub Jankiewicz
License: Public Domain (http://www.wpclipart.com/legal.html#terms)
Alternate:
Source: http://andreajoseph24.blogspot.com/search/label/onions
Author: Andrea Joseph
License: CCv3 (NC, ND) - http://creativecommons.org/licenses/by-nc-nd/3.0/
.. Source: NuoveXT 2 (http://nuovext.pwsp.net/)
Author: Alexandre Moore (http://sa-ki.deviantart.com/)
License: LGPL v3
File: NuoveXT 2.2/128x128/categories/applications-development.png
.. image:: /_static/buttons/tutorials.png
:target: tutorials.html
.. Source: http://www.cipherdyne.com/images/anvil.png
Author and license are unknown
.. image:: /_static/buttons/api.png
:target: api.html
.. Source: https://openclipart.org/detail/171951/help-by-diamonjohn-171951
Author: John Diamond (https://openclipart.org/user-detail/diamonjohn)
License: Public Domain
Alternate:
Source: Oxygen (http://www.oxygen-icons.org/)
Author: Andrea Joseph
License: CCv3 (A, SA) - http://creativecommons.org/licenses/by-sa/3.0/
File: Oxygen/128x128/categories/system-help.png
.. image:: /_static/buttons/faq.png
:target: faq.html
.. Source: Nuovo (http://www.silvestre.com.ar/?p=5)
Author: Silvestre Herrera (http://www.silvestre.com.ar/)
License: GPL v2
File: Nuovo/128x128/mimetypes/gnome-mime-text-log.png
.. image:: /_static/buttons/change_log.png
:target: change_log.html
.. Source: Crystal (http://www.everaldo.com/crystal/)
Author: Everaldo Coelho (http://www.everaldo.com/)
License: LGPL v2
File: Crystal/64x64/apps/bug.png
.. image:: /_static/buttons/bug_tracker.png
:target: https://trac.torproject.org/projects/tor/wiki/doc/stem/bugs
.. Source: ColorCons (http://mouserunner.com/Spheres_ColoCons1_Free_Icons.html)
Author: Ken Saunders (http://mouserunner.com/MRDS_Cell.html)
License: CC v2.5 (A, SA)
File: ColorCons/Blue/Download.png
.. image:: /_static/buttons/download.png
:target: download.html
.. toctree::
:maxdepth: 1
stem-1.6.0/docs/api.rst 0000664 0001750 0001750 00000006451 13124757507 015464 0 ustar atagar atagar 0000000 0000000 API
===
Controller
----------
* **Core**
* `stem.control `_ - **Controller used to talk with Tor**.
* `stem.connection `_ - Connection and authentication to the Tor control socket.
* `stem.socket `_ - Low level control socket used to talk with Tor.
* `stem.process `_ - Launcher for the Tor process.
* `stem.response `_ - Messages that Tor may provide the controller.
* **Types**
* `stem.exit_policy `_ - Relay policy for the destinations it will or won't allow traffic to.
* `stem.manual `_ - Information available about Tor from `its manual `_.
* `stem.version `_ - Tor versions that can be compared to determine Tor's capabilities.
Descriptors
-----------
To read descriptors from disk use :func:`~stem.descriptor.__init__.parse_file` for
individual files and `stem.descriptor.reader
`_ for batches. You can also use
`stem.descriptor.remote `_ to download descriptors
remotely like Tor does.
* **Classes**
* `stem.descriptor `_ - Base class for descriptors.
* `stem.descriptor.server_descriptor `_ - Relay and bridge server descriptors.
* `stem.descriptor.extrainfo_descriptor `_ - Relay and bridge extrainfo descriptors.
* `stem.descriptor.microdescriptor `_ - Minimalistic counterpart for server descriptors.
* `stem.descriptor.networkstatus `_ - Network status documents which make up the Tor consensus.
* `stem.descriptor.router_status_entry `_ - Relay entries within a network status document.
* `stem.descriptor.hidden_service_descriptor `_ - Descriptors generated for hidden services.
* `stem.descriptor.tordnsel `_ - `TorDNSEL `_ exit lists.
* `stem.descriptor.certificate `_ - `Ed25519 certificates `_.
* `stem.descriptor.reader `_ - Reads and parses descriptor files from disk.
* `stem.descriptor.remote `_ - Downloads descriptors from directory mirrors and authorities.
* `stem.descriptor.export `_ - Exports descriptors to other formats.
Utilities
---------
* `stem.util.conf `_ - Configuration file handling.
* `stem.util.connection `_ - Connection and IP related utilities.
* `stem.util.enum `_ - Enumeration class.
* `stem.util.str_tools `_ - String utilities.
* `stem.util.system `_ - Tools related to the local system.
* `stem.util.term `_ - Tools for interacting with the terminal.
* `stem.util.test_tools `_ - Static analysis checks and tools to help with test runs.
* `stem.util.tor_tools `_ - Miscellaneous toolkit for working with tor.
stem-1.6.0/docs/conf.py 0000664 0001750 0001750 00000017173 13115423200 015437 0 ustar atagar atagar 0000000 0000000 # -*- coding: utf-8 -*-
#
# Stem documentation build configuration file, created by
# sphinx-quickstart on Thu May 31 09:56:13 2012.
#
# This file is execfile()d with the current directory set to its containing dir.
#
# Note that not all possible configuration values are present in this
# autogenerated file.
#
# All configuration values have a default; values that are commented out
# serve to show the default.
import sys, os
# If extensions (or modules to document with autodoc) are in another directory,
# add these directories to sys.path here. If the directory is relative to the
# documentation root, use os.path.abspath to make it absolute, like shown here.
sys.path.insert(0, os.path.abspath('..'))
sys.path.append(os.path.abspath('.'))
# -- General configuration -----------------------------------------------------
# If your documentation needs a minimal Sphinx version, state it here.
needs_sphinx = '1.1' # required for the sphinx-apidoc command
# Add any Sphinx extension module names here, as strings. They can be extensions
# coming with Sphinx (named 'sphinx.ext.*') or your custom ones.
extensions = ['sphinx.ext.autodoc', 'sphinx.ext.viewcode', 'roles']
autodoc_member_order = 'bysource'
autodoc_default_flags = ['members', 'show-inheritance', 'undoc-members']
# Add any paths that contain templates here, relative to this directory.
templates_path = ['_templates']
# The suffix of source filenames.
source_suffix = '.rst'
# The encoding of source files.
#source_encoding = 'utf-8-sig'
# The master toctree document.
master_doc = 'index'
from stem import __version__, __author__, __contact__
# Ignore the '-dev' version suffix.
if __version__.endswith('-dev'):
__version__ = __version__[:-4]
# General information about the project.
project = 'Stem'
copyright = '2012, %s' % __author__
# The version info for the project you're documenting, acts as replacement for
# |version| and |release|, also used in various other places throughout the
# built documents.
#
# The short X.Y version.
version = __version__[:__version__.rfind(".")]
# The full version, including alpha/beta/rc tags.
release = __version__
# The language for content autogenerated by Sphinx. Refer to documentation
# for a list of supported languages.
#language = None
# There are two options for replacing |today|: either, you set today to some
# non-false value, then it is used:
#today = ''
# Else, today_fmt is used as the format for a strftime call.
#today_fmt = '%B %d, %Y'
# List of patterns, relative to source directory, that match files and
# directories to ignore when looking for source files.
exclude_patterns = ['_build']
# The reST default role (used for this markup: `text`) to use for all documents.
#default_role = None
# If true, '()' will be appended to :func: etc. cross-reference text.
#add_function_parentheses = True
# If true, the current module name will be prepended to all description
# unit titles (such as .. function::).
#add_module_names = True
# If true, sectionauthor and moduleauthor directives will be shown in the
# output. They are ignored by default.
#show_authors = False
# The name of the Pygments (syntax highlighting) style to use.
pygments_style = 'sphinx'
# A list of ignored prefixes for module index sorting.
#modindex_common_prefix = []
# -- Options for HTML output ---------------------------------------------------
# The theme to use for HTML and HTML Help pages. See the documentation for
# a list of builtin themes.
#html_theme = 'default'
html_theme = 'haiku'
# Theme options are theme-specific and customize the look and feel of a theme
# further. For a list of options available for each theme, see the
# documentation.
#html_theme_options = {}
# Add any paths that contain custom themes here, relative to this directory.
#html_theme_path = []
# The name for this set of Sphinx documents. If None, it defaults to
# " v documentation".
#html_title = None
# A shorter title for the navigation bar. Default is the same as html_title.
html_short_title = 'Stem Docs'
# The name of an image file (relative to this directory) to place at the top
# of the sidebar.
html_logo = 'logo.png'
# The name of an image file (within the static path) to use as favicon of the
# docs. This file should be a Windows icon file (.ico) being 16x16 or 32x32
# pixels large.
html_favicon = 'favicon.png'
# Add any paths that contain custom static files (such as style sheets) here,
# relative to this directory. They are copied after the builtin static files,
# so a file named "default.css" will overwrite the builtin "default.css".
html_static_path = ['_static']
# If not '', a 'Last updated on:' timestamp is inserted at every page bottom,
# using the given strftime format.
#html_last_updated_fmt = '%b %d, %Y'
# If true, SmartyPants will be used to convert quotes and dashes to
# typographically correct entities.
html_use_smartypants = False
# Custom sidebar templates, maps document names to template names.
#html_sidebars = {}
# Additional templates that should be rendered to pages, maps page names to
# template names.
#html_additional_pages = {}
# If false, no module index is generated.
#html_domain_indices = True
# If false, no index is generated.
#html_use_index = True
# If true, the index is split into individual pages for each letter.
#html_split_index = False
# If true, links to the reST sources are added to the pages.
html_show_sourcelink = False
# If true, "Created using Sphinx" is shown in the HTML footer. Default is True.
html_show_sphinx = False
# If true, "(C) Copyright ..." is shown in the HTML footer. Default is True.
html_show_copyright = False
# If true, an OpenSearch description file will be output, and all pages will
# contain a tag referring to it. The value of this option must be the
# base URL from which the finished HTML is served.
#html_use_opensearch = ''
# This is the file name suffix for HTML files (e.g. ".xhtml").
#html_file_suffix = None
# Output file base name for HTML help builder.
htmlhelp_basename = 'Stemdoc'
# -- Options for LaTeX output --------------------------------------------------
# The paper size ('letter' or 'a4').
#latex_paper_size = 'letter'
# The font size ('10pt', '11pt' or '12pt').
#latex_font_size = '10pt'
# Grouping the document tree into LaTeX files. List of tuples
# (source start file, target name, title, author, documentclass [howto/manual]).
latex_documents = [
('index', 'Stem.tex', 'Stem Documentation',
'Damian Johnson', 'manual'),
]
# The name of an image file (relative to this directory) to place at the top of
# the title page.
#latex_logo = None
# For "manual" documents, if this is true, then toplevel headings are parts,
# not chapters.
#latex_use_parts = False
# If true, show page references after internal links.
#latex_show_pagerefs = False
# If true, show URL addresses after external links.
#latex_show_urls = False
# Additional stuff for the LaTeX preamble.
#latex_preamble = ''
# Documents to append as an appendix to all manuals.
#latex_appendices = []
# If false, no module index is generated.
#latex_domain_indices = True
# -- Options for manual page output --------------------------------------------
# One entry per manual page. List of tuples
# (source start file, name, description, authors, manual section).
man_pages = [
('index', 'stem', 'Stem Documentation',
['%s (%s)' % (__author__, __contact__)], 1)
]
trac_url = 'https://trac.torproject.org/{slug}'
spec_url = 'https://gitweb.torproject.org/torspec.git/commit/?id={slug}'
def skip_members(app, what, name, obj, skip, options):
if name in ('ATTRIBUTES', 'PARSER_FOR_LINE'):
return True # skip the descriptor's parser constants
def setup(app):
app.connect('autodoc-skip-member', skip_members)
stem-1.6.0/docs/api/ 0000775 0001750 0001750 00000000000 13177674754 014736 5 ustar atagar atagar 0000000 0000000 stem-1.6.0/docs/api/socket.rst 0000664 0001750 0001750 00000000074 13115423200 016723 0 ustar atagar atagar 0000000 0000000 Control Socket
==============
.. automodule:: stem.socket
stem-1.6.0/docs/api/response.rst 0000664 0001750 0001750 00000000762 13115423200 017275 0 ustar atagar atagar 0000000 0000000 Controller Responses
====================
.. automodule:: stem.response
Responses
---------
.. autoclass:: stem.response.add_onion.AddOnionResponse
.. autoclass:: stem.response.authchallenge.AuthChallengeResponse
.. autoclass:: stem.response.getconf.GetConfResponse
.. autoclass:: stem.response.getinfo.GetInfoResponse
.. autoclass:: stem.response.mapaddress.MapAddressResponse
.. autoclass:: stem.response.protocolinfo.ProtocolInfoResponse
Events
------
.. automodule:: stem.response.events
stem-1.6.0/docs/api/control.rst 0000664 0001750 0001750 00000000212 13115423200 017105 0 ustar atagar atagar 0000000 0000000 Controller
==========
.. automodule:: stem.control
Exceptions and Attribute Enums
------------------------------
.. automodule:: stem
stem-1.6.0/docs/api/exit_policy.rst 0000664 0001750 0001750 00000000073 13115423200 017762 0 ustar atagar atagar 0000000 0000000 Exit Policy
===========
.. automodule:: stem.exit_policy
stem-1.6.0/docs/api/descriptor/ 0000775 0001750 0001750 00000000000 13177674754 017114 5 ustar atagar atagar 0000000 0000000 stem-1.6.0/docs/api/descriptor/certificate.rst 0000664 0001750 0001750 00000000106 13124757507 022113 0 ustar atagar atagar 0000000 0000000 Certificate
===========
.. automodule:: stem.descriptor.certificate
stem-1.6.0/docs/api/descriptor/descriptor.rst 0000664 0001750 0001750 00000000101 13115423200 021756 0 ustar atagar atagar 0000000 0000000 Descriptor
==========
.. automodule:: stem.descriptor.__init__
stem-1.6.0/docs/api/descriptor/tordnsel.rst 0000664 0001750 0001750 00000000123 13115423200 021436 0 ustar atagar atagar 0000000 0000000 TorDNSEL Exit Lists
===================
.. automodule:: stem.descriptor.tordnsel
stem-1.6.0/docs/api/descriptor/server_descriptor.rst 0000664 0001750 0001750 00000000130 13115423200 023346 0 ustar atagar atagar 0000000 0000000 Server Descriptor
=================
.. automodule:: stem.descriptor.server_descriptor
stem-1.6.0/docs/api/descriptor/extrainfo_descriptor.rst 0000664 0001750 0001750 00000000141 13115423200 024041 0 ustar atagar atagar 0000000 0000000 Extrainfo Descriptor
====================
.. automodule:: stem.descriptor.extrainfo_descriptor
stem-1.6.0/docs/api/descriptor/hidden_service_descriptor.rst 0000664 0001750 0001750 00000000160 13115423200 025016 0 ustar atagar atagar 0000000 0000000 Hidden Service Descriptor
=========================
.. automodule:: stem.descriptor.hidden_service_descriptor
stem-1.6.0/docs/api/descriptor/microdescriptor.rst 0000664 0001750 0001750 00000000122 13115423200 023013 0 ustar atagar atagar 0000000 0000000 MicroDescriptor
===============
.. automodule:: stem.descriptor.microdescriptor
stem-1.6.0/docs/api/descriptor/networkstatus.rst 0000664 0001750 0001750 00000000142 13115423200 022542 0 ustar atagar atagar 0000000 0000000 Network Status Documents
========================
.. automodule:: stem.descriptor.networkstatus
stem-1.6.0/docs/api/descriptor/router_status_entry.rst 0000664 0001750 0001750 00000000142 13115423200 023751 0 ustar atagar atagar 0000000 0000000 Router Status Entries
=====================
.. automodule:: stem.descriptor.router_status_entry
stem-1.6.0/docs/api/descriptor/reader.rst 0000664 0001750 0001750 00000000115 13115423200 021047 0 ustar atagar atagar 0000000 0000000 Descriptor Reader
=================
.. automodule:: stem.descriptor.reader
stem-1.6.0/docs/api/descriptor/export.rst 0000664 0001750 0001750 00000000121 13115423200 021123 0 ustar atagar atagar 0000000 0000000 Descriptor Exporter
===================
.. automodule:: stem.descriptor.export
stem-1.6.0/docs/api/descriptor/remote.rst 0000664 0001750 0001750 00000000115 13115423200 021100 0 ustar atagar atagar 0000000 0000000 Descriptor Remote
=================
.. automodule:: stem.descriptor.remote
stem-1.6.0/docs/api/connection.rst 0000664 0001750 0001750 00000000116 13115423200 017567 0 ustar atagar atagar 0000000 0000000 Controller Connection
=====================
.. automodule:: stem.connection
stem-1.6.0/docs/api/process.rst 0000664 0001750 0001750 00000000067 13115423200 017113 0 ustar atagar atagar 0000000 0000000 Tor Process
===========
.. automodule:: stem.process
stem-1.6.0/docs/api/util/ 0000775 0001750 0001750 00000000000 13177674754 015713 5 ustar atagar atagar 0000000 0000000 stem-1.6.0/docs/api/util/enum.rst 0000664 0001750 0001750 00000000073 13115423200 017353 0 ustar atagar atagar 0000000 0000000 Enumerations
============
.. automodule:: stem.util.enum
stem-1.6.0/docs/api/util/tor_tools.rst 0000664 0001750 0001750 00000000102 13115423200 020424 0 ustar atagar atagar 0000000 0000000 Tor Utilities
=============
.. automodule:: stem.util.tor_tools
stem-1.6.0/docs/api/util/proc.rst 0000664 0001750 0001750 00000000077 13115423200 017356 0 ustar atagar atagar 0000000 0000000 Proc Utilities
==============
.. automodule:: stem.util.proc
stem-1.6.0/docs/api/util/conf.rst 0000664 0001750 0001750 00000000131 13115423200 017327 0 ustar atagar atagar 0000000 0000000 Configuration File Handling
===========================
.. automodule:: stem.util.conf
stem-1.6.0/docs/api/util/str_tools.rst 0000664 0001750 0001750 00000000110 13115423200 020427 0 ustar atagar atagar 0000000 0000000 String Utilities
================
.. automodule:: stem.util.str_tools
stem-1.6.0/docs/api/util/log.rst 0000664 0001750 0001750 00000000060 13115423200 017164 0 ustar atagar atagar 0000000 0000000 Logging
=======
.. automodule:: stem.util.log
stem-1.6.0/docs/api/util/term.rst 0000664 0001750 0001750 00000000107 13115423200 017354 0 ustar atagar atagar 0000000 0000000 Terminal Utilities
==================
.. automodule:: stem.util.term
stem-1.6.0/docs/api/util/test_tools.rst 0000664 0001750 0001750 00000000105 13115423200 020602 0 ustar atagar atagar 0000000 0000000 Test Utilities
==============
.. automodule:: stem.util.test_tools
stem-1.6.0/docs/api/util/connection.rst 0000664 0001750 0001750 00000000121 13115423200 020540 0 ustar atagar atagar 0000000 0000000 Connection Utilities
====================
.. automodule:: stem.util.connection
stem-1.6.0/docs/api/util/system.rst 0000664 0001750 0001750 00000000105 13115423200 017727 0 ustar atagar atagar 0000000 0000000 System Utilities
================
.. automodule:: stem.util.system
stem-1.6.0/docs/api/util/init.rst 0000664 0001750 0001750 00000000057 13115423200 017354 0 ustar atagar atagar 0000000 0000000 Util
====
.. automodule:: stem.util.__init__
stem-1.6.0/docs/api/manual.rst 0000664 0001750 0001750 00000000054 13115423200 016706 0 ustar atagar atagar 0000000 0000000 Manual
======
.. automodule:: stem.manual
stem-1.6.0/docs/api/version.rst 0000664 0001750 0001750 00000000057 13115423200 017121 0 ustar atagar atagar 0000000 0000000 Version
=======
.. automodule:: stem.version
stem-1.6.0/docs/roles.py 0000664 0001750 0001750 00000005220 13115423200 015624 0 ustar atagar atagar 0000000 0000000 import re
from docutils.utils import unescape
from docutils.nodes import reference
from docutils.parsers.rst.roles import set_classes
def role_trac(name, rawtext, text, lineno, inliner, options={}, content=[]):
"""
Aliases :trac:`1234` to 'https://trac.torproject.org/1234'.
:param name: the role name used in the document
:param rawtext: the entire markup snippet, with role
:param text: the text marked with the role
:param lineno: the line number where rawtext appears in the input
:param inliner: the inliner instance that called us
:param options: directive options for customization
:param content: the directive content for customization
"""
# checking if the number is valid
try:
ticket_num = int(text)
if ticket_num <= 0:
raise ValueError
except ValueError:
msg = inliner.reporter.error('Invalid trac ticket: %s' % text, line=lineno)
prb = inliner.problematic(rawtext, rawtext, msg)
return ([prb], [msg])
app = inliner.document.settings.env.app
link_text = 'ticket %s' % unescape(str(ticket_num))
return (
[make_link_node(rawtext, app, 'trac_url', link_text, str(ticket_num), options)],
[],
)
def role_spec(name, rawtext, text, lineno, inliner, options={}, content=[]):
"""
Aliases :spec:`25b0d43` to 'https://gitweb.torproject.org/torspec.git/commit/?id=25b0d43'.
"""
# checking if the input is a valid short commit id
if not re.match('^[0-9a-f]{7}$', text):
msg = inliner.reporter.error('Spec tag expects a short commit id (seven hex characters): %s' % text, line=lineno)
prb = inliner.problematic(rawtext, rawtext, msg)
return ([prb], [msg])
app = inliner.document.settings.env.app
return (
[make_link_node(rawtext, app, 'spec_url', 'spec', text, options)],
[],
)
def make_link_node(rawtext, app, url_type, link_text, slug, options):
"""
Creates a link to a trac ticket.
:param rawtext: text being replaced with link node
:param app: sphinx application context
:param url_type: base for our url
:param link_text: text for the link
:param slug: ID of the thing to link to
:param options: options dictionary passed to role func
"""
base_url = getattr(app.config, url_type, None)
if not base_url:
raise ValueError("'%s' isn't set in our config" % url_type)
ref = base_url.format(slug = slug)
set_classes(options)
return reference(rawtext, link_text, refuri = ref, **options)
def setup(app):
"""
Installs the plugin.
:param app: sphinx application context
"""
app.add_role('trac', role_trac)
app.add_config_value('trac_url', None, 'env')
app.add_role('spec', role_spec)
app.add_config_value('spec_url', None, 'env')
stem-1.6.0/docs/change_log.rst 0000664 0001750 0001750 00000066555 13176650724 017014 0 ustar atagar atagar 0000000 0000000 Change Log
==========
The following is a log of all user-facing changes to Stem, both released and
unreleased. For a monthly report on work being done see my `development log
`_.
* :ref:`versioning`
* :ref:`unreleased`
* :ref:`version_1.5`
* :ref:`version_1.4`
* :ref:`version_1.3`
* :ref:`version_1.2`
* :ref:`version_1.1`
* :ref:`version_1.0`
.. _versioning:
Versioning
----------
Stem uses `semantic versioning `_, which means that
**versions consist of three numbers** (such as '**1.2.4**'). These are used to
convey the kind of backward compatibility a release has...
* The first value is the **major version**. This changes infrequently, and
indicates that backward incompatible changes have been made (such as the
removal of deprecated functions).
* The second value is the **minor version**. This is the most common kind of
release, and denotes that the improvements are backward compatible.
* The third value is the **patch version**. When a Stem release has a major
issue another release is made which fixes just that problem. These do not
contain substantial improvements or new features. This value is sometimes
left off to indicate all releases with a given major/minor version.
.. _unreleased:
Unreleased
----------
The following are only available within Stem's `git repository
`_.
* **Controller**
* :func:`~stem.process.launch_tor` raised a ValueError if invoked when outside the main thread
* Failure to authenticate could raise an improper response or hang (:trac:`22679`)
* Renamed :class:`~stem.response.events.ConnectionBandwidthEvent` type attribute to conn_type to avoid conflict with parent class (:trac:`21774`)
* Added 'force' argument to :func:`~stem.control.Controller.save_conf` (:spec:`5c82d5e`)
* Added the QUERY_NO_HSDIR :data:`~stem.HSDescReason` and recognizing unknown HSDir results (:spec:`1412d79`)
* Added the GUARD_WAIT :data:`~stem.CircStatus` (:spec:`6446210`)
* Unable to use cookie auth when path includes wide characters (chinese, japanese, etc)
* Tor change caused :func:`~stem.control.Controller.list_ephemeral_hidden_services` to provide empty strings if unset (:trac:`21329`)
* Better error message when :func:`~stem.control.Controller.set_conf` fails due to an option being immutable
* :func:`~stem.control.Controller.get_ports` didn't provide ports for many representations of localhost (:trac:`24085`)
* :func:`~stem.control.Controller.is_geoip_unavailable` now determines if database is available right away
* Added the time attribute to :class:`~stem.response.events.StreamBwEvent` and :class:`~stem.response.events.CircuitBandwidthEvent` (:spec:`00b9daf`)
* Added the consensus_content attribute to :class:`~stem.response.events.NewConsensusEvent` and deprecated its 'desc'
* Deprecated :func:`~stem.control.Controller.is_geoip_unavailable`, this is now available via getinfo instead (:trac:`23237`, :spec:`dc973f8`)
* Deprecated :class:`~stem.respose.events.AuthDirNewDescEvent` (:trac:`22377`, :spec:`6e887ba`)
* Caching manual information as sqlite rather than stem.util.conf, making :func:`stem.manual.Manual.from_cache` about ~8x faster
* Added :func:`~stem.manual.database` to get a cursor for the manual cache
* Failed to parse torrcs without a port on ipv6 exit policy entries
* Resilient to 'Tor' prefix in 'GETINFO version' result (:spec:`c5ff1b1`)
* Added a **all_extra** parameter to :class:`stem.version.Version` and support for multiple parenthetical entries (:trac:`22110`, :spec:`b50917d`)
* Setting 'UseMicrodescriptors 1' in your torrc caused :func:`~stem.control.Controller.get_network_statuses` to error (:trac:`24110`)
* Closing controller connection faster when under heavy event load
* Better messaging when unable to connect to tor on FreeBSD
* More succinct trace level logging
* **Descriptors**
* Supporting `descriptor creation `_ (:trac:`10227`)
* Support and validation for `ed25519 certificates `_ (`spec `_, :trac:`21558`)
* Added :func:`~stem.descriptor.networkstatus.NetworkStatusDocumentV3.validate_signatures` to check our key certificate signatures (:trac:`11045`)
* Moved from the deprecated `pycrypto `_ module to `cryptography `_ for validating signatures (:trac:`21086`)
* Sped descriptor reading by ~25% by deferring defaulting when validating
* Added server descriptor's new extra_info_sha256_digest attribute (:spec:`0f03581`)
* Added server descriptor's new protocol attribute (:spec:`eb4fb3c`)
* Added server descriptor's new bridge_distribution attribute (:trac:`21177`)
* Added extrainfo descriptor's new padding_counts attributes (:spec:`0803997`)
* Shared randomness properties weren't being read in votes (:trac:`21102`)
* Added bastet as a new authority (:trac:`23912`)
* Updated longclaw authority's address (:trac:`23592`)
* **Utilities**
* Support connection resolution on OpenBSD using fstat (:trac:`13807`)
* Added :func:`~stem.util.system.size_of`
* Added :func:`~stem.util.log.is_tracing`
* Added timeout argument to :func:`~stem.util.system.call`
* Added cwd argument to :func:`~stem.util.system.call`
* Added round argument to :func:`~stem.util.str_tools.size_label`
* Added :class:`~stem.util.test_tools.TimedTestRunner` and :func:`~stem.util.test_tools.test_runtimes`
* Supporing pid arguments in :func:`~stem.util.system.is_running`
* Made connection resolution via proc about 5x faster
* Normalized :func:`~stem.util.term.format` to return unicode
* Don't load vim swap files as configurations
* **Interpreter**
* Added a `'--run [command or path]' argument `_ to invoke specific commands (:trac:`21541`)
* Allowing interpreter to continue after tor shutsdown (:trac:`22374`)
* Interpreter buffered an unbounded number of events, leaking memory over time
* **Website**
* Source code served by '[source]' links perpetually stale (:trac:`19521`)
.. _version_1.5:
Version 1.5 (November 20th, 2016)
---------------------------------
`Stem 1.5 `_ is a long overdue
accumulation of seventeen months of improvements including dramatically
improved python 3.x performance, `tor manual information `_,
and much more.
* **Controller**
* Dramatic, 300x performance improvement for reading from the control port with python 3
* Added `stem.manual `_, which provides information available about Tor from `its manual `_ (:trac:`8251`)
* :func:`~stem.connection.connect` and :func:`~stem.control.Controller.from_port` now connect to both port 9051 (relay's default) and 9151 (Tor Browser's default) (:trac:`16075`)
* :class:`~stem.exit_policy.ExitPolicy` support for *accept6/reject6* and *\*4/6* wildcards (:trac:`16053`)
* Added `support for NETWORK_LIVENESS events `_ (:spec:`44aac63`)
* Added support for basic authentication to :func:`~stem.control.Controller.create_ephemeral_hidden_service` (:spec:`c2865d9`)
* Added support for non-anonymous services to :func:`~stem.control.Controller.create_ephemeral_hidden_service` (:spec:`b8fe774`)
* Added :func:`~stem.control.event_description` for getting human-friendly descriptions of tor events (:trac:`19061`)
* Added :func:`~stem.control.Controller.reconnect` to the :class:`~stem.control.Controller`
* Added :func:`~stem.control.Controller.is_set` to the :class:`~stem.control.Controller`
* Added :func:`~stem.control.Controller.is_user_traffic_allowed` to the :class:`~stem.control.Controller`
* Added the replica attribute to :class:`~stem.response.events.HSDescEvent` (:spec:`4989e73`)
* Added the NoEdConsensus :data:`~stem.Flag` (:spec:`dc99160`)
* Recognize listeners with IPv6 addresses in :func:`~stem.control.Controller.get_listeners`
* :func:`~stem.process.launch_tor` could leave a lingering process during an unexpected exception (:trac:`17946`)
* IPv6 addresses could trigger errors in :func:`~stem.control.Controller.get_listeners`, :class:`~stem.response.events.ORConnEvent`, and quite a few other things (:trac:`16174`)
* Don't obscure stacktraces, most notably :class:`~stem.control.Controller` getter methods with default values
* Classes with custom equality checks didn't provide a corresponding inequality method
* **Descriptors**
* `Shorthand functions for stem.descriptor.remote `_
* Added `fallback directory information `_.
* Support for ed25519 descriptor fields (:spec:`5a79d67`)
* Support downloading microdescriptor consensus with :func:~stem.descriptor.remote.DescriptorDownloader.get_consensus` (:spec`e788b8f`)
* Added consensus and vote's new shared randomness attributes (:spec:`9949f64`)
* Added server descriptor's new allow_tunneled_dir_requests attribute (:spec:`8bc30d6`)
* Server descriptor validation fails with 'extra-info-digest line had an invalid value' from additions in proposal 228 (:trac:`16227`)
* :class:`~stem.descriptor.server_descriptor.BridgeDescriptor` now has 'ntor_onion_key' like its unsanitized counterparts
* Replaced the :class:`~stem.descriptor.microdescriptor.Microdescriptor` identifier and identifier_type attributes with an identifiers hash since it can now appear multiple times (:spec:`09ff9e2`)
* Unable to read descriptors from data directories on Windows due to their CRLF newlines (:trac:`17051`)
* TypeError under python3 when using 'use_mirrors = True' (:trac:`17083`)
* Deprecated hidden service descriptor's *introduction_points_auth* field, which was never implemented in tor (:trac:`15190`, :spec:`9c218f9`)
* Deprecated :func:`~stem.descriptor.remote.DescriptorDownloader.get_microdescriptors` as it was never implemented in tor (:trac:`9271`)
* :func:`~stem.control.Controller.get_hidden_service_descriptor` errored when provided a *servers* argument (:trac:`18401`)
* Fixed parsing of server descriptor's *allow-single-hop-exits* and *caches-extra-info* lines
* Bracketed IPv6 addresses were mistreated as being invalid content
* Better validation for non-ascii descriptor content
* Updated dannenberg's v3ident (:trac:`17906`)
* Removed urras as a directory authority (:trac:`19271`)
* **Utilities**
* IPv6 support in :func:`~stem.util.connection.get_connections` when resolving with proc, netstat, lsof, or ss (:trac:`18079`)
* The 'ss' connection resolver didn't work on Gentoo (:trac:`18079`)
* Recognize IPv4-mapped IPv6 addresses in our utils (:trac:`18079`)
* Allow :func:`stem.util.conf.Config.set` to remove values when provided with a **None** value
* Support prefix and suffix issue strings in :func:`~stem.util.test_tools.pyflakes_issues`
* Additional information when :func:`~stem.util.system.call` fails through a :class:`~stem.util.system.CallError`
* Added **stem.util.system.SYSTEM_CALL_TIME** with the total time spent on system calls
* Added an **is_ipv6** value to :class:`~stem.util.connection.Connection` instances
* Added LINES attribute to :data:`~stem.util.term.Attr`
* Added :func:`~stem.util.system.pids_by_user`
* Added :func:`~stem.util.connection.address_to_int`
* Added :func:`~stem.util.term.encoding`
* Added :func:`~stem.util.__init__.datetime_to_unix`
* **Interpreter**
* Added a '--tor [path]' argument to specify the tor binary to run.
* **Website**
* `Comparison of our descriptor parsing libraries `_
* Example for `custom path selection for circuits `_ (:trac:`8728`)
* Example for `persisting ephemeral hidden service keys `_
* **Version 1.5.3** (December 5th, 2016) - including tests and site in the
release tarball
* **Version 1.5.4** (January 4th, 2017) - drop validation of the order of
fields in the tor consensus (:trac:`21059`)
.. _version_1.4:
Version 1.4 (May 13th, 2015)
----------------------------
`Stem's 1.4 release `_ brings
with it new hidden service capabilities. Most notably, `ephemeral hidden
services `_ and the
ability to `read hidden service descriptors
`_. This release also
changes descriptor validation to now be opt-in rather than opt-out. When
unvalidated content is lazy-loaded, `greatly improving our performance
`_.
And last, Stem also now runs directly under both python2 and python3 without a
2to3 conversion (:trac:`14075`)!
* **Controller**
* Added :class:`~stem.control.Controller` methods for a new style of hidden services that don't touch disk: :func:`~stem.control.Controller.list_ephemeral_hidden_services`, :func:`~stem.control.Controller.create_ephemeral_hidden_service`, and :func:`~stem.control.Controller.remove_ephemeral_hidden_service` (:spec:`f5ff369`)
* Added :func:`~stem.control.Controller.get_hidden_service_descriptor` and `support for HS_DESC_CONTENT events `_ (:trac:`14847`, :spec:`aaf2434`)
* :func:`~stem.process.launch_tor_with_config` avoids writing a temporary torrc to disk if able (:trac:`13865`)
* :class:`~stem.response.events.CircuitEvent` support for the new SOCKS_USERNAME and SOCKS_PASSWORD arguments (:trac:`14555`, :spec:`2975974`)
* The 'strict' argument of :func:`~stem.exit_policy.ExitPolicy.can_exit_to` didn't behave as documented (:trac:`14314`)
* Threads spawned for status change listeners were never joined on, potentially causing noise during interpreter shutdown
* Added support for specifying the authentication type and client names in :func:`~stem.control.Controller.create_hidden_service` (:trac:`14320`)
* **Descriptors**
* Lazy-loading descriptors, improving performance by 25-70% depending on what type it is (:trac:`14011`)
* Added `support for hidden service descriptors `_ (:trac:`15004`)
* When reading sanitised bridge descriptors (server or extrainfo), :func:`~stem.descriptor.__init__.parse_file` treated the whole file as a single descriptor
* The :class:`~stem.descriptor.networkstatus.DirectoryAuthority` 'fingerprint' attribute was actually its 'v3ident'
* Added consensus' new package attribute (:spec:`ab64534`)
* Added extra info' new hs_stats_end, hs_rend_cells, hs_rend_cells_attr, hs_dir_onions_seen, and hs_dir_onions_seen_attr attributes (:spec:`ddb630d`)
* Updating Faravahar's address (:trac:`14487`)
* **Utilities**
* Windows support for connection resolution (:trac:`14844`)
* :func:`stem.util.connection.port_usage` always returned None (:trac:`14046`)
* :func:`~stem.util.test_tools.stylistic_issues` and :func:`~stem.util.test_tools.pyflakes_issues` now provide namedtuples that also includes the line
* Added :func:`stem.util.system.tail`
* Proc connection resolution could fail on especially busy systems (:trac:`14048`)
* **Website**
* Added support and `instructions for tox `_ (:trac:`14091`)
* Added OSX to our `download page `_ (:trac:`8588`)
* Updated our twitter example to work with the service's 1.1 API (:trac:`9003`)
* **Version 1.4.1** (May 18th, 2015) - fixed issue where descriptors couldn't
be unpickled (:trac:`16054`) and a parsing issue for router status entry
bandwidth lines (:trac:`16048`)
.. _version_1.3:
Version 1.3 (December 22nd, 2014)
---------------------------------
With `Stem's 1.3 release `_
it's now much easier to `work with hidden services
`_, 40% faster to read decriptors, and includes
a myriad of other improvements. For a nice description of the changes this
brings see `Nathan Willis' LWN article `_.
* **Controller**
* Added :class:`~stem.control.Controller` methods to more easily work with hidden service configurations: :func:`~stem.control.Controller.get_hidden_service_conf`, :func:`~stem.control.Controller.set_hidden_service_conf`, :func:`~stem.control.Controller.create_hidden_service`, and :func:`~stem.control.Controller.remove_hidden_service` (:trac:`12533`)
* Added :func:`~stem.control.Controller.get_accounting_stats` to the :class:`~stem.control.Controller`
* Added :func:`~stem.control.Controller.get_effective_rate` to the :class:`~stem.control.Controller`
* Added :func:`~stem.control.BaseController.connection_time` to the :class:`~stem.control.BaseController`
* Changed :func:`~stem.control.Controller.get_microdescriptor`, :func:`~stem.control.Controller.get_server_descriptor`, and :func:`~stem.control.Controller.get_network_status` to get our own descriptor if no fingerprint or nickname is provided.
* Added :class:`~stem.exit_policy.ExitPolicy` methods for more easily handling 'private' policies (the `default prefix `_) and the defaultly appended suffix. This includes :func:`~stem.exit_policy.ExitPolicy.has_private`, :func:`~stem.exit_policy.ExitPolicy.strip_private`, :func:`~stem.exit_policy.ExitPolicy.has_default`, and :func:`~stem.exit_policy.ExitPolicy.strip_default` :class:`~stem.exit_policy.ExitPolicy` methods in addition to :func:`~stem.exit_policy.ExitPolicyRule.is_private` and :func:`~stem.exit_policy.ExitPolicyRule.is_default` for the :class:`~stem.exit_policy.ExitPolicyRule`. (:trac:`10107`)
* Added the reason attribute to :class:`~stem.response.events.HSDescEvent` (:spec:`7908c8d`)
* :func:`~stem.process.launch_tor_with_config` could cause a "Too many open files" OSError if called too many times (:trac:`13141`)
* The :func:`~stem.control.Controller.get_exit_policy` method errored if tor couldn't determine our external address
* The Controller's methods for retrieving descriptors could raise unexpected ValueErrors if tor didn't have any descriptors available
* Throwing a new :class:`~stem.DescriptorUnavailable` exception type when the :class:`~stem.control.Controller` can't provide the descriptor for a relay (:trac:`13879`)
* **Descriptors**
* Improved speed for parsing consensus documents by around 40% (:trac:`12859` and :trac:`13821`)
* Don't fail if consensus method 1 is not present, as it is no longer required (:spec:`fc8a6f0`)
* Include '\*.new' files when reading from a Tor data directory (:trac:`13756`)
* Updated the authorities we list, `replacing turtles with longclaw `_ and `updating gabelmoo's address `_
* Noting if authorities are also a bandwidth authority or not
* Microdescriptor validation issues could result in an AttributeError (:trac:`13904`)
* **Utilities**
* Added support for directories to :func:`stem.util.conf.Config.load`
* Changed :func:`stem.util.conf.uses_settings` to only provide a 'config' keyword arument if the decorated function would accept it
* Added :func:`stem.util.str_tools.crop`
* Added :func:`stem.util.proc.file_descriptors_used`
* Dropped the 'get_*' prefix from most function names. Old names will still work, but are a deprecated alias.
* **Interpreter**
* The /info command errored for relays without contact information
* **Website**
* Tutorial for `hidden services `_
* Example for `writing descriptors to disk and reading them back `_ (:trac:`13774`)
* Added Gentoo to our `download page `_ and handful of testing revisions for that platform (:trac:`13904`)
* Tests for our tutorial examples (:trac:`11335`)
* Revised `GitWeb `_ urls to work after its upgrade
.. _version_1.2:
Version 1.2 (June 1st, 2014)
----------------------------
`Stem release 1.2 `_
added our `interactive Tor interpreter `_
among numerous other improvements and fixes.
* **Controller**
* New, better :func:`~stem.connection.connect` function that deprecates :func:`~stem.connection.connect_port` and :func:`~stem.connection.connect_socket_file`
* Added :func:`~stem.control.Controller.is_newnym_available` and :func:`~stem.control.Controller.get_newnym_wait` methods to the :class:`~stem.control.Controller`
* Added :func:`~stem.control.Controller.get_ports` and :func:`~stem.control.Controller.get_listeners` methods to the :class:`~stem.control.Controller`
* Added :func:`~stem.control.Controller.drop_guards` (:trac:`10032`, :spec:`7c6c7fc`)
* Added the id attribute to :class:`~stem.response.events.ORConnEvent` (:spec:`6f2919a`)
* Added `support for CONN_BW events `_ (:spec:`6f2919a`)
* Added `support for CIRC_BW events `_ (:spec:`6f2919a`)
* Added `support for CELL_STATS events `_ (:spec:`6f2919a`)
* Added `support for TB_EMPTY events `_ (:spec:`6f2919a`)
* Added `support for HS_DESC events `_ (:trac:`10807`, :spec:`a67ac4d`)
* Changed :func:`~stem.control.Controller.get_network_status` and :func:`~stem.control.Controller.get_network_statuses` to provide :class:`~stem.descriptor.router_status_entry.RouterStatusEntryMicroV3` if Tor is using microdescriptors (:trac:`7646`)
* The :func:`~stem.connection.connect_port` and :func:`~stem.connection.connect_socket_file` didn't properly mark the Controller it returned as being authenticated, causing event listening among other things to fail
* The :func:`~stem.control.Controller.add_event_listener` method couldn't accept event types that Stem didn't already recognize
* The :class:`~stem.exit_policy.ExitPolicy` class couldn't be pickled
* Tor instances spawned with :func:`~stem.process.launch_tor` and :func:`~stem.process.launch_tor_with_config` could hang due to unread stdout content, we now close stdout and stderr once tor finishes bootstrapping (:trac:`9862`)
* **Descriptors**
* Added tarfile support to :func:`~stem.descriptor.__init__.parse_file` (:trac:`10977`)
* Added microdescriptor's new identifier and identifier_type attributes (:spec:`22cda72`)
* **Utilities**
* Added the `stem.util.test_tools `_ module
* Started vending the `stem.util.tor_tools `_ module
* Added :func:`stem.util.connection.port_usage`
* Added :func:`stem.util.system.files_with_suffix`
* **Interpreter**
* Initial release of our `interactive Tor interpreter `_!
* **Website**
* Added a section with `example scripts `_.
* Made FAQ and other sections quite a bit more succinct.
* **Version 1.2.2** (June 7th, 2014) - fixed an issue where the stem.util.conf
module would fail under Python 2.6 with an AttributeError (:trac:`12223`)
* **Version 1.2.1** (June 3rd, 2014) - fixed an issue where descriptor
parsersing would fail under Python 3.x with a TypeError (:trac:`12185`)
.. _version_1.1:
Version 1.1 (October 14th, 2013)
--------------------------------
`Stem release 1.1 `_
introduced `remote descriptor fetching `_,
`connection resolution `_
and a myriad of smaller improvements and fixes.
* **Controller**
* :func:`~stem.control.Controller.get_network_status` and :func:`~stem.control.Controller.get_network_statuses` now provide v3 rather than v2 directory information (:trac:`7953`, :spec:`d2b7ebb`)
* :class:`~stem.response.events.AddrMapEvent` support for the new CACHED argument (:trac:`8596`, :spec:`25b0d43`)
* :func:`~stem.control.Controller.attach_stream` could encounter an undocumented 555 response (:trac:`8701`, :spec:`7286576`)
* :class:`~stem.descriptor.server_descriptor.RelayDescriptor` digest validation was broken when dealing with non-unicode content with Python 3 (:trac:`8755`)
* The :class:`~stem.control.Controller` use of cached content wasn't thread safe (:trac:`8607`)
* Added :func:`~stem.control.Controller.get_user` method to the :class:`~stem.control.Controller`
* Added :func:`~stem.control.Controller.get_pid` method to the :class:`~stem.control.Controller`
* :class:`~stem.response.events.StreamEvent` didn't recognize IPv6 addresses (:trac:`9181`)
* :func:`~stem.control.Controller.get_conf` mistakenly cached hidden service related options (:trac:`9792`)
* Added `support for TRANSPORT_LAUNCHED events `_ (:spec:`48f6dd0`)
* **Descriptors**
* Added the `stem.descriptor.remote `_ module.
* Added support for `TorDNSEL exit lists `_ (:trac:`8255`)
* The :class:`~stem.descriptor.reader.DescriptorReader` mishandled relative paths (:trac:`8815`)
* **Utilities**
* Connection resolution via the :func:`~stem.util.connection.get_connections` function (:trac:`7910`)
* :func:`~stem.util.system.set_process_name` inserted spaces between characters (:trac:`8631`)
* :func:`~stem.util.system.pid_by_name` can now pull for all processes with a given name
* :func:`~stem.util.system.call` ignored the subprocess' exit status
* Added :func:`stem.util.system.name_by_pid`
* Added :func:`stem.util.system.user`
* Added :func:`stem.util.system.start_time`
* Added :func:`stem.util.system.bsd_jail_path`
* Added :func:`stem.util.system.is_tarfile`
* Added :func:`stem.util.connection.is_private_address`
* **Website**
* Overhaul of Stem's `download page `_. This included several
improvements, most notably the addition of PyPI, Ubuntu, Fedora, Slackware,
and FreeBSD.
* Replaced default sphinx header with a navbar menu.
* Added this change log.
* Added the `FAQ page `_.
* Settled on a `logo
`_ for
Stem.
* Expanded the `client usage tutorial `_
to cover SocksiPy and include an example for polling Twitter.
* Subtler buttons for the frontpage (`before
`_ and `after
`_).
* **Version 1.1.1** (November 9th, 2013) - fixed an issue where imports of stem.util.system
would fail with an ImportError for pwd under Windows (:trac:`10072`)
.. _version_1.0:
Version 1.0 (March 26th, 2013)
------------------------------
This was the `initial release of Stem
`_.
* **Version 1.0.1** (March 27th, 2013) - fixed an issue where installing with
Python 3.x (python3 setup.py install) resulted in a stacktrace
stem-1.6.0/docs/Makefile 0000664 0001750 0001750 00000011005 13115423200 015564 0 ustar atagar atagar 0000000 0000000 # Makefile for Sphinx documentation
#
# You can set these variables from the command line.
SPHINXOPTS =
SPHINXBUILD = sphinx-build
PAPER =
BUILDDIR = _build
# Internal variables.
PAPEROPT_a4 = -D latex_paper_size=a4
PAPEROPT_letter = -D latex_paper_size=letter
ALLSPHINXOPTS = -d $(BUILDDIR)/doctrees $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) .
.PHONY: help clean html dirhtml singlehtml pickle json htmlhelp qthelp devhelp epub latex latexpdf text man changes linkcheck doctest
help:
@echo "Please use \`make ' where is one of"
@echo " html to make standalone HTML files"
@echo " dirhtml to make HTML files named index.html in directories"
@echo " singlehtml to make a single large HTML file"
@echo " pickle to make pickle files"
@echo " json to make JSON files"
@echo " htmlhelp to make HTML files and a HTML help project"
@echo " qthelp to make HTML files and a qthelp project"
@echo " devhelp to make HTML files and a Devhelp project"
@echo " epub to make an epub"
@echo " latex to make LaTeX files, you can set PAPER=a4 or PAPER=letter"
@echo " latexpdf to make LaTeX files and run them through pdflatex"
@echo " text to make text files"
@echo " man to make manual pages"
@echo " changes to make an overview of all changed/added/deprecated items"
@echo " linkcheck to check all external links for integrity"
@echo " doctest to run all doctests embedded in the documentation (if enabled)"
clean:
-rm -rf $(BUILDDIR)/*
@rm -f ./stem.* ./modules.rst
html:
$(SPHINXBUILD) -b html $(ALLSPHINXOPTS) $(BUILDDIR)/html
@echo
@echo "Build finished. The HTML pages are in $(BUILDDIR)/html."
dirhtml:
$(SPHINXBUILD) -b dirhtml $(ALLSPHINXOPTS) $(BUILDDIR)/dirhtml
@echo
@echo "Build finished. The HTML pages are in $(BUILDDIR)/dirhtml."
singlehtml:
$(SPHINXBUILD) -b singlehtml $(ALLSPHINXOPTS) $(BUILDDIR)/singlehtml
@echo
@echo "Build finished. The HTML page is in $(BUILDDIR)/singlehtml."
pickle:
$(SPHINXBUILD) -b pickle $(ALLSPHINXOPTS) $(BUILDDIR)/pickle
@echo
@echo "Build finished; now you can process the pickle files."
json:
$(SPHINXBUILD) -b json $(ALLSPHINXOPTS) $(BUILDDIR)/json
@echo
@echo "Build finished; now you can process the JSON files."
htmlhelp:
$(SPHINXBUILD) -b htmlhelp $(ALLSPHINXOPTS) $(BUILDDIR)/htmlhelp
@echo
@echo "Build finished; now you can run HTML Help Workshop with the" \
".hhp project file in $(BUILDDIR)/htmlhelp."
qthelp:
$(SPHINXBUILD) -b qthelp $(ALLSPHINXOPTS) $(BUILDDIR)/qthelp
@echo
@echo "Build finished; now you can run "qcollectiongenerator" with the" \
".qhcp project file in $(BUILDDIR)/qthelp, like this:"
@echo "# qcollectiongenerator $(BUILDDIR)/qthelp/Stem.qhcp"
@echo "To view the help file:"
@echo "# assistant -collectionFile $(BUILDDIR)/qthelp/Stem.qhc"
devhelp:
$(SPHINXBUILD) -b devhelp $(ALLSPHINXOPTS) $(BUILDDIR)/devhelp
@echo
@echo "Build finished."
@echo "To view the help file:"
@echo "# mkdir -p $$HOME/.local/share/devhelp/Stem"
@echo "# ln -s $(BUILDDIR)/devhelp $$HOME/.local/share/devhelp/Stem"
@echo "# devhelp"
epub:
$(SPHINXBUILD) -b epub $(ALLSPHINXOPTS) $(BUILDDIR)/epub
@echo
@echo "Build finished. The epub file is in $(BUILDDIR)/epub."
latex:
$(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex
@echo
@echo "Build finished; the LaTeX files are in $(BUILDDIR)/latex."
@echo "Run \`make' in that directory to run these through (pdf)latex" \
"(use \`make latexpdf' here to do that automatically)."
latexpdf:
$(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex
@echo "Running LaTeX files through pdflatex..."
make -C $(BUILDDIR)/latex all-pdf
@echo "pdflatex finished; the PDF files are in $(BUILDDIR)/latex."
text:
$(SPHINXBUILD) -b text $(ALLSPHINXOPTS) $(BUILDDIR)/text
@echo
@echo "Build finished. The text files are in $(BUILDDIR)/text."
man:
$(SPHINXBUILD) -b man $(ALLSPHINXOPTS) $(BUILDDIR)/man
@echo
@echo "Build finished. The manual pages are in $(BUILDDIR)/man."
changes:
$(SPHINXBUILD) -b changes $(ALLSPHINXOPTS) $(BUILDDIR)/changes
@echo
@echo "The overview file is in $(BUILDDIR)/changes."
linkcheck:
$(SPHINXBUILD) -b linkcheck $(ALLSPHINXOPTS) $(BUILDDIR)/linkcheck
@echo
@echo "Link check complete; look for any errors in the above output " \
"or in $(BUILDDIR)/linkcheck/output.txt."
doctest:
$(SPHINXBUILD) -b doctest $(ALLSPHINXOPTS) $(BUILDDIR)/doctest
@echo "Testing of doctests in the sources finished, look at the " \
"results in $(BUILDDIR)/doctest/output.txt."
stem-1.6.0/docs/_static/ 0000775 0001750 0001750 00000000000 13177674754 015613 5 ustar atagar atagar 0000000 0000000 stem-1.6.0/docs/_static/prompt/ 0000775 0001750 0001750 00000000000 13177674754 017134 5 ustar atagar atagar 0000000 0000000 stem-1.6.0/docs/_static/prompt/run_file.png 0000664 0001750 0001750 00000103265 13124757507 021442 0 ustar atagar atagar 0000000 0000000 ‰PNG
IHDR Õ ? ‰„? sRGB ®Î é bKGD ÿ ÿ ÿ ½§“ pHYs šœ tIMEá -±Kñ IDATxÚìÝwxU÷ðïlͦ÷ž@B
z“" R¤ˆ öŠˆ ¨`E_EP°¼XPDTˆ— !$$$$¤÷²I6ÛÏïMH!e‚ñçù<Ïy عsçÎÌ™É;Z×ÀÏ <ÁcŒ1ÆØ¿C.€$ Ç ìpº¥‰…¾à øNcŒ1ÆØ¿Ü! ï øµ-Iõ& pÝ1ÆcŒ1ÖÀ' m-©¶‡åöö0®/ÆcŒ1ÆštÀd êæ’ꃜP3ÆcŒ1&*± ^û I½/6ý+je0æ¾¾ «Æz@ʃ1ÆcŒ‰3¬&nTÃ? µ`ˆÁ“&£¿[;¦¿VaXðÒ“˜ÞÕ¶ÁÆÿ×u¿)uÈcŒ1öïôHM }-|¡þ·Rç^Ø|ø(NÅÆcÏs×>÷¾o7
Ò>Æ0Gáo)µU×Eر{#æ(þu[¬½Öýß\‡Œ1Æc7Á µIu_4êöÑsÙ :ò8FLÿ~/®ÁG@êu/6|Ð ».Ç¡2âêcŒ1ÆcÌ’G÷€5 ¨.$4õšN/ô!©Ó:¨>KúÒôy”ñÙ(’5˜VL(É/r}}4•ÊÌDDD&u XÞ¬j¦‘zßKÛ’ËÈ`ùšª³NÐæÇz‘½¤f 6CèËbjRåÎQd׆ò¶]iþ¦£”¥#"ÒSÎù8RÑ…ç:‘¼v:™;ݹx Åd눈ÈPK;–
#7©å{Ut ÂRÖŒ£ôíæßèr%‘©è4Ÿì]WG
?ºëµÝt±„ˆÈLÅ~¢W'ø‘¢-õ'bÝe~shwQáÖiäUSF©ç4Ú^L”¹i9KÚ·988888888ÄÀ2âGƒ/n̤Ü-‘ä?øCºZüÍ›¿ƒò27ÓXgI #ßÙ»¨„ˆ
n ç ˜FãÇDÒÝs ¡yýIR;U'?c2ÔŸú¹‹žü"™ˆrè£Ö–ïyw¡^3·QѶ™½(,,ŒÂÂÂ(ÄÛºn>…Ôƒ¦~_BdºD_??ƒ&LžK‹?>N•õ“jÁŽîx7‰HGŸ?=™† F÷®ØK¤£Ã ûÈ_HK ´zü º÷“L"ºHoN A ¾Í'ÊÛHAœhäÆL"J£íKgÒø ³è¥W‰(“6t"Al™E»„\Æ|B™TM‡ž
%¥Ìîߣ&sò;4ÐNhß:äààààààààh §ñrÿ™ôù¹|*/J Ë_ ]¹Yôå8—¶/Àf0}V@d<ö$uR´áwŽiŸŽèâÒº»Ç ©ú§ Ê¡õýT7´Â²À§é Å= \7_‡Ét°^R-õ}Žµ5×›¤×[Wºç€žèü3 «IªÍ‡iº3ÈnìO¤1 ¥™®ÙÚI•æã4ÇC ©ÿ£CD—Vv%eí|”áôJx˜ü¤m+{«ë.ØPïWΓ‰.ÓÖOO’ÆK+º[·}> m ¯Æ C ßaaO8¸Ý¯»<ƒþGÞCÒü#(*ÏÇ™Oï…Ÿ\\¹Ï rÎ|þÒôÍO'ó¶ Cj‘&³¥—þ‹Ñ
@i£h×9TCŒ< 9’CsÓ„ŒF¸T‰‘_gÃH"™ ±c” p{ãu7›A 2a†RA€uð„!ÑûÓ «V—Š_£ò€°áVµso ªÂ™7¦cÑÉ Ü÷Pd¬žƒµç5Üˉ1Æcìæsm1gu ·›F  ?
Âsý£1%b>.Mú^îc-2Ñ3ƒ ˜M-<Ø(“¿ ÀÛã+ðí31°×@DÎ1ú›°ºT“ Kš ½D$PˆofôF×®]DØקm¼Z))j" j×J„{×þ†¤rËweI¿bí½ÁP ÿüMiÓ! rBºyAÉm›1Æcì–‘5÷…2äqì9·Ãs¾ÇÊ^À¡l9üzŽÀ`stæúSžÅ¢Áó]Q÷‰¡$ 8ø »ÛC
\'mÁ «¬ 5» Í€© i `@ú'!üW[¸×Ÿ¦
9i††eñ.ÞŽü³÷ÁÜì*]_ “:
qÃ]Ÿ Çö{²ðñSã±ð’ sßÀºíÇá
ÃÜŸ [˜ïí΄¬¯& ó…`è΢ŒÛ6cŒ1ÆØ-uý«¥Þ4{¿–¨p Ýå&iæuŒ2êøT, ¤É½ºQB sOQ½Wx·a‰ç<:iª¦¸ÿe’>í?4ÀØÒðmådŽ™O^qå‘?Oqd¢cÔ{ý¹,€žˆ1]XB!r1¯¡Èmúo¤£|úôëzŸ+)|u*‘öWšêZóZp™;ݹx ÅdëjÞ K;–
#7i½us DÏ|ô OÎ#µ¾ö=î¥ttI—k¯3—8ô¦'¾8AU5_›ª(/öëlYŽÔg!¦zM!Ç&_ÑîGw½¶›.–™©øÂOô꿺צKÜiÜûQt!£”j߯NÙOïNëHJ~ý(G³Ñd÷‰ÛH<:J‰ËÞÂþÂÛåÞ>xßZ?Žuv‚¼Í¿—À¹ßd„ã¾û=ÆÚ™Ø÷M Ðm2ú»HD]ƒ ù
GîwOX]ßeE'L™ýá/q´„ Áw¼u‡ÞèŽ oß‹;ïŽÙë³1ìÍßñÃC×þD ó ‰' Ÿ ×ÃoãÑéc1bØHDNyoí¾
= ÀÞÙ‡
3LØöØX ê? CÆÍÃòM¿"¹Òò†ySþ÷˜Þ¥+ºFŒÁÉÍ[pÂÈuÇñËŠÄ¿} &Ü5ï%õÄÊ=ÇñáH' ±EèÈ‘è¦ß‚Ç&E"òîñQF,Þù#ž®éŠÃcŒ1ÆDÞ©¶ê¹–®’†~ c×BF^{g¸±Ã4ÝùfÜ©.¥-w:RÇGŽ¦à+íh×ÌêÆÎÓsAr¶"‰H¿ÆÛ7\¶ýø½¤£dZÕU!îjDâI³¢ôDW×R/+ËgÊð×(…ªèç»]I Hêû 3j)j®7Ik'¸Ò=ôD矡 ™å3EØJJ¦*Ú5º¹ºv¤‰ûtDY›h¼§¬årÉ:Ðçš¾S-õ”bˆèÒÊ®uw•áôJx˜ü¤ ÈéÙ¸†¿—u|’ÎÑŸûÕGëwªA&˜A>´B¯·Q‘²ýë~Ïëƒ>}j¢ç (¿Yù¿éß,ÁgÚxc^'4}ïô,
îŽîÝk"|¾Ê0´o1ÌùØÿÑï¨öŸÙ]U ¬ÐõþyèTú#>ï"²É]úúB±?±¦‚ ©Ê ¶öªFÉU9RbÏàLù-*qÕŸxïµSXøÊ"ô=×Ôj¤ÅÇ!®üú„¼8{£“³ P¯Us' (P€+ÅFÑ7÷‹£×aWéÌz°V&Ëñø<doùÇk–+(Ä73"ñf¼¶á¯õÅH׊_åêÄO0=èGôž8sçÜW~^„7O¿ƒIã_BT‘©áß j4=˜‰pÝçB«£ž˜a4‚D€Àû cŒ1ÆX“š¼Sm.:Œ-'Í}r†:ÝnCY‘±ýe|#Ì #ìÛè™Qrj7⎙c|ê®&d~˜0'¸ø bŠÅ÷ §ò£øÏçWá9{1îµ ÷¹žÇûÎYF= I>€xrÃà~rd$& !¡.SòQMm\m}Îüð <;¥'|— ±ï XÿPPþå¤C…€ìÝVÖ\ŽF<0bL`Ýp{ÊNˆ é $ ÄåjÞcŒ1ÆnTÓCê3ðÍSkðØé•ØwØ
+ßÚ†˜lút±obb{t‹@DEýß—áÊ¥ TŠÌQ®Añ¶…{[ ü»F Â
9I)(Ò7‘}VœÀ»ï_ÄÃk»·ie
)_áåmKñÓú]xß¼ ß]’¢û¼·°®_)¶Où)mê%¢EÜƵˆyn6oªöÞ‹oRëf`ÊÚ¥ .ÃÿGãój¬ÿ9yx‡ø£ä‡
Ø-ºKŠ=¿ö L)FÔ™TéTð:>0ár^UÃ! Íe¸x<xn ^}¬?æ;¢£Õq|º%ÚÌíxñ“åøãÕ_°Å¸ [â¥èñÀëX’…OF},Z`‘1ÆcŒµ¦Ùú>L£/SyÍ#†’T:ößy¨héÁ@"Òí¥qöb T”SÈÒ„&f’H/†*=¨h[×Üm*í®$¢6 ©€ëPšõA¥TX–R‘E Ì
%ká:¥ Ž4fK1¥Ñ;½UM MèFCžÝL‡¯¨kÖÉH%ÉûhY„ÕµiZ}PQêNcÖüBqùÚk5£Í‹£_Þ¼›:(¯Ÿ^ê6ŠÖü‘A:""Sýx ¹Jê†Ô›¸f/]ªÙ e‰{hÍDÿº!õšxPv#iGQÊkÝxX=ŽærL Ä׌1ÆcŒÝ8 WcŒ1ÆcœT3ÆcŒ1ÆI5cŒ1ÆcœT3ÆcŒ1ÆI5cŒ1ÆcŒ“jÆcŒ1Æ8©f-“Ã{üjür±:"± ™gwâ¹nV5ß pù1.ë58»ºT7¹4‚M OšŒþnÒ›¾æ·rYŒ1ÆcíœT Puš‚Õ»Î!OO "TežÂÖÅýá :> "º.Ê·
‡- ‡IÀÜÄ÷D2îÇ]–d1diBÓ$âÅP…¥žóp’Ú?ÀÿÚ[ÿl1|[9Ì1óáÕJyLQáP»Vª Ü»ö7$•[¾+Kúkï
†J¸Í7”çt|¹ëeÜ™ÿ)FÞ‰;ÇÎÂâõ»qªÀpmSÚtG \…n^u¯"¿I¬º.ÂŽÝ1'@qÓ×ýV.‹1ÆcìF4ûbjeÈãØsn†ç|•¼€CÙrøõ Áæ*è¼û,
žèz¯)7”¤B Dxw{H!ë¤-øcµ€•£æ`w¡0•# Hÿï$„ÿj ÷úÓT!'᫼•#ÞÅÛ‘?cöž"4ÿôëËcR§¡ $n¸ë³ãØ~O>~j<^’!bîX·ý8¼µa˜ûs!Ì·é†RúöG˜² Û^~ [Žkš˜Â„¬¯& ó…`è΢ŒÛ6cŒ1ÆØ-ÕÄ«±½iö~-QáºËMÒÌëŽ ¾¦¼õi,¯)¯¦¸ÿe’>í?4ÀØÒðmådnÃkÊåÁÏS ™èØ# HvíÕÜôDŒ™èÂ
‘·åu”Jò‹\F_ M¥2³åµß&u XÞ¬P÷Zð»^ÛMKˆˆÌT|á'zu‚_ÝkÁ%î4îý(ºQJµ/!W§ì§w§u¬{%¸Íú²¸é·Á',
!9@RŸ…tºþõ_3^?¾4á• )®ÈT[`ʼ°ŸÞ‹t#‰Øõn¡<•;G‘ݵzu§;o¡˜lå÷±´cÙ0r“Z¾—ùÍ¡ÝeD…[§‘WÍgRÏi´½˜(sÓ(r–´aY \ÿ¡Äs. 1%¯êZ— þíIu)};e
}‘¯¥˜§;‘¼ÍIµ„ìGÒzóSõ[O9”Cëû©š/—¬=q®é¤Zê·Ž›‰R_ïQw'Ýa2 l"©–ªìÉÑɉœœœÈÉÑžTÒë—ÕRy¤¾Ò1£–¢æz׃àJ÷ ІdµŸÙPïWΓ‰.ÓÖOO’ÆK+º[·iY ·C4ý "™`¶$ÜõX¡×Û‰¨HY‡þÖõ??‡ç‡õAŸ>5Ñs”߬ž*F¤³ŸigàyÐôckg±hpwtï^áÓðU†¡]K!÷„AnÀ™Ï@š¾éi¬ƒG yˆÞŸ]퇺Tü•„
Gp3Ãs‹“¦ ¼íÑžc]¨‚G¡›P€¨½Éж8¥
mJGiI JJJPRz
´iÛ²BF#\ªÄȯ³a¬}`Ô\ˆ £ä€{Üåµí¬
gÞ˜ŽE'pßCý‘±zÖž×p‡,ÆcŒýã4ù ¢>ï"²É]úúB±?–¼Q€Te[{U£d¯ )±gp¦ü•¸êO¼÷Ú),|eúžkj5ÒâãW~}B^œVȽÑÉY¨×ªÀ¹“(À•b£¸2å’Ãl¢V&ÐxP¡ÕQFÌ0šArýo[/Wý%7Z®T)LÐ[+s5ο9#·¨,CØ«‘y¡ºMŠ⛑x3¾a
Oúb¤×ûHî; ºIA& töèýþ S1ÆûGiòNµ¹è0¶œ4#ôÉEêt»
emDÆö—ñ0 /Œ°oCâiFɩ݈G8fŽñ©»šùaÂœàâ/ˆ)7ö‡!÷$bŠ€^ &£ƒ¼éi4—£‘ ŒX7¼²"Gz q¹ú&T
éP¡`ç»F·¹µ§p^2ÈòVê©üÒ1DGE!**
QÑÇTnnbQ•ÐÁnv×_—i’ žÜ0¸Ÿ ‰ HH¨‹Ä”|T×äÌ‚m ¼üãF ]„ "Êg1v~0®ñËbŒ1Æ» 4¥3ðÍSkðØé•ØwØ
+ßÚ†˜lút±obb{t‹@DEýß—áÊ¥ TŠ ŸNá„o[¸w° À¿k"ܪ“”‚"}w-+NàÝ÷/âáµÝÛ´²†”¯ðò¶¥øiý.¼o^Žï.IÑ}Þ[Xׯۧ|±½D*ObõK¿ãžO7áÔ¼½ù .æi!sðAù1|¾õ´™Ûñâ'ËñÇ«¿`‹q9¶ÄKÑã×±*$ ŸŒú Y&´0 á
2—áâñLà¹%xõ±Bü˜ïˆŽVÇñé–DhS¿Å;ûWâ‹w~ÄǦÕø)]ŽNà B/ 7°(]V â«—áî7^Áü5û‘'óAˆýI|úUª³v`é‡Ëð¿ÅÑ8ä¼ëŽEžÁÞ!þ(ùavg ÁCß؉•þ»1³ëzÄå , Ä_ãÃÝa˜³»àÚð†-.‹÷aÆcŒÝ&š}pЩïô1ú2•×<òg(I¥cÿGŠ– $"Ý^g/öAE9…,Mhb&‰ôbÍu*ÚÖuw›J»+‰¨
Cê Á:”f}E)–¥T¤DѳBÉZhc‡tAEWÐÖéTqmœ·L:±a<¹Iê†Ô›¸f/]ª©À²Ä=´f¢Ýˆ*M<¨»‘´£‚(åµnu8¶áa=©Û(ZóG鈈LEtöãqäZS ‰Ó zöÛ³T`""ÒSÎ…‹TIDçŸ ¬bPt((`æGt,»f0@CÞ0–\j×]êFCžÝL‡¯¨k*ÇH%ÉûhY„Ù
|ŸÒ©„¶Oñ¨{˜QæO ¢µDÙi¨½ ~Y s ¸ë¿õÏálÊ;(˜î‰Ñ?sC`Œ1ƻѼŠ«àßÂ= z Ô‘”[ ‰KWL|~5Â+ÅŒceœP3ÆcŒqRÍZßÒÎèzç\¼vO8\ ÌåH=ò- ¾;óL\?Œ1Æcwÿ`Œ1Æcì/’p0ÆcŒ1ÆI5cŒ1ÆcœT3ÆcŒ1ÆI5cŒ1ÆcœT3ÆcŒ1Æ8©fŒ1ÆcŒ“jÆcŒ1Æ8©fŒ1ÆcŒ“jÆcŒ1Æ'ÕŒ1ÆcŒqRÍcŒ1Æ'ÕŒ1ÆcŒqRÍcŒ1Æ㤚1ÆcŒ1NªcŒ1Æ㤚1ÆcŒ1NªcŒ1ÆcœT3ÆcŒ1ÆI5cŒ1ÆcœT3ÆcŒ1ÆI5cÿ@Ê`Ì}}=Võ€”kƒ1Æcÿ_’jÁ&ƒ'MF7Nq¸o«0,xéILïj{[_5¶×6å¶ÁcŒÝ¦Iµ2è!léØxìy.âÚçÞ÷íFAÚÇæ(´-Çéº;voÄœ ×øæ‰\‡¼M¹m0Æcÿ¬¤ºïK+Ñcï Œ˜þü^\ƒ Ž€Ôë^lø ;v-\ŽCeÄ5ÇcŒ1ÆX=Ô0d4õšN/ô!©Ó:¨>KúÒôy”ñÙ(’]7} a3„¾,¦&Uî EvµÓ)üè®×vÓÅ""3_ø‰^àGŠzó’8¢g>ú‰Ž'ç‘Z_;—R:º¤KƒéZ ‰;ûà%åkj~¯§¼3Ûé¥Ñ^$oë²Z)³ªÇ
:VADDÕGéÛÍ¿ÑåJ"SÑiZ?ÙÛRbÊ#¶oa´Z?Êzý
Qù¶ád[û;‡Étˆ.<×ɲnw÷~]È(%mÍ Ô)ûéÝi IÙÆò¶]iþ¦£”¥³ÔaÎù8R×_@¹Ó‹·PL¶Žˆˆ ±´cÙ0r“¶a{‰l«í±_ÈüæÐî2¢ÂÓÈ«¦ŒRÏi´½˜(sÓ(r–Üžmƒƒƒƒƒƒã_ ×8pc&ån‰$ÿÁ ÒÕâŸhÞü ”—¹™Æ:KÚ6sAEžÁ]¨×ÌmTDE´mf/
£°°0
ñ¶& @œhäÆL"J£íKgÒø ³è¥W‰(“6t"¡f^Š°•”LDÉŸ/¢Y“ÆÐð;GÐØ»gÐ]!ÖâË# ¤gãˆ(ù=š5v$ž´ÞÚ_@Di´þNGñËQfûÈ_HK ´zü º÷“L"ºHoN A ¾Í'ÊÛHE–GL Þâhµ~Ä$Õµëžò!ÍŸ8–ÆN^@oF—Ñ9Zª_ ©Mý¾„Èt‰¾~~M˜<—|œ*ë/K°£;ÞM"ÒÅÑçOO¦¡‡Ñ½+öRéèð£$»½D¶ÕvÙ/ !—1ŸP&UÓ¡§BI)ó£û÷¨Éœü
´Ú0 Ž¿-©–ûϤÏÏåSyQíXþíÊÍ¢/ǹÜðBTýÖSåÐú~ªë¾“ú?J1Dtie׺;”Êpz%‰ˆN€xºƒûÉ‘ñýYT6‘“ÊEl¯¶mw<†?ŽE‘ xþÈ3¶i¿ Á¶^þq#†Æ.BGªñÞéMØùA4ÂîC‘¹½ÛcŒ1ÆnBRÄÈ·?ŸãO Çž\hGgCë U
ÔHÍ×·i!º¬ÄW/ÃÝo¼‚ùkö#Oæƒû“øô«TgnÇ‹Ÿ,Ç ¯þ‚-ÆåØ/E^Ǫ,|2ê{d™nÂZ÷]‚7Ûb²Á3^Û]Ë°sÚNdˆLþL"Êl×Îåi±o·VeÊGô7§AëVã¿kÊñ^T&ŒîCà
@ßÞ‹ÊÜ—6½Œ?^Ü_d/á£èth]†Â¸ÖEÔµK?\†ÿ-ŽÆ!çÕXÿs,ò 6ðñGÉ°;ÃÐnÛýë¾xõ»uxÄ Xàt
>~Ýeh‹ÛTpÀÐ7vb¥ÿnÌìº q9À Ç#që×øpwæì.¸v'ý Õ6cŒ±ÿÇ®ëhí4òJÏûž¦yJ-ŸYGÐâ½ñ{*Žb·/¤ E[;o+(`æGt,»fð4CÞ0–\$uÔM\³—.•[¾.KÜCk&ú7¦L샊3ú‡ú]È5X±Ë>NŸ>N¶B—ÕJ™ë?øVÿw¶#¾#µù$Íó”ˆ.¨:¼å£´^?“ÞúR*jyÓRQÊQúè.ËÂM=¤i7’vT¥¼ÖmÃê)|(rÅN:—o¸64aqêZ?Á½îÁD©
yv3 ¾¢®™ÆH%ÉûhY„•øí%²Z–çIwy… ÆtúzªW3^6·M²ø>¥S mŸâQ÷[™?-ˆÖeo¤¡öÂmÙ6888888þ!Ôüã_r_>ÏžMÅû%Sá4ìG”qycŒ1ÆX;p0ÆcŒ1ÆIµ8|—š1ÆcŒÝ$ÿ®î Œ1ÆcŒÝÜýƒ1ÆcŒ1NªcŒ1Æ㤚±ÿ?kØt‹=þžKê —¾óàíë áï® E þ1ÆI5»Áì RŸþàf„õéÈùOßš6ÃÐå¡oЧ6îêƒ:E
¶°í<n¾.O õkÑpr²ú{+TÖ^‘+áç£Eu¥þ ܹÉÜaÛ¡7l¬$·= ¶°í2 î~.ÿì‹Œ[ÙÆn‹ö,…Üo:‚§oDAŸ…Ÿ!bê3ðpªy«Ô ® Gè´gàæ àƒ)cÿb²ærm™ûpøô g/OHŒ¥±(8ùr³ÊêNR?øÜó&¼½>°2ú1\J¨;‘„ÏG‡ ý RÆ’SÈ;öòó*ÿáOH
ÚúA)QÀìäø÷Ÿ$Û¥žåPÜ
ß Cáàê Œ0ŸAÁɯ—£¾¡ÄHâ8 Ç? û¬×w8æ¿e½ZGÕ§qeçH¤Np±ž|lø ¬a7à9ø¸¥#ëÇ÷‘_¢¿iû—Äi :é‹ÒŸ. J«ÿËû´Ä%Ágîz.î܅궼ÑUÌñ°]Ë#@êØ ná#áìk« dìx•¦[¿Éåþp 0 ÞÁÁPHÍ0ÿ‰¼_"?·ñq£ Ž ·¼9÷CÀè»a“ÿ3ÒOÆAOVÛØB¯©gSòö…|Òt˜0º]_@åçÿã¤úڙʮ§ÃN̨$$¾pîs ¼Çª ûî-WÕ %dR@{~-®¤”Ö <Í0WV]»ÂW†>ƒÐþ¨Šû )y€mÄýð ÿ4Lß¿Â
Ó?¸êÌÐ'¿‹øO˜KÓñ÷®I{Õ³$XÁ˜¹éæäð‡sÏð+‡vÛû(mÉB°
„sÄ4øtï ãߺ^bV½
ºÒ*@¢ÞȆ¿”š:E¢C{T [}ƒ õß³I G!è®PÝðŠ·v¯.¾(>uUÄ]
²€%è>ª#Š~~W¯ ÔäPõy]#òºu%á“ØîÛlø†÷‡µ ¤Í@Ù…-¸z>ÆÚ|P>à䕤 Ð 2æ$ÅåXÖW ÷óà… éa(9Š´½_@#6ÃÐyÖBØÔ1÷œÛóçõQ‰ z΃o×^P) ÆÒ³(8õ5r3Š-Ëìá0à øÀÊÆ “: E§þ‹¬´BñwbÛ¥žÀý•-¸z¥öÿP©ïçH?XÛÈPª5ˆ½mUø#ðõÍBÁ ø$œn(§n¯õëþ¸ëA89XêÙ\•‚’Ø/‘™˜“ØŠìá0à)øuê+•€ †¢?Qpj ò²Ën/¯…_ð,dRÀ\‚“Ÿ!;½øÚ4íR ûµÿx‡†@!1ÁP’ €§þ÷‹6ì_¢(aÓm¬4ÿÃ¥ËÍ´a‰³e¿ë•• ú²”Æ|ŒÌLµ¸ýKŠ€Y+ࢴü×ýîÍp¯=|¥½…óQñmKj¬Âá9²øµH·Aî7PÏ k¹NEè¬'`m#U]FÑ™ÍÈLÊlØ–[, ©Ç õu@Áîç‘W¬½á6/ª ¶¶îV]áÞÑÚ?7!;% ªÔ ëûž‡G˜
O¤Á,ö˜ ¢žE•YĹ Õù4jcn“6ÃföÚSÏãâù¼í›Ô‡põÌtë3 Nç^GQ•™3 Æ8©®=3ë 0Hm\!E4šz‰•Ìr©&©#ä
- nñ ª ØÛšÓ—!
[Žn}ÈýyJŠŽ> ®Bß깚`Ì;‚Js } ÉO³œ|$îp
tåí@…Ž XÁ¶ïJ„v3 (f=²
5ûL€ß¥Ò-AR¢å/Xw…[Xo é[\É‚Ao‚ ´‡PZT³¾
Øö_ÿÀ<ä }ee@é+;tª¹+q
©ß_†TâçQËàÕd¹m`Ç*w1¡äÔGÈ*` 2>cWA¾ïE\Í®+Xyw…Ê´ é¿ÇB/8Á¾Û xŽz† «W.î^NûÔóu™¤vapè A}åjC~k€æô2œ?M€, ~nðX;®éÒQüç'(ª*ƒI°‡Mèløz æâç‘/ònª`+ï.°ÒÿŠ+‡ba”ºÁ¾ë½ð¿
ò=Ë‘‘«©›¶ò,rbNAk´ƒ]·¹ðý ôÛ_EÚÔŽåq€Ó+б£Å§6 ¤\+ß‘ðqnµº_ˆÛ¿Ä^yÁÑ× ÆÌcÐ4Ùd¬a7p‚Ôل¬ürÀ¦'üï {G„Lµ¸ý˘†¬Ý/ ßu
BF„C ýrK 5u[ض„Zâç¡Ã©ø¿H8—åЩçÖ‡uóÓ¡êÂçÈ)7ÁªÓtø]™n RÓËE–Ç ½G@‰B¸Œ] %¨2%ç¿FfbÚµÄRLkuë.Hm “¦ºîœ¡Ï„º pr÷i0‹9&ˆ¬çÖ×Kܹ Õù4ÛÆfMQŒFh/ïEEßGáêë€â¤R~ cœT7qÎq†Žƒ»Añu–×®…-Ì#솽…î@U‰(<µY)¹0¬Ü ƒ•ÕH]Ý!•Ë¡”ë¡Ñè7È$€¾fv‚L‰´æa#2ƒ Õ0× ‘´ (Ì5!°ã XJƒÆŽáâ Gù©‹0 Ø €o¸ Ôÿ{W/× Ìò³@žÐ)¬I¿CwíÆ Õ©Q’m²Jd6Ö€. Ù ¨Ô˜ ¤¢Á}'³ú2
ÑÁÐÜyÓv |º8C{fÒÎg ”ggBp~Þ}ú#7'ºîîKUJ3â`PQ¢€ýÌypör@~y1·y¿{4äM-D{—¶ýš6Ô³(ÖƒÐyÖc° ˜R‘³g*
mmZýtÒní Lù(¿’í¿U% ‚žƒ§3„ü¼¶•V“„ò¬‹0Pg§ƒ¦¯Wß~ÈûåPÝ68‹â+±–mZj
Ç™sáâeui›ÊÓÒz ¶à`ƒê˜UH³ü¦<·Ža‹®íØ¢ö û—ø¤Ú66€.¿°É¿"6ýàæ]ìr\9[ó—…ú;ÇÖ ŒDì_€ †ò ˜• aTç º´é‹‘–Û†Š ‡ÐÁí<®üpz³Ê&öåÖêYÌñðšÂ½ÈºPsç=ë*ಾ=ûA™q :sëåÌNîr˜òO!/î ªu2XÎDÇAË!«^Œ”´rñm¬•i bÝ©:ê
À3b ì³wB]e‚ÔÖ J9 ƒÂµWŒµÜÄÖs«e{.hµ~Ä·±ºcrÔjžÞž8©fŒ“êF‡9H]"Ñé®ÙPeŠK1
û‰QùïHÞú; $¶Apîµ ‡¯€¤z Ò³«œ «N½ˆ¸x •FØ]· %l€ÐàÚ?øV¢è—gž§«Yê„8˜G€‹ÓÐTÁC ÔÆÕœŠš› Ý ä[ÞÃ'A^IP/©n1c‚úä×( ¿ Á³û@“~ ÅI‡P”™Ý¦?ËK  B9Š³
ꬦ|”g—Ã;¨ ”²è&]ÒæBg¬m,=)Í¥?#y×aˉ©1“ZÚPÏ"UŸEÚ®UPØw„c×{à=q9°{5rŠtS3ý‹í€
ƒÇ€{àæÛJ+¦êjH$€^&ûkE3æ ,³ ^A]¡” jq›ZÙØ@€åD+®<-¯—ľ3¬PŽ¢¼’fOÞ¢ö cëû—ø†oI¢Èhj¾nŠçÖÊ,ö\pSŽ æ*èµ€ÔÆæÿß0’Œ±¿’T zLAÈ„©¥®Gâ‘è›= ša®LFÑñÏ`ã¿
Î; #;¤-„VP¨”€¹ úJ ‚#Ö
@Wc½;ÇšØ÷tYa9‘ ú8Œ9¿£T· Ρ ].…{ˆ ô—÷£²f2A @â?ÞA^iÃÛªdªlÓÃgæ²h¤~÷'¬; ‚KÐx ŸÂ=HùmÔZs{ÞŒmúoýùË -U73©D€ ºžÅ¡º’TèJRQ‘éÌåðDÞÁÄ[ú¤~»µ ‰ÜǾ_û È=þ ÊJ« ëpø™Ñô_ nd› -BM–í$´µ<í暶ßÂ^,j¿h}ÿÍTƒPÙÙ@Àõ#Æ‚ Ì ³¸jm ²æëP€Ì;NJk`äGè=²þ廉ëÝquû«(QÏbŽ‡æŽµ ]žB£¥kžÌºÞ#Œærh«ÁÊR `„ˆ6&ª ŠYw‚©p R¶ý©+d L²!>”‘݆c†ˆe‰(³¨6³Ž ‚ )@zcœT× lî@@äTÈS×!ñÈiÄ I£Ü,êJÀ=¨3d©1–?#[…ÂÉÐǧÖû³2ÁT–ŒŠ²–ÎIÈO*‚Kçñp.QÀÙ*Ù é×Øæ²xT£?lݤÐ]IÿëÉŸY
MگФý†l§ñè<ý>øwþ .ÆæÖ;×`2;XúRýs\ªÑ v¾î
,Ý? õ€ƒP–Ñr.mõîÛývÿ¨]Ï …Ü{<|¨ã@i_HMMJÜÖù4§ùù´[û‘yÁÞE€îü6ä¤dZ¶…Z½××+™`6Ù@Òh›6½\`çå”'‰ïb#º<-¯—¹ü"ªÑ öþÞä7ÝæEïì_â“ê u€•ƒ©äR@°ò„ÊY “. Ú*¸ù´Wû1棢 p
âý¨¨ÔA°êdÙåº<«
Úb5 ¯J¨
¶PH.£(%§nynàa…ò2¬:Mƒ¯“¥NYºIÚ¹<-Ý ¬mc=–!H²…9…0+;C^ï&¯øý¢åýKüÅh)Ê“®ÀÐ88ÛD~£yPÅqäeMAÇ~Ï¢ý„Ò
)”ÞÃaF#i´¶Õ.®*ZãD8õWé$N°R¤ 0YÜ RÒ¡áðÖJÈt&À¤†®¼&3 õ 1ÇÃZ6áèW
ƒÔöaÓáéPŒÂ£§,Ç1åA
ãÓàÑzV";³
Êyð°)Bþ É–ŽbÚ˜ˆiHÔº ØøBåà•[8œÃFÁÞ&ù¿nFY5‰>&ˆZ–˜2‹ióí´^wí:Ve(Í,àþÔŒqR]—\Ùx: Š^è8©WÃï
?Åù݇a€2U8GŒ…µ€†â8äFmEîµþƒ&è.C’|>:ô|Á= Sé)díÛŒ¢c˜*Ž!;uB‚ªQpæ\£»`Tœ|—*f·Ûd„X0ÃT~¹ÙQ€Øñ 9$‚ì»?•¼æŽi&Ô±ëp5µq_?ªc?C®ËCð¼ã¸R%4‰Q’’3U¡âø«HÑ·o÷Ǥ Le±Èýý äd·aÜZc)ª‹K[»=(¾žM(Ï,„k°€òÌÆCž)!·
…[·‰°RÉ è /ŠCîmõ¶©˜ù §»2e ®½_¬ÃÃèÒ0¥¾óÑõþÞâ|Ú©ý˜sQ° dƒ¦ÃsørøJkî‚V¥£LÝøaU=ªÎ|Ž|§á>tܩ²MSë%Õ¤‚møCp³–‚4—Qxx 2kGnh÷ò´DƒŠã¯à²æ~ø„ÍC§) ŒI()¯nó~Ñòþ%úV5t©ß£¸÷Rø ‚²ß5|–Á\Œ¢è7 ½ãx
x
®‚ †Ò¼š®tý…t³ûWí_kÎ#ãpŒBDZ㠳U—6¡ørvÃUÿõ,ˆ8 ’ÚÜ$è‚F# 2€ †â?‘ýë7ÈËÑ´¡ €»0ÆcŒ1ö—H¸
cŒ1Æ㤚1ÆcŒ1NªcŒ1Æ㤚1ÆcŒ±1Ys¹¶Ì}8|úŽƒ³—'¤‚ ÆÒXœü¹YeuO6JýàsÏ›ð²køëÊèÇp)µÂò Á¶áóÑ¡G?¨”€±äòŽ}ü¼Ê¶=!)ó€sïyðî +`*CáŸ_#çJžåikY0:Ü·
Ž©+qáøËgVáè0e)\«¿Cž=¨6ògŒ1Æc·*©–xÀuàtØi¢‘•ƒÄÎ}îƒ÷Xtß½…⪚Aƒ%dR@{~-®¤”Ö$Éf˜+kß¾'…2ô„ö@UÜgHÉl#î‡ïø§aúþmŠ}+ž`Ç!«X‚‚ck‘^.…uнð¹
ÓR\¹ª¾þ7RO¸X7ùŸHûùWN¨cŒ1ÆØ-NªÍ¹Èûå)ä›5‰r *4Þp˜Øö
WÕ¼ÆU°‚La‚¡0š’&Þ„&õƒ[Ï. Ì
H=uÊ
°žù¼ºø¢øÔUQcz
öCàd‡Ê£+‘y© 2?pùüûANæ^4x±¬à ÇA/Âß;¹?‚â*~÷ cŒ1Æ»yšïS}-¡ RWHQÆP/%w€\j„Yê¹âúü\PÁÞФ\†4l9z>ð*<RPR (|:A&ˆ)¢ ™[/¨‰’¬Òº2™KP~9pê
«z3ì`×ïE…šP¸ÿ äðÛcŒ1ÆØÍ%ꊇaè8¸ô_GayÝ]_Aa ³Æ»ao¡» PU"
OmFVJ.Ì +7È EeµRWwHår(åzh4zÀÅ
2 oõ&²2{Àœ®þÄ&Õ% xB©”z˧òà§,—¡âÈdd”ó›mcŒ1ÆØßT ºD¢Ó]³¡Êþ—bQ?¥òß‘¼õw HlƒàÜk!:_Iõ¤gWÕ›RªS/".^C¥v7q…Ì%çQåÐ v}çÂ5
Kõ¼•cŒ1ÆØM%i1¡ö˜‚ɳ¡L_ÄèÃÐ5{WÙ se2ŠŽ†Âj{8uî ÒÂ+(TJÀ¬¾²$XAa t…0ŠéP
Œj5 q²Ü‘¾F
™½3¨ÜÁ6íCÊÎw_Ý &=
7GoeÆcŒ1ö÷$Õ‚Í ˆœ
yê:\:½¨'
ÎŽªS ®¬ƒ:×õŸ¶
…“ ÏN…QTß ‚±ð ªág '\ë=-q†C° PzUZj0=UÇ!sÏZê{ ÃøypPñpÜŒ1Æcìæi¦û‡6=gÁg‘~) 2Gÿº
EÐVh@°‚MødØÒ ©¨)<` :n*5Š.ÕŒêaÊDal"<?„N}ÈËì"æÁ‰¸š˜%jä õd§NDÐ gᇠ()“À:x&üܪPràК›¸<ÐÆ!ó·m°žz ‡Ä#þÀ ¸ƒ5cŒ1Æ»eIµÄ6ž€¢:NêÕð»ÂOq~÷a „LÕÎcác `€¡8¹Q[‘{?µ ºKë$Ÿ= ApÀTz
Yû6£¨¢
ÃÜ‘e‡_Å•êà3à¸Ë³ú"
®CvººÙŸ™KGZL?t x?|½Ï#-[Ã[œ1ÆcŒµ;à2cŒ1Æû+¸³1cŒ1ÆcœT3ÆcŒ1ÆI5cŒ1Æc؈gí IDATœT3ÆcŒ1ÆI5cŒ1ÆcŒ“jÆcŒ1Æ8©fŒ1ÆcŒ“jÆcŒ1Æ8©fŒ1ÆcŒqRÍcŒ1Æ'ÕŒ1ÆcŒqRÍcŒ1Æ'ÕŒ1ÆcŒ1NªcŒ1Æ㤚1Æû?öî=>βÎÿÿëžó)39Ÿ“6Mš4IS(mi Tz JA ¬[TX¿Š®®Š¢ü°è~WQw¿¢à~ý®+. VWô»â"»œê¯,§¦ô64mš4§I&“ÃLf2ç™û¾$=§í¤´¥ÐÏóñ˜‡6½sÝŸëºï”÷\¹æº…BBµB!„ª…B!„ª…B!„P-„B!„„j!„B!$T !„B!$T !„B!¡Z!„B ÕB!„B¼·™dNƈ¹êæ._‡;/E“
´ãÿó?â¦cÅFš® jÛ7Ù÷f/Ú9½RŸ*ªÐý;‰&´s|WœÇs !„B¼wCµSñ*–m ¿¬£¢’ îbäŸáóN ÎUT|øÛ”å ûÝ‘ÍŸb_÷äÔ ®–1çÒ˱[!heøÕŸá Ž içB东škoÆéÿ#½oì&¥Û0;]¤êô
FWVƒ-/å —cÈÛ@íuËþaÑDê=s.!„Bˆ÷n¨6”P¸ò6rb›xq?iC%ùK?Bùz;Éß<ÂxtzöR±b2B¢í{ ì
N‡d
-=”º±6|Ž†å5Dwÿ„®ap-úK*oøkÔ§¾Ãè¤zÁŒÁY‡Í&ðæ ÷Ï,5RO{ -Ø‹*÷’B!„„êcó¢áÿø,~-3 ”w3+ÇsÓåxÜÆ£‰éPmÃdQIv DNlÇXEÑâFôÇén}ƒ´£i wÜGYc%ã}Ç,™0V}‘K®Ñèúå÷ §oÌŒ¥êz*¯!·¤#@z”pÛ÷éÚÙ?ÕŽ¡ ÏâT6_†Ýª“ î`¤õçøúǧú¡¸ñ¬¸ÊšlN
†Ûký)ޞѩcL
ÔÜùÖ©³}à Š¦+H´~‰·Ú†Á¹šwÞƒóPi¾GÙùÌ›'kCþT=M—a·) 'HMtÜú „³¼BÇÖS|ó ºL=ÐöbûÔy
nrÞEeËrœz¢Ÿ‰=¿ ¯ƒŒŠóJjoû® ðÖŸ·‘ÖAq,£æ¶Ïá:ø{_m'cÌò\B!„"‹P
p8P(…#;*íš<˜Tc.fK‚t*sLŠ½· bÛ`lz…Ë,øþø8q˜[Q‹Ié#•Õ#–ºûh^³Ý÷¾-{‰Ç’(¶BŒáÀt0wâ¾bóU?ÂTpÔßNÅúM˜Ÿý*}ƒQPlØÊ›±«ÏÓûÜ.RJ î…Aé5Ÿ'ýÛM ‡2éÁûô—ñÞBýÚ› ÁH:ZlljLât?u £!ük lÆš ä¬ÜÄü&…‰í?Æës1ÕW¯ÇkGg·üå¤õ€ž ¹6\˾NÃÂ4c[ Ã;Ã\q#Õ˾B]ò~öwŒ¢G_£÷¥š6|šyþ¯ÑÙ‘"Õ'ÉOü‰}[ß"£g{.!„B‘}¨>ŠÁ³š¹W-$õÖß1:‹ -–!gõ#\¢€ í`´õ ¼]>4@±a"A$žÆXXŒÑlÆjN‹¥ “RÙ$5S å+—bð?Iû³/œá³sŠkù$¶?@O›
ä›ò¥Ëñ
mæð"Žè^‚ý»QÉ€÷ É/ó࣓" BµDÐÉ ·üC‹‘šˆ!I:3sÉŠór*š
Hîzƒ;¦gä-VRW¯?aГ ƒqz#]COÇÑ'îÓ×£8WPÙR@xËè;0½ ÇïE/}œÚ¦Ë°ìŽ¤¦“ñþŠ® u4]ñ%jò#äV0øï¿'’Ö³>—¡h#-7_‹y¦N'þ̾_ÿ”HF~°„B!¡ú踆±àzjßöÁbßÖŽcf+õÐstþës€ƒ«ŽüËîa0Äï§w0zÔ‘)¢_ew»t$CÎ1!í£,¼y=–£¾V÷/§þOl3ûþí ¢Îz\6ˆmÝ6c ž
þMØ 1î 92¬ú
†(¯kÄjÚ’p8ígu`ÏBì„ ôûN³+ˆ×UÒ0ÿÐb’cÿñ9z‡“³;—bƸú1–¬>î/ce˜ L[’ØÎ Ò_ù]ª”Øþ þñÙ}Q þ‘Îÿû2ÊLŸÌTÃ$d:[!„ª Ô%·P㘺 £ã¿·’:i:ÔÐ"Œ½öœÕ›È_0‡þÁ½è‰Q2Ø°Ø …HE %‹ÃÉQ2hÁÿ ó÷[P céFVjô?ó "i@›$™™j_ÐÏÅ~!:g¼
É)¾OQL(hè§Ý‘.El×?°ÿ€ej=E*0» «(
aÆ_ú.ÃÁc£ëj„£Wå(ÎFró ƒî}8ÚM$5‹ÈLžd=¸®›K$„Bñn
ÕŠó
j®¿s÷èøïm¤³Ù®X9öY2z¼‹pŠë`êÞ:µn×Ö@^¤Ú»§×ñNL `tÆÐ5d ŸøÑÙ0ÖE4
K°vožq¶Z í%Îrr*‹QF¦–`,ÁS቎©p~Ö÷½K£ª€ÙƒQõ¨@©EºI±Wi ʨÿù[Gèdrâ4§ÒhX1YN|^6ÑNœå¸ŠŒ$žb¿ls
e×} ×ø/yë•U7œÚ•{yëå]S×"‹sŠþR–!„Bdª8ßI.;èÝçÇ”[}äÀô‰É:6œ- Äî!6E·”àn¸•"{˜±}ÓkˆÕFwuPrÕ½Ô.µ0쇜EñÐA_‡7û‡¥¤»ðmÛMþªÓxC5Ãû÷§Q,ùX Œu
¡EÞÀÛñA–|‘yÚSŒ
Øë?L¹'Àè³[§>y¶Cµ #î ‡–)o
3wb1v2v`mò5†½·0÷òÏ3GÿÁI#Öò58€3ÙùY‹v‘ÈÜDÞ²QhÜCÚ‡ÍÒÅhç Zt+Þö›hXô lÿŽ¿¯´fÅâ)$Óó<p³ìs”»¶sð©ç‰Ç ÷åKi^û?¨îý2ûÂÙK–!„BœÀ<|ÂW
…ä-û W¹
ë(n:êUâct šâÄ1g % ¯§¤i5óbÍìcäµÇì?´gµŽ:¾“Étù‹>HIÃRì™ ½ôcF3¬V#¤'º‰Ž 3ë :êØ6ci¬å+(j^Gáü+ɯž‹)ÙIÐ;ŒFš”·•˜RKAËM×/ÅI'þ-âõ†¦šQœ¸×ãQß`¸shz6»˜üE«0¼ÈˆïH°Tœ—R² ‚ľçÅN–52c^”¢¥7¡ ¦ s|/¯ Mx Õu E‹ÖSTwsƒÝ:ð £#ÑÙ]©Ì(ÑIÎyk)n| 5ó1Å÷ôú§ú>ø:ád.9µë(i¼š‚ºËÉÉDßV"q cÉíÔ¯ª%´ù{øFScê$SzeõN&÷· Ys~ªsi 2ñ Ò±^‰8²úC!„#$·Ávo éö;H¿x =!„Bˆ÷“ Á¹bñ` ÎÔ ‰xÅZIî¢Û°§Ûðùc2ŹšwÞƒóÐ|²ó™7Q/‚¾ !„Bˆw$T+rSzù-Í©ÁlTÉ„; îù
ÞŽîã Îòöò6P{Ý2‚ØC4‘:'ÕãÛ8ø»ƒŒy¬½ŸÒ»í&oí7©™Wxx_<ÀÄÞßâmïÈîqíïDßÍÕ®øåóçc1jdÆßdøõÁï ù$ªâÂÕò1æ\z9v+d ¿ú3üÑ#Ç«¨øð·)Ë9¶ùÈæO±¯{òØû#wsoø+ÜÞo²ûåNäí€B!$T Ÿ-=먻õnÜñíø^{šHÌ€¹ ™ »ñÝ»_ˆ%Œ‚!F*sò!1¹ 1ž¢óåݨ¶Ê
T-‡ùktlï¿ð£â&ïêÿ—¹Õ>†_þ;‚îK>Få_Dêoñ‡2€kÃçhX^Ct÷Oè×¢¿¤ò†¿F}ê;ŒNNÏ×+VLFH´}ƒ]‡žŒ©¡EŽ<R±Í#ч¨¸ä,@F~Ž„B!¡z¦–KþwáμÊ?ü˜Pb:E÷·2vôq†<‹7RÙ|v«N&¸ƒ‘ÖŸãë Ÿ
cŠÏŠû¨¬©Áæt j¸±ÖŸâí:ÆÔ@ÍQ`j²øæ'(>”{ ¡íÅö©åÖzJ–ÞH^E ö F@ŒÈÖ‡Ù¿{ú‘㧫g6RÃÄF{È Q/ZÉãÔÎ_mW?15Ës®ælû~:¶fŠç:H¼ùc»|è@4˜Æñ‘/QÒTÅèë=hÆ*Š7¢Ê+oí›z³ Ø0YTÒ£ÝÄ3=õÑŒ½å“TVzyéq,+?Cžü !„BBõ ì )ª4“Øþ „'‹£NÜWlb~£J õGxƒ
ŽúÛ©X¿ ó³_¥o0
Š
[y3võyzŸÛEJÉýð/(½æ󤻉áP2=xŸþ2þÂ[¨_ÛBxó#øi ôäèáP©8š)jZûEßV/锊bu£Ç¦Clõœ1MÕ@1dß÷ljβ泥Pcñ#>5@8yÅéA·×ávAlÛŒM²p™ß '0s+j1)}¤tÀäÁlÌ s1[¤O˜ÒOÛö mÛt0ÕPµB~ˆ„B!f ÕGRÄFÆN:ë¸VPјObûô´yÑÐà Jþ·)_º ßÐf¯Žî%Ø¿˜ Xpß±‘ü2þÐ8:)Ò¡!TK ™ðñàÉÖ§ˆwÿ™À`âÌê9“e+&ŽêPYe&Õ±„:Ûs¼ffÕ÷“Óã]„'¡tÑ܃¿# U1ºÊ°š´EÅV„‰‘xca1F³«9E,–‚‚"LH© X\h± 9« áôh£Oàíò µìEž$„BqÚP®¡Ÿ&:Tš"ÚúUv·HG2ä }BÏÑù¯Ï ®:ò/»‡¹k ¿ŸÞ·5Û/„Bq‘…j-î#{a Š×w–ç%õwÇDçøoØ¿¥L&Jj2ˆª]ÈE먣ÏÒõëç0: 1’¨¦U4Üv;zÿàÔ sb” 6,v+h!R@ÉÅâ°@r”Ì Ÿ¾ÔÐ"Œ½öœÕ›È_0‡þÁ½²Ã‡B!Ä Àè _MtÕ±5ß@ŽU™ñµÐ^âxÈ©,æðÆ< ˜è 9Û-!´VL–3{ ͬêÑU4
091('i0=J||€x(pB ¾Ðú~„Šõ“Œ;È_y3öÔ›øz¦–ðèñ.ÂpÔ-Àt¨h[yì&sÒu>ò| !„BˆÓ1Ý@ѱ!oŒ±WŸ¦ð曩ÿ “¡¶×ˆDULîZ\Ž} mo'yoÇiXòEæiO1 4`¯ÿ0åž £ÏnZS¬Ì"WF»Hdn"oÙ‡(4î!mÈÃféb´s0«ÙQ=›z %1 ††ë)«N»°0Ö5töÏu ú
g%vOö¢ò›®Áí ÀÿŸO0Ÿ.F `tW%WÝKíR Ã~ÈY´ ôux§ÏcÃÙòAÜé b“QtK î†[)²‡Û×w¤£›Çƒb,ÃlÅVŠ=?šô“ˆ&å§J!„e¨Þ ·‡ƒŽ6ú{öÿßQ*–¿ŸâUŸ§\=ÞOhßÁ©Ù]=Êäkß +ñ1*/ù4uP'vá{îg ÉÚÛDý/¿HÍŠk˜»~ha¢û~ÌøA²[y1›zRD·ÿ3þ¼OPü¾¿¡XŸ$Öñ¿ teb/´¾›±_r?Ín2á^&{Ÿdÿî-LF^Ø’Ü÷ö›?Ɯşdþ¥ [ñ>ûcGïQmŸCþ¢õT8,@šôøn|/þ+¾£úeÈ{?õ·lÀrè sþŠÆ9 v‹¶Í²DD!„ ¸øw
!„B!ÎiÈÛ@íuËþaÑDê‡tÚzÎâ¾ ëÉö>3ä®bî
…ÛûMv¿Ü)³B!Ä™‡jųŽº[ïÆ ßŽïµ§‰Ä ˜ šÉ±ß¡ýB4RO{ -Ø‹úvb“{%Å!ÂCFÜWa{ëwÄÕ‹árŸ½1|/Ö£Øæ‘¿èCT\r #ÿ>!„âm…j%—ü+îÂy•ø1¡ÄtŠîoeìèã xo¤²ù2ìVLp#?Ç×?~$wgs̱'ÇTv;
7Ü {¾Å¾mûÐ «Ypç=8 â{”ϼyb3¸ÉYx•-Ëq:Lè‰~&öü‚¾¶2‡OfÆ6 ¶Ðqð
µ·®£(ÿôNϤ«©øð·( 9ê‘Û–%4lüLo|‘½{üè¦jî|ˆëÔ·ßüÄá'çh=Ðöbû‘ÚÊî¡åãŸÇdm²‘7~Â`ïÑãsšš7ž÷QYSƒÍé@Ôp;c?ÅÛ3:ÕNõhÎ,Ç3–ªë©X¼†Ü’â©uîéQÂmߧkg? 8–SóþO癪G‹vØõ/ tôNýãlÖsºû'›ñÉŠ{Ë'©¬ô2òÒãXV~†<ù÷A!„o+TÛRTi&±ý?'NKœ¸¯ØÄüF•@ëð õ·S±~æg¿Jß`4ËcŽfÄ\õê¯[‡¾û:ßÜ7Òât?u £!ük lÆzl¸–}†…iƶ>†w4†¹âFª—}…ºäýìï˜XÆr
ê
ˆïÙJ"hd,ø!JæWá íÎþ×ü™ ¼Oá-Ô¯m!¼ù|4 zrôØ`ÙÁÐÖV™ r~”²k?Gêß¾ÁHXÍ®fņ¼»ú<½Ïí"¥äá^ø”^óyÒ¿ÝÄp(“]=Y¡KÝ}4¯YŠî{ß–½ÄcI[!ÆpàðøèÉ^Æßü?ŒE'P7Ά»¨¾òKhã_ ߟ:‹õdqÿd3>YIÛö mÛt0ÕPµBþqB!ÄÛ ÕGRÄFÆN:Ó§¸VPјObûô´yÑÐà Jþ·)_º ßÐfÒÎÓ sd¥{ãg¨½²‘Øßà`ûQË´©‰’¤O’‘ç
*[
où}‚Suû½è¥SÛt–ýÏ‘ÔÀw%ùΆûèLtù¨l¾{k7Ѭߟ" BµDÐÉ ždMõäÆîB&ƒrïø(enFÂÁìj>ÔNt/ÁþÝSí,¸ïØH~™h =›z²CLu”¯\ŠÁÿ$íϾ@òdï2T?¡ƒþÌْç !„â,†jt
ý4ÃàiÂNˆqïÈ‘ãT?¡ÁåuXM›Q³8&u(9—ÝÂ2±_¡«}hÖñFñ,Ä®˜1®~Œ%«ûËX&$53¶ÚË1?ÃDtêÄɾ×I,[M~Ž¥Ïé`ë É ØœN‚YÖ|òv NûYOqÖã²Al붓j@±7Q²âÃUÎÁjSPãq H™Lgµ ÃlîŸó0>B!„³
ÕZÜG öÂ<¯ïüÌß…^e4yEË>MÅøw œ<ñ¼§(DQÂŒ¿ô]†ƒÇ†c]Ê Æò梸ïfÑ'î>öûç”â @G £á ìF¡¢ë (³¨yÆ}æô3ŸT=å÷M½™B?ÅA†Š×•J÷ |¯ýÁ(8Z¨ºîvÌg½ μ“2é,„Bˆóhæ FulÍ7c9Zj¡½ÄñSY|$|KðTx`¢ƒd&»c‹íÂû§¯ÑÓã¦ô†‡¨ªtÏjÓ¨*`ö`<î/µ‰vâ¸qI‰ õJ„CS °s]F^Î8#Ï?È[¿ûÊôë! Œ`w)V EI%Áà®Àtº“µVL–3Ûa9›šg×`6õœ| õXÑ8–LÅŒoÃÊp($÷þš¡®·ˆŽ÷ îšzp–ë™Õý#„Bñ2ŸðU=N|Ü€§e¥s+!£¢ØKpV^EÑ QßZj„¤ãJJÀ®M¢[ç·ô^*JŒny’@8
Ù £8q5®Ç£¾Áð¾N¢}$Ü×Q¹l ¾Îä1 5”¼UÕÔaL § waŠx`==BÒºœ’–ëðähhŠ
³»šœêK°ÄzH¤ Xëþ‚Š²_{žht’Lb’L"DZi¡¤©†dç¢É$ªéJêWà0NÁ…°™¼šùà}žÑ‘# ®ÔužæUäæ›IÇÌy È-Î ŸD?º_ÓËYŒÅä/Z…yäEF|á,jÖ Ÿ“´“U=ÙŒ¡6AéqâÞ=hU ¢¢©€Xçv™#,3æE)ZJqÓ
jê1Ç÷ðúÑH“|p2—œÚu”4^MAÝåää@¢o+‘„‹Üå !/ùŸx;úŽ™Ö5yÍWa{‰±@ ul71ã\ò›n xÁ*
jæB¸›P׫„CÉ#ߘ%:éÂ9o-Åï£ f>¦ø^‚^?ZVaï45ǵمÆSÕC6c¨£Žm#0–ÆZ¾‚¢æuο’ü깘’½Ãhz„˜w ¥p9Å‹n¤¤i
…u
c„{^a";‹õœÁýó6Bµ¡à6oý ”-X†Ý†Ü%5£Àñ#³ÚžO!„Y}*„B!ÄÛb!B!„BBµB!„ª…B!„P-„B!„„j!„B!„„jq~(œÍ eÎ¥5ró!„Bœ×Pm*Æ5g NÛ¹>‚±ânZ>ñMKç^¡ï¼õý hÞ,¼÷§ÔU;§¿àµ`=E•çà1îç¨æ‹ùz]D}B!ÞÑÈ7ãWmK˜÷ÁO‘ï¶ Eû˜<ø ƒ;þ›XjöÛZò6P{Ý2‚ØC4‘š}•Y×£`tUa5XÐòr/ˆÐ÷¶ûþŽ2c›w%¶ôn†cEÍóõzw÷]!„¸ CµbÌÁê¶ßþ=ú|:–Â%_öW4UW³ÿé_1™<¿Ï‹É¾ TçßÓ (E ö"–~›ŒeäÏ/A x’HJ—š¥ïB!„˜M¨>D
$â›ßn‚ýÃ,øð]Ìmy™ö7ûÑűœš÷‚<Т]vý ½¨:`j æ·(°NµW|ó Š¿=Ðöb;j6ídQÎÕ,¸ó ÿÒÛ÷(;ŸyóÄ`m§déäUÔaÏñ`4 Ĉl}˜ý»§ smp“³ð.*[–ãt˜ÐýLìù}m d×cÆRu=‹×[RŒ =J¸íûtíìG˲ï
ð,ÞHeóeØ:™àFZŽ¯üÈ£.OW³ãJîüÖ· ¢ýõžéG€;ð\û8ó‹^bï¿ýŠØ¼Ã0ä^IANŒÐw8Že÷ÐòñÏc2‚6ÙÎÈ?a°÷¨šOÓ/CÁÍÔ]û~Ü96´h'ƒ œóaÍô0òòÿb /8‹kqúšÏë½jÈŸê{ÓeØm
è R]·þ#áìêÉö^Íözò_óx¯Ê¿¹B!.ÆP}4=ô
ÃCwP[{9¶ýÄUГ½Œ¿ù‹N *nœ
wQ}å—ÐÆ¿@¿?™ ¼Oá-Ô¯m!¼ù|ôT{ÉÑÃÿá?m;ÙÔo¥û©
yä_ó e'é‡âh¦¨i ìÿ}[½¤S*ŠÕ ›þ¾
ײ¯Ó°0ÍØÖÇðŽÆ0WÜHõ²¯P—¼Ÿý £è±ÔÝGóš¥è¾ðmÙK<–D±b ¦BmV}wâ¾bóU?ÂTpÔßNÅúM˜Ÿý*}ƒÑìjŽw0>
s«aÙÚCBLexŠ-¨C;IžÑ”½Ûü•XR;a)AdC[[IdrÈYøQÊ®ý ©û ìAí IDAT#a5«~)ŽZrrøþ량Ïý óÄ~þ[$æ}†¹«n&0ø3"™l®Ev5Ÿ¿{ÕAÎÊMÌoR˜Øþc¼þ8S}õzܹv”0z–÷üéïÕY\¯S9Ÿ÷ªBq±‡jH Ÿ€’
̈«€ê'tÐøˆh@ÁS÷rJóQüÃè¤H‡†P-t2dÂCă3„äÓ´“U=驉’¤3§ëKŠx÷Ÿ &N ÝÎT¶ÞòúLÏ–ú½è¥SÛt–ýÏ‘4ÔQ¾r)ÿ“´?ûImæsœ®ïŠkù$¶?@O›
ä›ò¥Ëñ
mæÈoñO^3zˆpg7\µ’Üœg©(®fÜŽ4‘žþ3[cª¦°6ŸLߢ3½¯™ÜÁøÁ]¨ÀdÐAî ¥ ÌÍH8˜U¿¦jš$6ÒIXïA[CÌßA(³Ÿêºj¬f…¨5‹k¡eYóùºW—SÑT@r׃ ÜÑ7õËb%uõúcØN[O×}6×ë4?çí^B!$TŸH±7Q²âÃUÎÁjSPãq H™LïH;gƒâYˆ]1c\ýKV ÷—±2LH9ëqÙ ¶uÛIuv ž&ì„÷Ž QªŸÐ`ˆòºF¬¦Í¤ÒÙ´¤’î{‘É+?IÁœ"ü»G0—,Á¦ `È =³ÚòW‘çˆ0±ÿàiC¹žð‘Ì€ÍéD!˜U¿Ž™KÕu˜þX©®«è@ÉîZ =þ§ªù|Ý«Šg!vÂú}hçñžŸÍõzgïU!„â¢Õ6¬¹$†Š×•J÷ |¯ýÁ(8Z¨ºîv̳ú¯õ™¶s\=‡ÚÛ ÕŠ‚B˜ñ—¾ËpðØ” «R mê4ú…ó m=ÞÆÈ@ŠÚ+±½õ¶Ú9è#OIœIV
—cN¼ÉØX6³*ºÊo·¢¡kÚ^‹,j>÷ª¢˜PÐеsqÏŸë%„Bˆw,T+î•”–I¶m›Z£k)Ã] lû5C]S!3l'•áÄ` %аb²Ì°ÿi휪žÃÒ¨*`ö`T8惎YÅ»‰vâ,ÇUd$y°wæÙÆXÑ4,ÁÚ½ùÔ³Õ§è»ÚKœåäT£ŒLýJ c ž
LtÌÌ¢p=L¨íÒ7¥¨Âµ"¯ìæŒ60Ï¥p®›LïËÄÎ`öq¶ýRÈΟNçÍÙ^‹lj6¿{U‹t“b)®Ò<”QÿÌïñÎðž{×ˈ¹üJ*Âí/žé“«çë^B!.¶PmôÔà,É`ο”â¥7àœ|ÎÝýÓ Äó39ž†[)žÉHÅV‹e†µh‰ÌMä-û…Æ=¤
yØ,]Œv¢Í¢SÖs8\ƈûÇ¡åFÊ›ÂLÄXŒŒ "›•zt+Þö›hXô lÿŽ¿¯´fÅâ)$Óó<Ò]ø¶í&ÕÇi¼¡šáý{ˆÇÓ(–|,†NƺŽœë”}¼·ãƒ4,ù"󴧰טrO€Ñg·Î:k#ÿ…?¸–ÊÕwû8è
ÑMa,\M®-Dp/g²ºEÏ¢_Ƴu-²©ù<Þ«úäk {oaîåŸgŽþ‚“F¬åkp ©3¨ç¬]/Ó<Ê×~”";Z»ÙýßN8ö|Þ«B!ÄEªuu’d8Iþ’/Ó¸´X?“]ÿLÇŽ-Dí ùyþ˜®¼Ò5R9µ§ j´—‰ðq¿‚N´Ñÿò‹Ô¬¸†¹ë7€&ºïÇŒ DË¢¬ê9,M|×OðÜK韣Pëøߺ†Ð²úŒÉ7 fßä T.ü 5õ6@C
íÁ7ø" *É}òVì*¯¦|õ5S3¬™ ÑÎ't u®Sõ]2ùÚ7èJ|ŒÊK>MÔ‰]øžûCƒg°Zó1¶•²ë.‡ƒÏŠŸIÒ±ãXp¦ØkŒÎô g«_Ù\‹,j>÷*Ú8c›¿…ñŠ»)[ñY
•tpxjŸ~?;gëz©#„F)œ¯yý|Þ«B!Ä{.¯÷ÎKÉý€Þü‰ïë•…–3kòPŸ·ñ—ú¢•ótû¥ßxÍŠ{ƒÞ|ï“z}ë¢ë»¼ä%/yÉK^ËË$ï)Þ,¥8sí`£øŠaîý!þñ3›e6–¬ÁcgìÀ Ú»¤ûVÍ6 ÖáL
’ˆ'P¬•ä.º
{º
Ÿ?ö ï»Bqñ’Pý `È¿‘Ú›Ö`Ñ'‰u=ÉþWw>£5®N\ .Áy‰ñà»e´ ¬fƒ{ÙUTÌ«Âd ôÉáWéûÓoÄ´÷vß…Bˆ‹˜ò 3!„B!Þƒ B!„ª…B!„P-„B!Ä»™xøÜžBÁXq7 ÿŸ¿¦ÐØÆøÐÄIž2WŒ«j椟tæÜ,óVœ«i¼û2wÉ”/¹•òò~üC3Ô“eÍïZ6œËÿ'‹®¿“ï‘sô8¼ópM…B!.¦“emkóßÒrEõ £v‹¶Í{g±}—‚ÑU…Õ`AËËzÆ y¨½nÁ?ì!š8n;8ÅMÞÚoR3¯ððÔº:y€‰½¿ÅÛÞA:Ëbôø6þî c kï§ômÖüîeÁ’W‚b0`wZ€ø99Ë)¯é,ߘ™ë¾Î%kÌôýúëŒF´w¸ !„Bˆ¬Bõ!½ üñŸ µ[—žôÏr?\TçßÓ (E ö¢ža™&w!†ÀSt¾¼ÕàÂV¹ªåâ0ŽíýÙÕ¤EI£`ˆ‘Êœëš/da‚/}™Ž\‰±Ð}{Z*š1·“Œ¡¦¤R
¦ü…Ø“û˜ŒfÎs;B!„gªã$ƒýÄg˜dTœWR{Û§p
ü€·þ¼´Šc5·}×ÁGØûj;ªc5 î¼ç¡oò=ÊÎgÞ<6¤š¨¹ó!
¬S,¾ù ŠEÛžGh{±ýÈñ©ab£=d€¨¿äqjç¯À¶«Ÿ˜
ð,ÞHeóeØ:™àFZŽ¯<ëåŠ3‹š0c©ºžŠÅkÈ-)fêIÓ£„Û¾O×Î~4Ç•4Üù)¬o=Dûë=Ó¡ßçÚÇ™_ô{ÿíWS5gÃZOÉÒÉ«¨ÃžãÁh ˆÙú0ûwO/_1¸ÉYx•-Ëq:Lè‰~&öü‚¾¶¯¼°]Á‚~×Ñmþ/v>»ãHÿ²içt}ŸÍ5=åÝYMÉÕ÷Sâ éBSM_ÿž7©ö£ÇP<ä¾ïajç+^|˜ÞÞ£–ì̦ !„Bˆ³ ªON¾FïK
4mø4óü_£³#EþªO’Ÿøû¶¾5Àât?u £!ük l¦†2=xŸþ2þÂ[¨_ÛBxó#øSSãzrôáKES5P-qâ¾bóU?ÂTpÔßNÅúM˜Ÿý*}ƒÑìú•MͱÔÝGóš¥è¾ðmÙK<–D±b ¦Z¼ƒñQ˜[µËÖ `*ÃSlA ÚIrÓߊ£™¢¦%°ÿWômõ’N©(V7Jpl:8Úp-û:
ÓŒm} ïh sÅT/û
uÉûÙß1:u\rŸú
FP
(¸öËÇ-ɦ,ú~Æ×ôø{ã Þß~–±¢F
.¿—
LÿLç«û‰ÇŽ
ÂÆbéoØS¤CC¨–:2á!âÁÓ¬¿5ypT€Ê*3©Ží$TP\+¨hÌ'±ýzÚ¼è@hp %ÿÛ”/]Žoh3©l¦«³©ÙTGùÊ¥üOÒþì $gJezˆpg7\µ’Üœg©(®fÜŽ4‘žþ3XR’"Þýgƒ‰C·s•-„·|¾Á©0é÷¢—>NmÓeXö?7U£ž 518õM†ô ý˪ C}?“kz²79™†²ë(Îïfp›FÙe×áêÝIX;1€mþj¥B¸ýà A9ëv„B!Î~¨îeà™Ÿ2yhMµ #yL6JÛùCú+¿Kõ‚Û À?ž:wÕ–~–Kïýìô bÄ:Ê]h€ÑÓ„ãÞ‘#3”ªŸÐ`ˆòºF¬¦Í¤ÎÒ“œg=.Ķn;I¨PI÷½Èä•Ÿ¤`NþÝ#˜K–`Ó0äžÕaQ< ±+fŒ« cÉêãþ2V†ÉÀ)êœ];©¬ú~YæRP[Iªýïð·«(u_'¿v.~ÿÞãÞ˜¨¤‡žÃ;ôvÛB!„8ë¡:Nr¼‡XêT³‘Ü<è`«{ Žö_9~Jølí¦6þöoi#“‰’š ¢jçp›¶S6Mýµ~êóëñ6FRÔ.X‰í—°ÕÎA y‚HâìÖ(
aÆ_ú.ÃÁcß9èjä4 Êœm;Ùõý¬IuÐÿûÏ` ¦)øžþ,¾t|ö·ÔÙjG!„boïá/æÊ®û®ñ_òÖïŸ ì¼Ú•—`:aº4ª
˜=SëygÌ© 4¬˜,§()=J||€x(pB ÖB{‰ã!§²øÈxÆ< ˜è ™9&!¢i€É‰á¤ûå¼f=ÖE4Ž†%XO5‚z˜PÛ+¤=k)ªXHa DöíÎnÊ,híÄqã*2’ ?ꕇ²^3œM;Y÷=ÛkšUa‰©ë…Ž~Ò lÄ\¾žÊ˯Çí0¾v„B!fï$1`*^KI•‰hšÕƒÙ>ý²™Ð’qt ä¬xš²½ô<ók&'{™œœCÉÒõØÆ^&J fPòVQTS‡1€œzÜ…)âÉÃÁF×mxšW‘›o& S0ç- ·8C||]±ã\°\•áÎÁ™Cbj„¤ãJJÀ®M¢[ç·ô^*JŒny’ÀÑû¢a(ZCau†èŠ§ wAú˜zNY³6A„¹÷‡çvg”Ó§h,ó>L‰{˜hpCñzŠÝi"Û½²O³B!„„ê “!ÿFjoZƒEŸ$Öõ$û_ÝAZg/µÉ]†{áu”Ø- er÷cô œ_U!„B¼M²üC!„Bˆ·É C „B!„„j!„B!$T‹wˆ±”‚e)¯ô Èh!„BH¨žS1®9KpÚNÖ}cÅÝ´|â š–Î}÷ Òiûu|¨® ðÒkÉ˳]õ!„B¼·Bµkó·XzïƒäZÞƒÎÛ@íu £ ÇtòPíªÂj°`ËË}×Ìâž¾_w=B!„犤i¤:ÿžö@)Z°W Œ"„B!Îa¨6àY¼‘ÊæË°[u2Á Œ´þ _ÿø‘}ú ùSÇ4]†Ý¦€ž 5ÑEpë?20Îî<ŠÏŠû¨¬©Áæt j¸±ÖŸâí=ê\§©ÇÔ@ÍQ`:¼øæ'(>£{¦ž,¨9W³àÎ{p jÓ÷(;Ÿys†`mÆRu=‹×[RŒ =J¸íûtíìŸz ŠÁMλ¨lYŽÓaBOô3±çôµu™ÍF†–ŠWn¤t^ §H^¡çO?#œÔ³ê—
`®¤pùÇ)o¨ÇbPI†0 ©Ù\Sc5 þÅ#ߢmóÞ©~Z–аño0½ñEöîñ£g[B!„„j'î+61¿Q%Ðú#¼AGýíT¬ß„ùÙ¯Ò7 ä¬ÜÄü&…‰í?Æës1ÕW¯ÇkGg·I¶bÃVÞŒ]}žÞçv‘Ròp/ü J¯ù<éßnb8”É®žLÞ§¿Œ¿ðê׶Þü¾@ =9:ôât?u £!ük lÆ‚ŒXêî£yÍRtß ø¶ì% K¢Ø
1†ÓO(´áZöu¦ÛúÞÑ抩^öê’÷³¿c4Ë
Â-¸–ßOõ¼a†_ù1°`ËQI zšL6ýR<ä]ýsç†o}œ@È„r ù³½¦YȦ !„B Õ ¸VPјObûô´yÑÐà Jþ·)_º ßÐfÒŽË©h* ¹ëAî蛞մ’ºzý™8º—`ÿnT`2`Á}ÇFòË<øCãE=)=E:4„j‰ “! " <îÑáZŒÔD IÒ™“Z å+—bð?Iû³/œá9ߊs•-„·|¾Á© í÷¢—>NmÓeXö?7ã÷Ít‰LN$½Lî%Sn"Ç sú~)®”Õ8‰oÝDïîá©ññÅÉmú›Ã×"›kšÝƒÖ³g!„B Õ`ð4a'ĸwäÈŒ«ê'4¢¼®«i3ÏBì„ ôûÐÎrázÂG2§=ëzRé³snÅY˱ÛNŒÏBìŠãêÇX²ú¸¿Œ•a2e¨Ž~ãçoø8óïZJ¬÷UÆ÷ÿŒ
¢Îb ‰Á½ !Ɔ'!Ïj 5ù¡B!„8k¡:«ð©˜PÐÐÏIÓÏíÖOÙ¶6õ׺~Š¾+(„é» Móº!•É¾mb3Ý¿yÇœ+)¨[Eùú
TŒ>C×ý–p"ÛÁÕ¦ë:;ã®
²·µB!Ä´3Þ@X í%Ž‡œÊâ#áÊX‚§Â $3 EºI‘‹«4lê9rp
+&Ë©ºŸFU³ãqÅë±.¢ p4,Áj8Yn'ŽW‘‘dpøQ¯D84û™{-L¬ç?xáAÚ~÷kEï§zAɱãzŠ~i¡·ˆãÁ]]~Ò‹žÕjQRI0¸+0îîÉjœ…B!ÞýŒÀÃ3emSñZJªLDû»Ð¬ Ìöé—Í„–Œ£§FH:®¤tÑ
ìÚ$ºuyK異4Áè–' „Ó G+^GÑ‚,éº}ž†k)(.Bõ>ÏèH– |Sœ¸×ãQß`¸shzŠbòÂ<ò"#¾pvõ
ź
Oó*róͤc
æ¼ägˆO 5A¡ä¢¨¦c" 9õ¸ SÄ“èÚñT-EÍ×SXæ݈ÑQ„½°wÁô1é’Öå”´\‡'GCSl˜ÝÕäT_‚%ÖC"•í4» ×’»))´¡-˜ %8+–‘_YFºëOŒÇ³ëWÊOÒq%-«qšchÖ‚fòjæÃôµÈn S¨¦K(©_Ã8A¶ÂcÛ™Ý8 !„B¼çCõ <
ë(n:êµ ŒHûk$Õ4)o+1¥–‚–›(®_Š“Nü[ Åë
M§ª8±·P]—P´h=Eu—á0§1ØݨÏÕP
YÔsHf”è¤ ç¼µ7¾‚šù˜â{ zýGÍ kdƼ(EK)nZCAM=æø^^?:êØ6ci¬å+(j^Gáü+ɯž‹)ÙIÐ;ŒFšÔàë„“¹äÔ®£¤ñj
ê.''}[‰Ä³œ«V Øʯ xáJš×Q´à}ähDÞú½{ »®ú”ýJ“òn%ªW»`%«(¨™“u½B8”Ìr uÔ±ÝÄŒsÉoºâ«(¨™ ánB]¯N·3›qB!„x÷SàüN*î
4Ý~é'"W@!„B¼ëã'*Úp,X‡35H"ž@±V’»è6ìé6|þ˜Œ¾B!„P}Z'ö²«¨˜W5õ¡6=FrøUúþô1Y „B!ÞÎûò!„B!Þkd¯3!„B!$T !„Bq±‡jÅgå×X°ª £\!„B!¡úLBµ
[y.ãÝ7z¦b\s–à´É„¿B!ÄÅì付JÈ_²‘ò†lVÔñá7ð½ü¯"ê…×ÅMÞÚoR3¯ðð;uò {‹·½ƒô9ØlÄ·Úë–üà ¢‰ÔÖíÂÕò1æ\z9v+d ¿ú3üÃù©B!Ä»;T[p,y€y‹ ¸íGôûÆÑí䔺I¥´ ¶+&w!†ÀSt¾¼ÕàÂV¹ªåâ0ŽíýàSüŒX>GÃò¢»B×0¸ý%•7ü5êSßatR•;T!„â]ª
\Eàû!}»ZÉ p€ÉÞã+À³x#•Í—a·êd‚;iý9¾þñ£fYÍXª®§bñrKŠ§ÖM§G ·}Ÿ®3]SÙí4Üpìùû¶í›z·¥†â•)W‡Åè)ÒWèùÓÏ'šÓM
í!Dý½h%S;¶]ýÄÔ,k¶ÖS²ôFò*ê°çx0 bD¶>ÌþÝCè¦jî|ˆëÔáÅ7?Añô·j=Ðöb;YÅacE‹Ñ §»õ
Ò:LŒ¦qÜq e•Œ·öÉã¼…B!Þµ¡Z‹D f-ùù» $f8ȉûŠMÌoT ´þoPÁQ;ë7a~ö«ô
F#–ºûh^³Ý÷¾-{‰Ç’(¶BŒáÀ ш¹ê#Ô_·}÷#t¾9 ¨±àZ~?Õó†~å;LLÄÀZ€-G%™>Õ" MÕ@1Ì¢fP Í5-ý¿¢o«—tJE±ºQ‚cSÁ;Óƒ÷é/ã/¼…úµ-„7?‚/@OŽ’íü²b¯Ãí‚ض› dá2 ¾?>N` æVÔbRúHÉ!„Bˆwi¨&ÎäkßcÀüª?ô#ŠûÿÌHû Œ
úaŵ‚ŠÆ|Û §Í‹„Pò¿MùÒåø†6“2ÖQ¾r)ÿ“´?ûÉSN»Z±7~†Ú+‰½ñ
¶÷ NM˜œHz™ ÜK$¦ÝDNÙ3ŽêPYe&Õ±„še͇ClŠx÷Ÿ Îô†"E:4„j‰ “! " œýšjÅV„‰‘xca1F³«9E,–‚‚"LHÉ
!„Bˆwk¨RÝø_ø"cž…4^Kñõÿ@Åè ézþwL&4 ž&ì„÷Ž Y6¡ú
†(¯kÄjÚLÚQ˱ÛN¨²{XPöÿ·woÁYßu ÇßÏ1'r$!„†B0`·ÊÁVd†ª³´ŒÚ±£;v;ÚÖµãlwêî^¸®£Ý^쮥3;2ë…ÕÙvÖ íhoêÒjm§Ò²Tˆí.D*
!'ò$Ï!Ïq/ )¥}@Qq߯›ÌóÏÿÿÏ/¿.>ùÍ÷ÿý…Iî}˜Þ§Þñ’^’øžï3¶õ‹,¿g Éã»9´“áþ™•ìYZ bõ¿.yø?8²·—*aÌ™ì â1dHt=B÷ ÙÉ Õþ]J’$ý‰„j
äÇ»9³§›Ø[›éøÌ—XºöM~½»¯ÄÛ¦Ãk±„†ñÝĦ>LÓúi yœ‰9ÁºpöúžyƒÊöÌïØÄ¢-wÐÛAïÏ~D<=+±<áW÷“Ë%ÈLŒ‘/üñÖOÓ1r”(ƒÂ8™I PG´2
S1rTK’$]Jn°\œ<Àø8Dæ/ ÆCŠZªÛ8wR¨™ÚÖZ8{© “½$ÒPÙ¹–²÷ûIÉ}œ|þ 9v¬†–_gq[Í…ûžOÖq’Ç~JÿK_cÿ³?$Ýô ®[Ñ<÷¼lŒÔH?©ñÑ‹u)c¾,…4ÊG¯¬Ou1ÕK|*;V>7 òNêçCf œõÔ’$IׄðOGíêo¹‡ù5¡rÂUmÔt~–¶e-L |–3C3g˜ªÜH˪[¨(LP,k§~Ý´¶¤‰½úŸŒÆ³P8K*³Œ¦n§qa
C„*›¨h\IÍü ©Ñ Š*æÜBm~C=‡Iœè"]óç´_ ¿d"‘*˜·ö>šË „¢„+›©j]OCÛB²½Ï32’‚@U+î ®ÐÅÐáwïšQʘ@ÅJ|°“ܑ相tÒ.Ë©½au
²É ‘úÔ-È‘™(Çtq‚©ü
šoüó‚cäÂí4ÝúE«ŽpòÕHø–¢$IÒ5!|©¬ ÈWQ³ê¯h©®$ ÇsýÝçêL¼þ½éûi»éA:¢?»ÁŸæÔL
È3Õó-ÞJn¥uÍfmþøôÒxn”Äá§í;uqø-Œ0ºëq¢µÿBÛ–ûHþø;œŠ ÔRsÓ4WD¦óhªŸø¾íœè½ŒMRJóeHïçí×^æú[>Î’-w@!N¢ç;Œ ´ª“Âu‹üÉ“Œ$ò>iI’$]5—®©> ¨„ª 1L2™Ék‰„rBuD¢çó@E5ó Ù{„пƚû £¥¼—ш¶.# (eˆÂM7SA?£'Ç.Œ©0Êø‘~¨_KUù¬ª©Þð yb?ßÆ©3)Ÿ²$I’®ªpIÉ»v3K>ògdÞúgbãV}Ñy’9ª7“›PL $Öõ'{) ò&¤™Le 5. ‰PÉLf`~á dÞw9D¸¦
§™šš}rž\|”"-”•… 3}4²ü!–GÂLìú*o¿=~yuÛ’$IÒï>TÍ¿eŸ¸‡ŠïÒ³÷ ³cmqüEÿàE Hp^
7‰%·}`ê« HÌ:3C¢ëºÉN樾Š¿Pat?‰ÚQ½þó4žþ6±±ŒOY’$IWUð=uó§ùÀ÷Pvüß9øÊkL]rU¹@aò0ïXª†úíb:FŽr¢ePH’™œ¤('Z…©¹R
ªÉ“‹Ç!X?½"}^ˆpMâsV°óÃ/Ðûì6N§ÖÐþ©¯ÐTõ)K’$éªU æúÛï"Ò·ž]{É”ôFáÜÛS½Ä'¡²cÅ…úéòNêçCf \IµEr±7I±˜†ÖzÎWO¨]¾Æþ—Dº8çübª›þ Oˬ¦}ë½ÔVØŽ[’$IWÏ%Ê?ʨZó—Ôñ? ï9M¸îº 'f‡IO$)RNÕwR“=Fr"A1ÚLMç]4UÄî™éê‘ï'¶ï Í y€eë¢ †êU÷RËAN ZoùD ‹3¿ØÎÀñø%/+Œ½È±½¸áÖ/жh?Ç’>qI’$ý΀_ëœ
I’$éÊ}Nƒ$I’tŲ hs.$I’¤+2zI’$éŠ
»I’$éŠíÏ9’$IÒ{.Èt÷Î…$I’tÙv¿:·eÊ6çC’$IºlÛ B3 z…دZ’$I*Õ“À·`zó—Ù~lv~$I’¤÷´¸í܇à;¾y'ÖWK’$Iï¨ïœ}à¡:>“¸Ÿt®$I’¤‹<9“—㳆.qò h–8w’$Iún'ð 35Ôï(áë™^ÞÞt2ýB£$I’ô§l8ÄôF‰Ï1݆ú’þAf… Ô* IEND®B`‚ stem-1.6.0/docs/_static/prompt/info.png 0000664 0001750 0001750 00000055673 13115423200 020557 0 ustar atagar atagar 0000000 0000000 ‰PNG
IHDR ø u ;“•Ì sRGB ®Î é bKGD ÿ ÿ ÿ ½§“ pHYs šœ tIMEÞ7+¿à± IDATxÚìwX××Ç¿³»,Kï"‚(Š€ŠX°#Š]cÃhb‹±&*Q“ü’¨‰šÄšØ¢b¢Æþj4–Øc¯ bWTšR‘^v÷¼ì‚€”Y$Qãù<Ïy ½Ü{î¹gîœ9s玀Òé €æ ê€a†a†a˜×…{ Î Ø
`wÉ …ÿ÷° @[¶Ã0 Ã0 üö ¼´ ¿»ö.@ŸíÄ0 Ã0 Ã0o ¹Ð¬¾Ù]4À÷&ÍÏÁ=Ã0 Ã0 ü™A~s áí Ü3 Ã0 Ã0Ì‹¾6¦‡ ÍÒœ]l†a†a†yãé!f½Ã0 Ã0 Ã0o>ý$ЬÕyã{LÇ ÊÀŽnEÞ`°wó²6³ ^ª=Tï2»¯'!—¤|†˜°mñT¼Áã]•öa†a†a^CšËðFîs¯zÞƒkÆ~L<™
*<.‘S¸è ÛÓ ú ²+Ù‚Ä®/Öþß—hvú[|ò¢”&°«i‰G‰ùoðxW} †nC°úP(ö·DN!“O(†a†a˜WMM 7Nô½èÛûD϶‘yÉߤ¦äÚ¤19 /Õ†ïK ´¢…!½‘6*KªÀ>z6Mèý9{)Š4$ò'£ÿ’XXXXXXXXÞl)å \Aþ kQPc2W”ñ‡UU¦¢ð™K)•6š “:|@¨Çz¿üKl©óÂCý”r´ÅÒî ù}œI¿ ŒQ+Z›L¥rãÓº¤WØ7GêöÍ t=…ˆHMÉ;é뮎$×å&Âû+:ø ˆˆ²£OÒ†5ûén‘êÉZÒ³:ÉthKbéO~ÞI§ïÄSZ^ÆOéä”ú$k €¤ÕûÓÆ;©”¯-– {†ÖŒiD¦’‚2
òþö:Å_ÞL_ö @+ã8Àgaaaaaaayí|™›}íKs£}iîý4rv5r¯'%É?PFwQPã1DO×S€i‘ã23rrs'÷4ûv¬Ì…&^%¢{‹iX÷NÔ©çpúîÈ3"
§)õäš2‚Ù¹Ö§FÁé =¡ÁÈÝÝÜÝݨ–eA
XCDhó§ÁÔ¥ë»ô¿mQDCË,HÙÓ Ý”C7hfê¿"†ˆ®Ów=ÛÓð
Dñ˨¹¡ø¶äîÓèÝY5‰ÞíÑ‘ÚµiOz
nu
ÅÛ (jS—=©ƒSjÚª½CDèçæEžd‚¦]_ú1–|–×?ƒ/•’M+ê¼´>M+У}iÆ êÔÛˆ ¥UXFW…
ühq QòoíȤ´ßeN4.¼‚ ¿Èo2çñND?t$iÑìºßzDh‰ŸÁ‹Yé Ýšæñ<ó¯ß€fÜ&¢3 ’£T‡ _}œúZ‚L:í¤,õI
¶È¤Ã6ÊPŸ¦ÁÕÑmiüLú¿@“òÛ-Ï>¥‰ywÚ›Kt½èÓ‹Â±à Ÿ…………………åuI©KóU*$H¾±71Ó-+¦&àþ3À°%æØ£†A–ÑC¯!è[=»V_@z¼… L¾Y€YuSHÅêàÚ îˆÇ‘[p07ûÅîíàZ™íiÔjH€ÔJ¨!Tþ™¶ÊAV=¦®;…È'YP©sðôÖjÊ}#9$üÒ
Ã0 Ã0Ìk¬¼ åŽ&hØßMƒàd¦9F±¹ÈVU}qÁgX_Ø'íÄšK¥y¾¥N‘í3ˬ¡T‚DYþyí%Ë ÂKŒ© Rª þ§Û*Ï>zu0~÷AÌ©}3?îŽ?¯§@°ïˆ v~;>W†a†aÞÜ _êh…^‹k ic½Â 8ñpN‡&áÒÉ äª«®ŒN7°޶HÜŠ°Œ²Ø\¤ç 0©)ðTUõF˺{7Ðí;º@ÿì5Mf]¿6‚ì€Gq·{O¦ êS¹¶›ÿd[åÙÇ .:zI9w
foˆÐ´uÏ QÙà Ÿa†aæMðUYjX4Оd"ü·Dœú=щô”Ñßèe-¡áeï¹®NÅõÓ1@È|=& ;Ìá¬8•ën"§ŠŒ¦ŠÙŒÏW|Ã_ïÆ:åXwM
1½n,VtØŠØ*¼©¨ò¶Ê³ON$þ¾t > .ÿ„¿£2!±öƒc‰e@‚Âu]m¡oP¶ú€ÜÚž
Ó‘–‰Û±™PóyÅ0 Ã0 óJyqq¾ ! w}R”÷²hU•-¦Ô~]
QÜjjX~Y©Mšu8šr‰ˆTO(lig²–”þ’-LhK:ѽo<Ÿ¿ÄZÁK¶Ðn]Ù}Ö ºõL³dêÍ?iV÷š:m“Yô%Û¢ÇÛo¢4õYb'Ý–è—l˳@
—>4wïuJ,ØGTMOcÂhý{N…Ûv4^@1¥l#úlc;2æ[XXXXXXXX^©(¶*û5Æ,£ ÕZ?¸N¼ð_`e†a†a˜ÿ.oÌÆ(æÍG¢‹Y 6¯‹ààža†a†aÞè _°@‹‘a½ ë¯çð¨1 Ã0 Ã0LY¡3Þ”%: Ã0 Ã0 ÃT»ˆa†a†a8Àg†a†a†ü7Ñ@¦1qÛ)¬êm)›ƒaæ
@†ê ÞE»êzl
†a8Àu°XŠ»yY›Ù¯‰q# |ºÿvÈÀè,~YaæM@ß
ÃØ€#W·áÃzl†aÞJ^ƒ
ù¥Tcø RQÆŽ®Ï?BU)ÈÐm(mŒ%J\åOF•G0§vËbˆrOÓ”††$”ü€€ICú`å)ŠÍ!"RRâåôY[’¾P—„Lê÷¤OWî£ð˜tR圧±N2ÝêÑo@³"_ü°ÔÉ`k ’Øô¤
wÓI¥=žN» £Ff’"zÈÈù£ËTªCÝɬˆýµzÐô-(.›ˆ(’ï ¥ãš’…èS>³hÛÅ8Ê&"¢\z ¶…>o§›Îâôy¹2 ޒؾC[cr‹üñ3zxn}ä@zEÇÔ°./8HwÓ5Ų¢OÑ/£|ÈT¢Û˜Vì‡bl(%˦£iÙá;”¢$"ʧ¤ˆ4£“}áÇÄøè¾Wè‡býGä9(AÃOh<öêd×bºˆÕKòŸ¼™®$«‰HMÉW·Ð”–V¥œƒŒ½Bèp:ÝA úÅ+ßçÅÖS‘oˆ;w* £V´6™J'q%µ0k q>&ÎÎÙ°âóTôÜ"ÒǤ¶é§»D³‚:YKøÃ7,,,o›¼&ŠHMɵIcr2*]‡žMzÎ^ŠÒ^8’^"À×÷œA·(—Ž©U<¨ [ê½5•(û,ÍÔ–š¶z‡þ·;HyŽBêÊ‹Ü$’ǘÿ£ØìGô÷ªiôaߎÔÒ·>UÓt«Ç°-}LtçûÎÔ¨aCjØ°!5lèIµÌ¤š ™Ãtˆ®MïL-ZÑÀet*•ˆn/¤v’Ú%šè_P‡F<œMHRðE\×1t ƒˆîï Y ô¦ ®}éƒ/–ѺoüÉD[〠iå¬1Ô¿KGê:p
½®$ÊÜE½Ñ:‹ÓçåÊÔ¯aD’"ö¹úy[òönBºŽ¤…§2ˆÔhB =íX™RÛ•‰²ÎмAm¨±o{ºè"åR2ïdñü¯¢1å‡"l(¯G“Ï&Ñí³èƒ^¨Ë€Oè×[j¢ÜÃô¾ƒT´ÿˆê»(?ç?bÏA=×OèJÞ#úëHѽ™Ô H ,JgÈÈùã”CétbÞ0êÑcÍ;‘N”s„F:Ë^hOQ< xšKÉ¥æû¼¸z*ö
ã.f,$&TÛ·ùûûJëÞ³é| Qüo=©šT¤}Äø˜H;‹™7*:OÅÎ-ºÌóò:cèH6Ñ£åmÉLà > Ë[ àxE hÒ˜ÙÑ'iÚýt7ƒHõä-éYýyvGîHݾùƒ®§&³±“¾îêHò¢Ù8KšðóN:}'žÒò
r6Oéä”ú$/r1/äXïR3øÒêýiãTÊ×ËŽ=CkÆ4*’]U÷·×)þòfú²ÿ Z÷2¾ù¯L z¼ŒüKùü¯m0 SÝü¼^að/Xt¥miD±?ú’6ÃdÒâGŠL=ES¼_x ¾ Li{F> ëcYª¾6|ž é×›Dç”Dwg5$ýbØ£ÔÓ¬¬›,{ôW6QÒ:êf#>ãeÚåOÊ¡ûô—þóãè,JŸ**Sª}̤Hʤÿ 4Ñ”3hB‹âˆV´ Û”æ´"èá\ Rˆ ÓÊúai6dòb™K£–«(‰RiC[cÑþ#¦ïâüPÌXˆí»>5˜yò"¦’§×—tK K‹šè6^
šE”µw UÓλ`ÚŸMôpŽ·v¼´Ç:Ò²ûétéë ê¾.¥x`®ƒÏ—[(ߨxÜEÏ ÅÎ[;ê·=•(ægjk.èdŸŠ|LT=¢l(ÆÄœºž_rª7õ2Qþqá(å > Ë[#¥®Á׳óC+çÌêÚCö9áÝaŽØ6( #ÿª‰ñ+¾BC ‚Æî¯âÚœèÚm0~¸íƒižÆâ Úºdv7¶'¬ÏÁè¾Ð¾m ‚zÆ÷D!€*a+úÖ÷€GÃŽøöNÙëˆT)—°î«!èܲšµîŽ)0léŸø®©¡¶D.á {;Y/³`^Q=;Ù"iÏz\Îxñg‰Â¦ íqTëœÒ"pø.àд>L [t™1.‚†ìŽC )‘ ukÆúÂL¢C= [Øä"ÃÀ öæòBÛ–Gîu˜{$ u‚ûÂU_\·%6 0:P»?}Ij!…‰KŒû¤5ä‘;±;2·ð—Êèü¯ È`ìÐÁÞ…ó“]X{9Ss&¦ Ýç
¼ÄÜ¢ëù•‡»ëæã¸à¼QÃ0où|Ó Ý”£>N}-A&vR–ú$[ dÒae¨OÓàjIkŽ¦sDtkš‡6C¬Yw=ã6ù ¥ÚG¤îÓèNÑÌ[Y"s¢qáegð_óî´7—èú§u_\BcàK?ƾDß¼ V áP¸ô ˜(|hî"º6—:9*H€”Lœéû;DtñCª!Á8€¶¤=Ý?“Þ ô#ïFhà÷§(‹ÒhGßjšzÅÔÜõc:BJÍÓ‹üèc´xP=2ÊÎx
j4?Š(c;š”·ö
…h—=(Í£(Ê¢ M*¾3´L'´úPÎYšÞÔ´XÖ²"Åèóre4þ‹ÒžÑC
í[£˜ï¸}H[c‰èi8í\»•.§gÒ…oÛ’UÁS"1cªƒ VdÃbKCꎤ?ŸÝ_܆Ìñ~(ªï¢üPÌXˆë»¢Ñ|ŠÊ½HceèQ½Ïo:n1ùˆ /¯¦Ñæ [ò]ED ´Òߎ·g=øŽ¼kÛOO ýF]m$Që_‹gÞÅù|Åõèâ去È9áù¼Y‹ÆžU…O¦ºzEm,Æ>û˜˜zÄÚ°¢óTçóBì:• Çä¶#q¬ÀçTÏpïYñW?k‹÷÷§ÃÀÊ zMÁÜa0ÔÁ¿ÇB )Œj¸ÂÅ8û–®Å)½pTÂ÷Ý‘èòËi¬{'nLuxrT‘
ÆÐÄg"¶ Y ¯CÃà?åo¤’x?Õw ê7å> Cý}awu.öÄ* þØ„»³?À ÷©8)G”ÎÏÉÂÅ©^pZ$A|T>Ú„IªWë…ó›âø˜úØ_VfY„Ï‹©Gß(wÜu @ßãCLnš‹½ý~ýR‡¡lûˆò11õè0oˆ9OÅ:ÿQ)€™ƒxÓL†a8ƒ_Áï°•ÒòŽS°@Æí7Qšú,
±“IÀJ§xZÖÌ°ÈßR³¥‰žm¤öÆ:fð¥Ï3ø%Ó«CÏ«ˆ’÷Ó7ƒÈÏÛ‡švþ”NæÝûÆóù„ªÊà›ÒöL¢ŸÕ{ñé@1Ñ#s‡ÚTÇÙž¬=>¥"º8Ιd ÖèÝžæþüÁŠúŸ ¢+ÈE&®žRÛ5jA+ˆžmjOÆeeðkês ¯È Œ¯•Ø¥Ó$¦ß%íÕ–Ö$¥n('CVBçW½ {zÿ¤šèòÇTK‚I;Zû„èæ—ÏŸHI,hi,QæÎîd!è:¦:úa©6”y‹t6›èAh?ª)×ÝEõ]” 긆º¬¾ë{Ò7÷Jß æÞ7
H_¤ÎR§±FD§ÉŽKìièY"º4Š ¥Ù ¬)áóâêÑÙ7*&¦ qóFåÖà—;·ˆ=¿¤Ž4ê"QîžÎdÊY=–·y
~QÒõƒ©¼56%ÏÏdÝ=‚¨†ö ]P¸Ä[¿6‚ì€Gq7[×ÛŒ\¤ç 0©“’ %
ꢣ—‘K§`ö†Ã89 çNœCTö?tË“}‡o®A¾°*×BùH‹Dd‚9ú/ü
ži;ðݶh(PÆ]œ‹êtjŽjýQÔB3' 3ò6’•âê)=1/©pM»¼ö@Ln¯‡û[¶ãn®ØŒòßØpžPÿãOÐÆR‡ç"¤‚š ‰¬œ®"tþw‘@&
u—YºÃË*®>*|"¥N ÃëJ:9ÁLªë˜êêÿ/ÚPVc ~Ý; Õ7õÿȈÎÓÝÅô½òõèŽÜ¹;úÕŠÁÒž>ðððЊ/mIAí¾]á¬'NgUÂY Ž|¶†uÁ;-60À ˆ:tI*BÊžÁ¨_؆<<š`èî vz5Æ–G*>/®žJûF™çŽˆ±P¸¡_ÏêÈ:ò+ΕȂWl q>&¦žJÏU5·TøÐÈM˜K1ÈÃ0ÌÛ¬²¨ŠÙŒÏW|Ã_ïÆ:åXwM
1½n,VtØŠX•ŽªSqýt 2_IÂŽs8+Nc庛ÈɉÄß·€ÎçcÂåŸðwT&$Ö~p,ñVž °C]W[èÔ…> ·v…gÃt¤¥Dâvl&D¿þ¥ŒÃ¾Ð øé§Oð®Ë,xáÙ· ÞhèZ n~ 1pÌXt¬Gag‚¶•œkøeÉ%„Ìýk¿LÁW{Rà:ìgLpŒÂ’à“x&¶ ÃwÒè˜~ áŸBmVíFLÇHÛD¬] ŽL<ÿZ™y=_ø5Ï…½WWŒûæ4{ø:Ì¿Š Ñý~ˆ_ÇÏÂÈs_᯳˜5çwœŽÉ‡yí¦híp Ó§ ĉ=ºL
×è0ÜzœÁ¼6ZŸ6ñXóK2Eê\õ˜¢–gC4L/ÚŸTÜ¿‚û@“šõP¯^5X×Bów§á‡fJœúh? © eÂ)ì¿'Çg‹ÆåB Ž&8¶Ÿ„… e¸3û8 +(ÅŒ©?”‰±¡ü¾ø=„ÝùK$¬ÝºàTɈÆû©PŠòŸŠû ꩈòûž‹êýà–y ½ŒéÏϧÄmáPöï‡ó —š”«³*K¿=†–¯Æ–Ù†˜
ðŸ¼AÂ1ŒZvMãóiQ¸u£¨vF°~šä$âÞí‡HU€ŸSß5îâÇBf×5ˆ—‘Vr rDØGŒ‰©G̼¡®ø<Í5·è>Ïû B«Çضç>ø üU”»D§èñ¢Kt Ý&³û¬=të™æiuêÍ?iV÷šÅ¶É½D ©Mšu8šr‰ˆTO(lig²Ö¾à¨péCs÷^§Ä í£qu6= £õï9>¶6h¼€bÊýŠx,:ÒÚ$¢Ì ³^Éß
ÈoI åÒ“»ghû±Ԯ†~)/ÛQà´ t-YÙÚ3ê-èçRdI‘ˆz¤Õ(hÎ>ºö8«`ƒPz¶ƒf÷©CÚá$6=é÷{¤Ö–ÈŠ»L»Ž _ I% ‘KÈÌg8->p‹’µ/ºå%\¦ ³º“ƒ ymºüÝH(øQÅ\ÜF3{»B¯sÕ/Ñ)…Ü=ÔÙTóá¤íTE~È¢ÇÑÏ£üŠ}ÈHQ» ÍÛ›ž|_)ù&í›×—\ôuS~(Ɔzu蓈2–…œFöqþ#®ïbüYœÿ”Ûw‰=½w\Etv8U—”Ü
]'xßžd"Ç R+j9e E<Õn¾±•¦¶*ëCW(ýåX1>/¶žŠ|C̸‹[ 2n³ŽžR"laXÆÒ”
ì#ÊÇÄÚ¹"V|žŠ³Žó¼¬þ;—(âsª/çGö,,,ü¡+Hɶû¯ô˜Ôtý‡öÏwRaaaaayýE0¤SNS.EÑ’V¦¢¿MÀÂÂÂÂþ[pðüh?¥’’ÎO®WìÉ Ëk*3òýä/J¥ :õ©ñWlYXXx›Læùâ¥,\[Ò^wÀõJ$òØ" Ã0¯?¸6¶À‘I-0tÑd›„a˜· ¡ Ï0 Ã0 Ã0Ì›„MÀ0 Ã0 Ã0 à3 Ã0 Ã0 óßð¥0pj÷€¡ðªk^ÆGÄ”a†a†aæÕø‚1 -FÐà ð©cVzð.¦ Ã0 Ã0 Ã0¯A€Ï”uçC·¡ØKH\å£b¿IaÙt4– ¾ƒ%( I;1£“}±O †u¼à YѧðË( ˜ê4zú¨Õg¶]ŒC6ˆrñ8l >og©N:‹õ,KøOÞŒ+Éj©‘|u ¦´´‚n œ×EgÞÆ^!8œN »3࡯ãH™4Ä+O!6‡@¤Dâåø¬m%ì#ºïU`g†a†aðÿ=ôlšàý9{póf(‚ ðâ y _4íR·`jß t
þ {õz`ú®õx×A
¦hóãßØ8Ú;G·…o“ ŒÝ¡÷— ÂÒ@ ž‚¨ ”#eÿ, éÚ ÝÞý鿃oÿ\ Ö‚xE!ƒóÛqx^¤ž=G`ͳΘ{h+†;ë²3«8 PÔ ‡ÿ;ö ¼+u&آךãøå=)6Žh‡fûãǘÖøîП˜PW®ƒ}Äõ½jìÌ0 Ã0 S:¥l/!CïôÞ¢S414œBBÃéãë©K)
¿è*Ü©?Í8B“BÃ)dùAµZSvh'’ˆ.#!}çÞÔzÔJ²ð”¦\h8…„ž¥QS‡’UÁ§âõjP>?ÒûK.QHh8MZ²zõiOfzÏõŒ<É{Øj±¬ Ž34jæ<ò¶“ëT A¿>ùM9L“Ö ¥þ==I®ó‡RäýíuŠ¿¼™¾ì?€VÆ%ò'£å™¼Ø'ßZ®¢$J¥
m5Ç šÐ¢8¢„-È° œasZ‘@ôp®)^â#¦]þ¤ ºOßzéë¤s…¢ð¡yQDY{P5¿Hì‚i6ÑÃ9ÞU¬³¶~«Ž´ì~:]ú:€º¯K!º;ƒ<ôKü½ÔŽz…Þ§|åCúí ûbvlƒé˜ŠèæçõH¯à˜EWÚ–Fû£/ˆµ¨¾W‘YXXXXXXXJ‘22øjägå9ñxòà*â ¥@fá·?#¨‘¥&ÛhÔ í'w' Ù1HIWÀ¨dmbÊ@C÷÷àÛ¬ ¬Ì
‹d2õa$OA®
€ÄuG®Gnm`-CâƒHdÕ†K· пŸô @0‡Ë°åhߺ̤‘x?‰ 90t¨ ‰J¥Í†‹(S‡µëˆ†î–sÔhÓ–zºÞ7åàòž°÷ €Y»#‘UÆ×H™U[˜8Ö„ ¢ —«9”—€ëÑÛÀ~hb¡1žAívhný ŽG#·R÷tR˜¸tÀ¸OZC ¹»#suÒ¹ÂÚ«5G@M ü÷Ó0w©ég1Õæ 6]œšÂFZ•:9 xõô ÿ=gžÅ3uUè×Bç.µ “:!(¨Š®à‘(,`*Ò §Ž¥Eàð]À¡i}˜
âì#®ïUcg†a†a˜Ò(s½DþÙX÷© ‰¾)
Xt^‹þìàÐز‹O!7õŒdîÃŽO¿Àƒ,3Ôûü(ººÔ @Qa™<œ5ßnGj>Rc)‘E€¬æûhÓÄ È>Š¿¾›‡èL‚´ú`ôýdL[ÃnûĨl`WS³Š9aÛxl>x J¹$ùÚM*¢Œåã=»Üþõ%ˆ;´Éù•y6B:}ELQwV-
Ä£%m±êž¶AU4Ö
ÀC+pì~[üñÇ=5~dï IDAT8÷é‚Ü9]1zo²Î_)“Ø
Æß±ëÐR
÷ f´™³•×¹4ô¬jÁ
é8û8¦\`f¬€‹i6.Åeœa©Ä¨ªJgj¾·?ûíÃ`¯ÍˆUÀ¥¬Š².`úÀ‰Hí$àÀÂóÈ*ò“*ñ,=¦Lž„ÀÃÓp & ÆŽõàd Í z ªŠí#ºïU`g†a†a |9Ì›~‚ wû£ºi‰ ÆPz0vrÔ¼4w 3 J,bÊ”¼«HCŽR[B•Ì4 À°Ž L À :}Ó®øß8ÀD!žEãΩÛðëUÕnÇøŽ—qçÌnD Ûƒ˜ä‚¨]D™òî!lQW„ý+à ÀÄg"¶ Y ¯CÃà?åo¤J
£®p1ŽÃ¾¥kqJ¯ •†ð}w$ºürë äéÔ’:iÞoÔ Î.>èþñ,Ì8yBÓÖ˜–ùô+ §zÁi‘ñQùhR¹ZÊÓYRÎoŠãcêc’º‚š”ˆ?²Ÿ )姜˘Õ2ܶÍÃþè)©q…½qHW½š¾3 Ã0 ÃTI€/±êΣúÃ^x†¨}Ëpãá3(¼CЮ¹ÍóB¨T’²ÞSFDð+HµëzR÷àȆÃÈ(Ç©RŸ©‹¤]C±&²'¼Zv‚k# ¸uó†[·Á¸ôýü};]d™ Ì[LÃþÃÓQmSøÚŠè¢1»IkÌß4†ó=Ñ{Öuäb~øn%~ºzËnŸ½wã©.©`U \=‡WÏáèá[0¿?i‚ùƒŽ!£Šz”Ÿü É0A
{#H” ˆŽ ±‡ƒƒ!ò)º>
)Sç¿aÐ~Þ±46?†rsÑ?šŽkAUÛ +£ÅDç„´ ? ‡Ób˜;Ô„µ^RÞÇÑkß#wïud¾ª¾3 Ã0 Ãè ]–vм®fÍqæ œÿc3nž?€{wŸ
cñð>” àÔu¬K»OSFTt‡¬‡×‘
æÞ°R^ǃ°£¸v÷®]Aüíd(
˜Ô°CîÍÍ8¾|8V
®3© jÁ+Ðrˆ,S€Ü&îÁøe{Ð+È
zÿÐ6'²ñëÞ騾©üG–îÈ,Ýáe•‡W ®·W§„áÀu% œ`&-~¿VÝÇø~ÎD؉°7© &@"«Ì¢ø²ÛR%œÅáhÀg`kXk=LbÓ
¼€¨C礪* ){£¾‡<
¥ †îÎ b—¡Wã`ly¤Ò±|¤ÆE"2Á ý~Ï´ øn[´ÆÅx«N}g†a†ùâËRƒ”¤KHÊï#£nèýbâžARvÑ( 97WãrbøÚ6F‡9ÐøQô cqäG®ÂɈŽlà ¯ Á#5jS˜ZšáÉú®øýð#¨åõÑ|Êxšd"ýq 2ó0u2 ¤Ç&i^œS¦À0ö]ÐÈ«:ä \:ö€Õ‘[ˆ×m5 … êºÚBß .lõ¹µ+<¦#-%·c3¡†ü¾ø=„ÝùK$¬Ýº ˆÏˆÆû©P&œÂþ{r|¶øgLP.Äáh‚cûIXØQ†;³ãqÑÈÓ° ¾Þ´£láçáüáéçëÌeöè2u4\£ÃpëqóÚh=|FØÄcÍ/a…êŠuÑVN–~{ -_-³
1ÿà?y ‚„cµìrPu:SZnÝ(Z¡¬Ÿæ9‰¸wû!RÅÚ kx¢¡k-¸ùuÄÀ1cѱFt … jñc*²ï¢íÌ0 Ã0 S JÙ^GJ†î#©Ç7G
·É =Oãl§>½ê“¬` óÔtìFõ‹¶ÌêS4ú»ÕÔÎÛŠÑeddÑåÿ4¿ý¯#)ÊÚŽRÏ\z|KÁóNn¥ùñ‚
Ôª†f»C=gòxw1
^pF«o8}¼põìÛÌ傶eŠl“ÙôÓ£ú7
èÕ Ûd‚ / z‘gÛ‘1@ЫCŸDPéœFöÚmµûѼý·é™ö'UòMÚ7¯/¹”¶
äÚÒ·„¼6
]~„n$äjkÉ ˜‹Ûhfo—b6¯Pg1m©µœ²…"žjþþiÄVšÚʪ”r/¯sq1¢Ö¿–³Mf™:ß’"Ê¥'wÏÐö…c©]
}ÝÇTdßEÛ™…………………EG Þ̃a†a†aþ+ð—l†a†a†|†a†a†a8Àg†a†a†|†a†a†a8Àg†a†að«ÁVîÐ0è]¸XÊ^}o#X¸wBà A¨mU•úHaàÔ
îCáU× ûÃ0 Ã0 óŸ ðånh:þ{t0 ÎæÒR›7lñ+BBËÈ/¨mPZeú°î²
cCÏaèV0¬Œæòºðû=: ŽZæUà Æp ´Aƒ'À§Žøoré¸CØÑÍâ ÷³-†a†a8À¯$UJ"oœCtäãò7äÌ`׸1ÃÒ§%ÌdoÓ(YÂòf\IVƒHä«[0¥¥žß2IaÙt4– ¾ƒ%( I;1£“=*o&Æ^!8œN »3à¡ÿ´¥ß ³" DÅåd°õó VL™
ÑUç²úþâMg½ïÁ5c?~9™úÜ+ ¯Êô«´¶DöKŒ>Ú~º
ÅÆXBâ*éì Ã0 ü¼â0™{kþ¸Hí†ã½ï>‚e™EŸàÎÚi0oç†ìK¡HÈ{{†Èùƒí8<Ïæ@Ï@«)‹1÷ÐV¤ºuÄ/•€¼†/š‰vq+0µï <Ò÷Ä€¯çaú.ÜwéˆßâT:·ª¨?ÿwì;x—ü¡*Û’ÁÒ¸;§ ‚ƒ FzÔÓçÁ²˜2¡£Îeöý…˜Û
×FÚ¾ñ8JâÇ«2ý*-Qý§žM œü5fN팚 žTÆ7†a†ymxñ·2gò³>Xr†&…†SHh8}4w5¶ó }A[Æ 5õY N!¡»É¿†œ ª>ì(…„†ÓøÑMH èûR—¥š¿ ;ÿ } N!«ÒÀ¡=ÈR.kSj7œ†††SHè/TÛ ¨>2lñ+…hõ)µŒö³¼Fžä=l5XVPî š9¼íäš2ú>Ôé'Ío—¥Ðpš´d u j@
¡H]z5¨NŸ éý%—´e¶Q¯>íÉL¯ Œ@r§þ4ãˆÆ>ËÒ¨Õšz‡vq"IQ½ôë“ß”Ã4iÍQêßÓ“ä‚ŽŸVøм(¢¬½¨šDsLbLû³‰ Îñ&EAßer’ù;£–«(‰RiC[ãâõIí¨Wè}ÊW>¤ßÞ±/ö7"±êHËî§Ó¥¯¨ûº¢»3ÈC¿ˆ«ª-“@Úž‘OÇúX–Ý1eÄ|²Y¤Îõ½¨(|æÒCJ¥f:—®ý*µ-1ý¥‚¼¿½Nñ—7Ó—ýÐÊ8¢¤UþdT ß`aaaaaayõRú ©ì<Üaj¬€*é. ?…žM#4xÿWôt‚´w
éâ¡”XþÍ×èì¹ îþCÔ2 Á .Ö£}ëF0“>Fâý$&äÀС&$ª³Ê¤"59‚±+êX„Öõ´ $Ö¨;r=ztkki D"Û¨6\ºý€þý¼ FÍÑ~òçpw²€ ƒ”tŒÊXì$³ëˆ†î–sÔhÓ–zºÙMZ9já¿Ÿ†Ù¸£HM?‹©6ç°é
àÐ6ÚÁ e TEzgâX&ˆBx\n‰Lp-tîR 2©‚‚já…Õ2¯Þ€>á ¢ç̳x¦.eDª¨-ÁÀö¹È0°‡½¹¼Ô¥)bʈò"1:‹è{†Ç{á”ú'V{¦óxéÖ¯ÒÛÓ/qúäàòž°÷ €Y»#‘UÖI¦“}†a†yUT°?7V¼õÿëŒß¶Ý EõnCQMç5·OpevW„~Ñ«— G> ãƒP]!.ÀϽµÌ «¶ái™‘°
ìjj‚ô„mã±iÖûXÿY;ü8z8®ì˜Òk§vÇž»¥«¥|¼a— !?7 íFr¾n–Ó³ª+¤#öq.Lk¹À̸\L³—X9—zà ¨;«–âÑ’±ê^‰³.`úÀ‰˜;wN;¬â j¾·?ûíðћ«qãVé¶ =3+dÅå¡íÚkxô4yÑÇ°xP=
º•Ñùf³Tuì»AC P)»Wã|šîã¥S¿ÊhKL¿DûQKžt÷
†a†a^
"×àç"åü.<é;Ö&õak"Å£LÝÒjdÝ>„'h
{}'X›Èð0»Š"e4
¿^õPmàvŒïxwÎìFı=ˆI.K©4$?LêÛAai
$PÔñƒ ´C§oÚ•´ `¢#ÛÉQó#î g ” åÝCØ¢®{éfáâT/8-’ >* mBJ+#ÀÄg"¶ Y ¯CÃà?åo¤¾ ˜ñGáÓ#¥ÜíUë…ó›âø˜úØŸTQzöåÚ€¼»‹Ñ¡æb R;5CðW«°rýq˜$ºaøAÍZt1eÄS¶Îºõ 0ô‚¾Õ“±kõ¤Wb¼téWÅm‰ 1þSN&@Gû0 Ã0 óÚø ©ó¡¹¬K š`]Mš*dº¼ª+‘i ¨¡.ƈ ÔÏ Axñ&$i×P¬‰ì ¯–àÚÈnݼáÖm0.}?ß.=4Rççkë ¤Ú‡©{pdÃadeT)ˆÏ$(
”•êAòïW˜Ÿü É0A
{#H” ˆŽ ±‡ƒƒ!ò)…Is Ì[LÃþÃÓQmSøÚŠh^D`Õ~Þ±46?†rsÑߦãZFFÕöÇÊhU´U2¢NaÕ„hÒý‚GøࣃG¡s™r ¯ ué; ÁgX_Ø'íÄšK• /±ý*»-1ã®»>/ë Ã0 üj*Ü&SHK`ìÖ V ‰'é*@•ŽŒ, °…}M±ûrËaáÛ 6 ~ Ïž”Ÿ¡ÝIÄ
Vfšu‚ž~± šrS¡‰]¬_,#(`Rù77ãøòáX=6»Î¤¨¯@OÈEšY¯# ̽a¥¼ŽaGq/ì(î]»‚øÛÈPæ#ãá}®N½QǺ‚»¹+M܃ñËö Wôt¼!P%œÅáhÀg`kXkGKbÓ
¼€¨Cç¤5¡¬Æ@üºw:ªoêÿ‘åÜ2Tk÷1¾Ÿ3v²b·O){£¾‡<
¥ †îÎ b—¡Wã`ly¤ª¢¶Êr6IÅ~$¦Liš”«³ø¾ ŒaXo[$îEXFåÆKt¿ÊiKÌXTZ ¼„}†a†y¥TuY¢ÁgÂ1I;[H¤ŸÜˆø B$n_MEsT öFv}©µyõX£ÁøMpRÛÂÂÊ€ñ{×"¾Èû”vQO [ëZh9{ $Fúç°cêˆÑ–£ôkxØÙ9Ãÿ›=pO‘ÀDq ;¦þ1¨æSÖÀÓ$éc™§€©“FŸôØ$ˆ
?ò#WádDG6p€×„¿à‘ƒ µ)L-Íðd}Wü~ørn®ÆåÄ6ðµmŒs ñ£4è;”a`û.häU r . {ÀêÈ-Äë’íΉÀÒoá£å«±e¶!æŸü'/Ap £–]C À~_ü€ ÂnŒü%Öî
aýsuF4nÝOEáB(Ã&øzÓ"Œ²†[œ‡ó‡§ ×Æ«Ò¢pëFÑÆ`ý4 ÈIĽۑª¬º¶ cøNú Ó/!üáS¨Íê ݈éi›ˆµ«Ã‘)ºŒDè,ªïL|G —M<¶„–¢ƒ¨ñ߯rÛÓ/Qú ‚Âu]m¡oP¶ú€ÜÚž
Ó‘–‰Û±™"}ƒa†a˜7 À²“ò`hg©: ŽýˆýÛ®" (1Æã¨ôK4ósƒ±@YÈ|t o%iÓ¨’ñ8âª{Ô†‰…3, ä']ÂÍ} qâØÃâAwþ œ_öÌGŒ†ku+˜Ùd"íf<Ô… x”‘¸¸ì{˜0nŽ6°°IEò•PJ@ùqgOÀÖ· líÝ`@™z‘§Váｑ¢|¨â±¤?2;ƒ_«Ö°·v„9 åÓx’§Í²æFàäwãûîGðöqƒ…ƒ ÎBVâ-D=Ê(¶ÜH ·zÁßM‚¸ãûD.‰(fSÂúæh:þG,ÿÜFl
†y=ÐwÅ{³—`z§j²5ÞâùÙ MÆÌÇOSÃÁðÜÂü§|‰ªwœ‰óObRh8BBÏcìÜP´÷¶q‹_^D~Am6hI#´ìÑMmJ9%–hþáŒêä½GX,Åݼ,„ÍlƒÊèü6×›Û+QãÎhQ¸cøÿÆ£¯‡ñ[ùïúÆKŸË+øùãºÔ,óKèR‡pT ÇzÃüíš1ÿsþ#~L+Ñ÷·jna^ã _#ßYè;°ìŒ ‰±¡4´‡B™ü”0DÞ8‡èÈÇÿÍ·t¥50ü„
D„«“]+ €+<&aË Ë0¸–üµn#§pÑ3@]O{è¿ö:ËàüÑåçmQ ê³"¶ûúnØ|è–ø½$ Éâ8PâJ´(HÔAÿùûq+E㇔ ëa€“Æ%6=±án:TZ›dƆc÷‚ahd&©Ô¸ÿ+ h7g‰sx8j~fÏí6>ƒúÜ0Øÿ‡¯z‚UwlŠÊ}îÇùɸ}dÆ4µx…û×Ç7DSÁyñožËª„ínà¯Æ]ðýÝWí`–èµ7ôøg4-mÊ=¦ãåá@ +²éh,;|)JQ>’"vbF'ûÂ/_¾qs‹è¾W嘾çóVQΗlõaÞ d ò/}„ПO"§X$¿Ü¤vÃñÞw Áò?f=—˜Ð4Žê¡ãè÷á¶ä+Dä¾é½R!ö×®p‹pEÞ0¤¾1z‡aRËa8’^¤'iþŸ>5
Ðø›ƒØü °õïbüñ¨lÜѪ•
âži¾@+ÈmP·Ž1nÎè‚œ|{bü´5¸Ôµ!Ú7ûGŸª_Ûq×o? s‚vaПO ÆÛ g çšrÜžÝïíL…±ƒ7Þùß,=îu½ ¬(òeaž*^ü«(Ÿ"òÚS@ö 2_±iè.l
:·FK=œ»—_ˆZûu‚+Â1ÿ|*H^ÃÍD»¸˜Ú÷ é{bÀ×ó0}— î»tÄoqª7onÛ÷* Ó7õzʼMPq‘a‹_)$4¼tùérÐ^^j7œ†††SHè/TÛ ”º¼gÐ{‹NÑDíß¼`=u ò!…¤H9E ª?`1½¿è¼¦5giÌ÷k©s€3Iµe#Oò ¶šF,+Ðå š9¼íäÅÛÔ¯O~SÓ¤5G©OO’ %u#úÔ`æ=Ê‹˜Jž^_Ò-u,-jbP¤†4û>ѳíȸà˜YO:JD!µI µ¢µÉT*Û: @¹ÐÄ«D¤~BO²µ¿E ¤y½k’¼¨>rGêöÍ t=…ˆHMÉ;é뮎ÅÊH,ýiÂÏ;éôxJË+hé)œRŸä I > E•8Ö›ÌKö[„λAtLI³Ð—
ÿÖŒ:ïÈ$ŠY@•±wY"#ç.ÑQêiVv9iõþ´ñN*åkuÍŽ=CkÆ4"Ó">&1kLãBÏPt¦¶*“â/¯ N–‚è¾WU¿ ›¯ zDKüŠø ¨Éâ8¢Ä•Ô™3}t™H}¬/Y–Õo혞 ¶&A{L¿Þ$:§$º;«!é‹ wþSU}—Ø
¡³ªlºúw å=X@ÍŒ@€1µÛøŒÔ熑½DܘxE ¤k~‹>IÖ짻Dª'hIÏê$+hSfKm>YGçâr‰ˆ(?ñ2mù¬-ÙHŸë${аå')6—ˆ( ]¹JiEÏåªì; ^$Úc²Z Óe"º0²†f®3·Hl©óÂCý”r´öI»w€æ÷q&ý‚¿QF”oˆi ÈkP×;èê•öüJ£˜ˆôCMa_«DDœbÏå
ç‚ù9í2…Ek&èÜØS´rD2.y]‘9Ѹð²Ï/1~X"s™@—IEÇß³nwÁ’zîÉ&Šø„êèi}^&/¼¶ £–«(‰RiC[ã7vnÛw1׋ŠÆTlßÿ¹……¥ÔkNiñ¾*% ‘7. ±àî5ý&bnœCôsxxõ&rTbï ÔÈÏÊrâñäÁUÄ?JÌÂn~FP#KÍã2YMøLÜ€ÎA`m˜€G×Î!1K Õ¼PÛÕFóèZ0‡Ë°åhߺ̤‘x?‰ 90t¨ ‰ª¸22»Žhèn A0G6]`Y™µ5Šú<Ø+¶âÖÍX}Ý }ßk Ûú¬‹ø¬™;Ü„d$cÓÀÆððð€‡‡}|Å1»0ãýnê>‹ 4ÁäíÛ0º¶VqÁ‹Nc÷W
qmÎ@tí6?ÜöÁ´?Ocq€Eá#G™] Æí ëãs0ºo'´o€ Þ£ñý QÈ JØŠ¾õ=àÑ°#¾½SyÕIcýE FçNp.xòmà†®M
ñìøŸ¸ó
¾É¤J¹„u_
Aç–ÍЬuwL9h…aKÿÄwM Öº¢Ùܽøi€
Çt‚ÓfhÕy¾X¾w2H÷ñúW2ƒ)¸v%‚ï‡x·±¨GË {g æ ÉGà¾pÕ9î"ü§jÉAÄ cƒáX,Q»Ôåo©ž Z9Ç`V×–²Ï ïsĶAùWMŒ_ñšLÐâû8ö"æôG›í0hI Ú~÷¶¬¥y|)†Þ¡'°f¤5Ž|Œn½Fà‡SÿÚ’uÖSdè‰ cHŒQ/ žyë0¦G‚zÀÏÑMñɶ ø¸ž\tQ¾!¦-Á í~<…?§û"rÑt ìˆnÃC‘눎î¦Uû2¡˜óBä¹\ñ¼Q`ƒ,œýq$zv ÆGñÁªãXÓ«šx ã‡Uež˜}ØxC‚&Á~0/0ŽI#·TàΖ½ˆÖ&¶I™‡çWN L kÂQË}cç±}=îå]sÄôýÏ- ƒ²£Cr }’BBÃiÌ0ï2ï6ËÏàˆ@}322«F5‚÷QHh8åKz ÉjA£CÃ)dõZò²‘`@Õ‡ ¥Ðp?º‰¦]™+ùÏÕdîut!™6{"ÈHZ2“"¯C&ì¡–ï£wºÔ'½JdðæSTîEë,#@ê}~ƒÔq‹ÉÏ@‡ ¾V ü–У²µ%2DEîþeµ&Ð":§ÍòIkŽ¦sDtkšÇóŒ™~šq›ˆÎ|HŽÚ Ü}Ý¡Lú¿@“
2`dš*Ò2r}Žˆ"h²«ž¦m·ÿÑMÊ¡½½
³=U›Á/É
©£Wöß™w§½¹D×?« sê¾7—(v9u±“•Ûfù}¯Ê ~dð’˜ûQÈŽ¤¢ º±k!
¬MFBù|@AæGel§@ñã.Úª$ƒÿ”Öµ1'çQ'(+ñW
47y!ƒ_јší¦ õqêk 2é´“²Ô')ØZ “Û(C}šWHZcRæС÷ª?ÏV
ÖÔï` Ñ• TK’¹|LáDtu²ëóó¶Œs¹j3øRØzÓà_"‰”ç)¤®\üÜRÚ¼á<žÂ‰è⇎š¾Š)#Æ7DÔ#uü€N«‰"g{“â ¶¡˜ó¢ÒçrÉy£”¾C¯ }zˆ.Ž#g™Èl¯?¬:ûÈ©þ—·ˆR7RSmvÞ%%Ð=ú¦~é×»º#éϧD÷·!sáÍ[*Ó÷ү⯕å•ù7ç‘üªDó¦Ÿ#xQ&.?†Q?îGÿNvš œ¡$PT¯¯Ù‚ìÑ!D%—±†R;§nƒ T¸ ãç…¢KŸwPÃD UÉEuy÷¶¨+–ŒîŒÿÛ{ù:¿¬@ý}awu
öÄ*äãÁ ›p×¾¸+þùÄí“[x
X8Z@Àе=Ü# 0·’‰}‡â÷vpý×·-P"v×R WybHOgèA
[ÿ ¨§Ævõ(ìyü·/À„îî0{¥å¤`ëPøúújÅ C¶¼°f #IDAT¤ÏǂÞu`áÖ?ß«ƒ‰{îáÑÉÙho]‘â^”x¸~
~É€o‡Ô~a—’ŠÇ´¨¡Ô ©•PC© À n Hõð[ ”/¶ª“°¥ƒ `[¶z€Kk¸" 'NÄ"ÿ_êy“ÕqP‘
Ù áX×/³»ôÀâ;/—ËT&ßƃ,À¬zÙs1e*Ó–kx
‰8´çþx•?/^ÂÇ
ÈƱcºà"òr Æ«Ž¯jǽÊɼˆ ¾9÷)“ÐĸÈq‘cú¼o*¨”ª^Ö $aý€çK4
ĽÕ7¸š€´7’Ï*7¦µGO_ô[ù d\H‚²È@UnnQC©‰PÎß•QFgß(^ •C
ò”ÿæ~j:ž%ÑÕÇŠZH "ÑÉ Q~X•anäv¬¿m….ï6„¡Â zVGä†M¸[üÒoÞb:ž^€º;ûÃoÐZDV´‰Ä0·TØ÷J{%®§¯`na˜ª
ðó3´'+X™iR‚ž>$ 1¯ S@æ œÿc3nž?€{wŸ»PäÆ]Õì†R½Ö³†Las³N
˜Ô°CîÍÍ8¾|8V
®3© jÁ+гxöOîŠF÷`ü²=èä†ÿoïÌÃk¼¶þ;'ÉÉ ™"†.b(EÅÔšgª¥hK•æÞš‰Ò^\\´ÔÔŠÛjS-ªÊ§†#Ô *1FHR$†™d89Yß 9‘D‘¢¦ý{žýxœ³³Þ½öô®½Ï^k[slé*t¡gÅXu«[`"®Ï;«©Ô£,€ì›Ä&‚må¸q€R2SÉÄ7û‡;iy;2˜pFÈÞ.Þ«^²®stí\Fv¯‹W1œi0–þ• Ôöz¬/¯‹Al<žu*bsŸ~«Ô‡ZZðçêµDf¯Ýÿ~²‰ùyË5o3¶¥Cþ ²8m
¤õÄAלUñ…M®ÛçvpJÜhÚЂ˜3ᄇç§3Q×H¸ ÄiÓÆÅÇr1ûØ ¬*Ó±'rz'QóæèI×6NØÜõV5¥ –°•ËšegpëÖF
zÓÃ+‚ÀŸÎQp:0/Û‡e›'QfÕ›4ñÿ… Ügbn)J÷â´ûÚÔÝŸÄÜ¢Pä‘_!’|‚‹ àîZ‘¦Ÿn¡Ö
°µ aÝØñ\Š?J¼¾'¶¶é>Å‹ØËIh=*~ÅÇ®äЩ7hS³É¿ß¿ÁödÊY àÛ•d˜ÐK¶eýËRNN›ÌìYzJŸ˜ÊªÈ‚½Ç–†ãçÐU³ÿo¢qQ×<5Rcˆø3?œä³7·¡{qÚýAmjŠîÅš[ŠÇ´Ã#8Ù‚V,}Þ•.Ÿî3†¯Ü' Œ &^Ö3±©á/]§ß “xX†Ì]+o¾^=?”ÎK*´ vƒfK§÷ÇJÛɹá2
¬›û\‹
âûö|ywîÁ;á:‡±Jºõh-Ž:Í_Âd¾òñ. ü]z½^«xa2µ¥¥ï ƒÈ¡Ræ.g?‹*cä´do?c.·t±M¢Rò¼#3$!jŸ|ÕÙ£°:©Øû+ÙÙdN]Ž,l'.Úû8qÙ·’Õ)"QSjæ;Õ꼥˴ß$")WÄ3›dZ—¡4‹ãÈdæÖZ¦íŒ‘LC‚„.ê ®ZË\ Ý]»þ"I"rkUû;ÎY…“…TsÊX?‡ä=Oíc “iåó¦ÌÜ|Z®çÅñËI—›±¡²¼oùÜ>fæ.m§m”×2îø²fÄÓ_—ò–uÔ*Z÷GÓˤ0™ºŠòÖŒµrþ–dŸtûÒYýŸöâe ÷¦uë&+£R%'ïûËÇd㥾“¶Øínzÿy4Ýólíò?s{CÖ§ŠH'Û¢Ú´ “mAùv-WIrNr™¹I³‘ßÉž?“‚²%ñÜfù¤¶UÇ|/iÿŸ5v-/p^–܈Þ+ :¹ß5–K@÷»Âdbá#ÃÄpdä0~EÎ-¦Ì¦Î-Eõ
åhÉÈ¡rÝ` xò´¤ŠÈñ>ùó|IÌ &Œ SÇr‘ó†Ö]:Îß+Ñ7òb;ê%.tµŒoçuÏ÷¡y™®òåþ«¹åÊŽ—£‹ÚçÏ«¦ôÙ3óÉ9’Vù€ÿ]NÕ•eôÉû8ùÇà³8·˜¤»)ínj›šò>5ynQI¥Ç’žp4Vbcg™ï©oî#
¦æñýÚ{—l e•J4骓Óúó2ëåûG©Ð–j(ãf‰\]$lž#ïôçT/¥»Ò½$’y¥QrBôôæ_#k©:T}Lé®’J/€¯qì"½¿
“¡³VËÛ–KÿùÆþo¾–Z.fªž¶ Ø¡Š4|¥¾4ê0D–Eê%~ÕëâqŸËZ¬+¿)ã¾Ý/ †+²¢G™çfÇâyÕKé®t¸d'uýÇÈ ^ ¥eóæÒºû ™·?U$eƒ¼åi¦êPõ1¥»J*=‰–'}>Hc¦'þìy }*á骅œdnžÙAèšùœºa@ñtaSg ¿ìñ§\N¡Ë‡ÒjÈz®Ý¯™ìªPÃr cw㇞›Ö|^õRº+Ý sg|_íË”žµpÕ9IDï]Á ³&Î êPõ1¥»Bñ$ìkxL¡Ë
…B¡P(
Åߎº5Y¡P(
…B¡P¾B¡P(
…B¡P¾B¡P(
…B¡xÖ
|K\;.ep`ýßkvÿá4X:ùà^Úá ^wŦñ2Ã
¤o¨dýz=×ØÑhæI22ÏðeÓÇ×n[ švíÆ+nfjÄ*
…B¡PØûØ$½žs4ÖxÕª‚¥®5½m ›oå;ŠÕëónEÝ£›jýùé’p}il aØØWïÆÇ_o!,6CÆa—/Ð,k1-Z)œöõvͯ£"óXRñÍi¬ùã2é"ˆdr5t5ÿnáF¡eŽ)ÏR(
…BñBñøÍRIàÜ÷qlQô£\˺¯íõ dFÌc}˜y ïôa8?ª^Ï3ϺžÕiP]ËÙ£qä<ÅEµpk@ŸþËÔ± ($<ôÁß—³mn#¢W,añ¨/¿KdÁp€f¶8Û@äç é½ò2Ù ärñfþ¢±È<²ÍíHÜ:÷&F“Vª='Lç³MVD”ïƺ1ýY
…B¡P(”Ÿk•¥r×hüZ3\í´Hj4çw/b׆`’ôZlêN¡ßðNؤneÃøñD%ƒuÿÒdg¬o®á— Ó¹ñR ú×Η٢*·ûž÷›Æ…óXÔ_ÂÐÀ¼ÿ…²iè@Î¥™¢IêøJƒ>ØÛY¡ôñ¡Dl™ËžÝ§É̳v,+QýÑ4j懓5èãpzãlöí;G–IÑ_ËüW½òÐa_³7;÷ rUo,5€>k‡ç±)piÆóÁ„ ØdïgÃÈaD¥ Z÷~ôý|.ÊÖ ÂoÍfËê4 ¾&Õµ\^?Œ_7œ2±¼JîÜ„aSÇЫM#jVðÀÞàûÇ6¦å¬3d˜»óêˆ9Ì x‹†etdÇ gÝÜ‘ ™µ›x£
«q{›}×Wи€ìœ]qn½‘¤;íQ´ °Ä»ý(>àO×Æ>”Ò@NÊ‚?.Ÿ 'ößÇìá=ã*khÈm†ÿ2mmJ÷"Å$Íð õ=3Ûba¯Þ”ûbÝ ÎºÇÞï36L÷`ž_Uf K½·mf‡}6WŽ„z"ñÞ¢ŠÌ“MìÏ#ùçÏyÿßÎÞ¤Wéý[MxéX—iú³
…B¡P¼PÜûˆŽÖ•ªþËéÚùU\Í.sý|4鶕ðé<‡·zÖÁ‚ n ûœM;.]{: ì„C©Æ¼:°3Ö\!lÉÕ}ñõõÅ·N{fFÝm›"Çœ²ïüÄñ-Óé ß´=èÔ®ožÁò ØÜòÜþƒOÕàå>«¸Á
Võy9÷™¾¾Ô~€4“5ÏàØøš”~©Ó6Fsûa·¶µîtœü!>'ÞÛx™,É&åâ¾\ŸRF’ÆÚÒÖ™¤Z—¦´£îž?N™’§@çÆÞ§5CF7Gý+£3 RŽB¡P(Š…¿^o[>@üÃ$`Ñ\ñõ.-öΞâXó#ù 0LMoKc^]5i4%TCå_3J@`˜ èU[tšÂòÌ<HÿÀ0 üF*YßëJ]¸÷Ú"a2lÈ+¢{˜ky-ëJ»…a¸SZW²°×N?K@`˜ÌŸ$e,‹ª“eP`˜|(/yèÌÅ¡ùÿdD`˜,œ&ÞVÅ)sylšHçÅaxTÞ}£¾Øh |§ÑÿuŠC÷K@`˜üóm_1ÇJʼ ,aò~—Š…¯êÖU–z#~“aK¶È «‹…¦øu¤«1QÎIšü_û{ëSv ìÏÎ ¾® ׸JÏ Y"ÇGHEó{È5÷‘‘'D A]¤TqäØ6•o®‹dï *•tE\aÞp\‘+² ¡õ£_ßl]_¾¼$¿´‰ØÞ«¬ ÄÑÉIœœœÄÉÑA¬Í
|o×JV§ˆÜÜ:Uú¶i(/Õk&}fì—Û’,ëzxˆ6¯ž« — ˜DIÍÑÇì–ùïüCl
´™)y Ñz¾+{y$ãLzÅA4_ŽJ*©¤’J*©ôâ$í½6õm*7Ä Àºí¦lÆÎŒ~ k/쌖Á‘¯fqÅ ÁÖÍ
â—±ùדÅ>:òxÈ$ñð†Ü³ÖöÕq··Ä®J ¬.¬#òzMÊñ\°õ¥ŒSɹ÷š»7¢´`8Ä¡mp»àu1V$se÷>² »—ÛálíEùjNÀU¢Ž_.|UwV¡ó:±àÃüßæ3è C [WmC-3KZýp™ì<‡ÍœxV·¶ ÷ª¸[”œ ¯&4qƒ£K×rþ©ñ_°¥É’ ÜLL$11‘Ä›ò•_¾+®ÖÎ o;ˆZû?Vî8̱нü4ÑŸ‘ötÔ gãöyVä|Z—sÆÎÜ û
M´Ýƒ¡Ë÷ðUk§;;ì¦äȉß@¿zhÙ}_ ¨Ìä}»˜T/¿L¦ÊQ(
…Bñâp3ø4fFþÖo¯ØIjAãÔH\ZÎŀγ¥òζ¸Ô¥¬«Ž¸Ë™wýD/@ó7Z ’£7>Yk|®øÑâÁ2Å~~°^Ú\Kä²2£Ö™Ú_çöÔª•@iwàÖn"ãþ~«W£Ñ¢!žå½Ú3ýTFa]³np!£åHäž&WÐtŽOïB« sÏ®å¤{2ß±B²3ÉœK;`¹ 0ý5"®™k Ì !» <©÷³tÄ@tÙOïu¶#˜TŠ‘ÇÌù!œ?®8þ¹‹‘£0ûÝÅ“£P(
…â…á ;øn_8M:€ãK¸dŸæ|è.¢Bwuê8qgO’j4b´.h7¨+¶9g ?r ´µi>x –w™·rÏTãŠK©Üm`…%ZM¾©lÈÔ`áì…¥±TZK[Ì bAklk±«Ö€ôhR2I<‘«W¹.ø¸˜: 뿉@Ú)®$êóˬO5F$q¹O™ ¬WvüáÜÈ:æ~øµ©‹Õý’f 'lïUÀÚý㤠ÞDÂÝö½®
õFþÆÐÅ¿ñzûjX<†…Òís;8%n4mhAÌ™pÂÃóÓ™¨k¤KÉÉÑ_=DHÔÐòEü2 ™©db‹›ýãú”CRÄ~‚ƒ‚
"(x?g“òq’IH,Tnç‡GÞ¢Öª"ÊCZôYnd߯Cj‹ÞM7%ÈК›=š …B¡P(Ï5÷´˜ôÑKÙw²-mjyQgÄ6|oÅ’šã€ƒs)–wbåÎ+䘕¥æð±4peÅvì±âVéÕ4.ëOûöÛY±>Š<{GRNq!<=+ÐdÊoÔHÔbou˜ucÇ› '5ú,Yx£óùæô'Yo½C4[>Ddjqvy©õÉ&¼ã
Ø{ºc¤ìû‰¸Œ\½D´§Uµ´™¹ƒWµ8¸8 Ù\Y¿”+~xä\L w׊4ýt µn€eëÆŽ7–¹½Ò²ïÿ¨л.îݾcp§D’’‹RXgoaíÄYänÒg‘°ëG®u‹‡%p•ˆýùuw§¡Jw¤^2è Ÿ¶]q Ž ¤7ù
—VóñüOø}t0»§²`Ã1âô¶”©ZŽÄµ Y £/99©‡˜:n=¿^Âá µùü» œŽËÀ¼”å-ö³tey{ÿ™—B8•þ ¯6™÷§m'ÎÜ‹ª‡øzY8é¦.ú¬<©ZÅ K몸[‚ε
5k§œÍÙKi¦…øÌ8Å7 Ž0óK¾ŸÈ~K¤Êû_1Âû" zï3F²£þ¨ñ´M9JØ…›ä”ªL‹“ðw¿Î÷߆ ƒMÈc^šŽc?¤JL(WSÑ8V¢ù€É t‹ã»oBM—£P(
…â…ãÞûʆ˜\ð¿®Û•„4Ì ½qt.EÎÍp²´h0ÃÞo<¯UÓÁ•¥ìü=CV$G¿_N2àÒu 5
Þ:š Í ‹g›æn8¹™‘ôçy² l‡g†ÏfÛŽPRô`æè“«-W/!æÅßLÏÂÆÓ ³œx®ç—5'ÐçZž Ÿ×—mÁ”刃‹Ù7Â8¹¬ ë‚.>ó®?ÇáÅsˆ¼’ZJ¹Yqûr 9·ð ¨W7¶âûy_~6† 3¥<+àèb>-³Õ““°™ƒGæXìJN^þ«åž ·“·€d.ïÙB¢þ1ôIbÏèF4 õ3·_Ç÷붰uÓÏÌÔ†êŽEÄ’âÊÑs~iwêtÈËNLZ¶ŽÍÛ¶°!p2ï4öÁ¾@Ï”›>`GËá»
[Ù¼zï6ð.ÖíÁV¾c :qœã!+èã
Ý9tü8‡f5ÄÆd)Yœý¢3í&á1|-ûìfIçëÌ{«% 0 †1³ÅÕó%Þžú›w±uÍ—ôó á³ M dŒMoJ
îåšñ¯9«ÙÄ–5séëq€io4aÈÎbÈQ(
…Bñ¡çÄ°¬K»9ßák›È‰iŠÎx†Ê^ÆWÒ¨L.îÌúÃ7žF±¬É”Ó' 8Vœ¸ô
…B¡P(ŠÇD–9TVuñw£ÅÖo>½ºº#vUp²ùs1{BŸvãÞ‚ò½¦1Ü'’Ó Øù
cx¥LL<ÍmÕ¨
…B¡P(Ošsà 2🌡l[Æ;Ï*˜“AÒÉ ZºœÄ짽Ü:\*þƒ¶#†àa
©žÕ“÷W_Å U¡P(
…âIsPt6¨ºP(
…B¡P(žyºæyŒî^Sõ¡P(
…B¡P<³ìZäøuÉ=ªc©êE¡P(
…B¡xæÈü€°¼@ƒa@Oã
…B¡P(
…âÙ2î{múBqð7þݪŽ
…B¡P(Šg‚ÝF~cÞ÷»Eª‹qà‡Š°£P(
…B¡PFÄc¿Q/ IEND®B`‚ stem-1.6.0/docs/_static/prompt/run_events.png 0000664 0001750 0001750 00000053274 13124757507 022033 0 ustar atagar atagar 0000000 0000000 ‰PNG
IHDR Õ ¾ ú óÛ sRGB ®Î é bKGD ÿ ÿ ÿ ½§“ pHYs šœ tIMEá ¸‡¥_ IDATxÚìÝy|TÕýÿñ×5“™,“HB„M ì(îVܵâò«Z÷¥«µ_[—ºÑjí¢UÛ~mëR°¢VÑ*²#$$}›}½s~$°æÔo?ÏÇã> 0sçÜsÎ;óž“sïÕ0î`0ä"„B!Äÿ--@°xø‡‘i}<ïþ¸ È“>B!„ÿeš§€‡ÿá„꫇$L !„BA3pðÌž4 äEO ó§ôŸB!„8óéšýÖ¾O h¤úEà2é7!„B!è%àòÞì;Rýpô“B!„5Ž}F¬M½ž¼¸åHlUsåÄóÎçØ\³ìéÃ#Ä° n@©O¹i°ô‘ìS!„∻¥;?ïª]t”€½ô:^þ¬œUŸmä –í~å K_§¹ú÷œš©%µÅ”1?ào¯ÿ+†Ø¤û“ôa_±`ˆŽ©ýŸv”òÍ_½CE»ŽR
jäów ã’bëî WòϺžÛgñ,8
qÞû$ð¼R
—s2 ”£eqÁ[aTÓ ëØ»Š¶1?c«Šòî…Ùhêcp%+”"üþ·la÷¡|Ú‰•W3Ðd´ÎFú§o¦¼¹¼RÙS¾î¡fåBîš]€µ»‡~=*ð§§íýÚôÙÿ$¤Öqk‰Åø>B!¾|uçhz¾Áþ‡^Wù˜úÓ{˜ðæÙL~æt>Yþ g?} ï8¾ÉŽçµË®âÃNù‚_5:þV JÒL웨™|ÿ¿yù6x姗qëGµè¹ÇpÒI¹ìòÄ÷Y÷S~pâÕ,ñíy$Ö^Eàƒk7> 3&rÎ{ž÷ иgÖ¼Þ’ ÝCµÏ@9*ÌêW>…3OæÄ+++c»ßæL;ƒá¬ãW«:Q»Ow8D}z~ÏøÏþ'—¿Ñʾ-÷ªs2ýspš5‹’B~zßz;@ZÁæþô·<ðÖ0|#Žç±JPG,v¬ûü.×,v,„è é÷©Bñ•×£ïîy P]‹EÍýЫV_[ Ìî9êï§ê¦¡…ê¢EjçŸf)Ëîõ ,ΓԳmê€ü‹f©´žõlEêœû_WŸ·+¥TBµmø‡ºïì"eëU–)ëõ½'ÿ¡–mmTÞhO) jéí£÷Zï‹)Oùè‡jKS°ûõQÕ¸öeõÓÓ*k²Ûê£ÎŽ w«Wû”RJ…v.U/>ýŽÚæWJo] ?PW?©Ñ><ŠKŸýc/Só·+åYpšrõ¼.ã|õRjÇuµÍ”§Îüí{jÃÎî.Á[ù®úÕ…%Ê~˜õrú‚j®J ŸºÏs–õÏ”J|x‘Ê:èë-ªä;Ÿ)¥>Pçgôµ-“ÊÿË•R+Ô•LI—cú=õ™ÒÕGÿo 2õ<®e©óß )µá6Uj5VŽiÀ•j… Råÿ©UÑêߨãœ(p©ÓxTbåÕj É`
õOß‹¹àZµZ)µt^ŽÒº ³{@U©€zíô4¨Ì –(]_·O›2ç|¨ú{ê¼LƒûTYd‘EY¾:KS×ðX×{]‹:NÃf…§Œ£`Ìi í$xÊoxâØ·¸î–O&»×pÇqÇ0ùÒ…´ÑÆÂK'3fÌƌäï.# ¹™ùØ2þuw ¾”³Ï¹‚_o™È=o,ãw3Ý»Çë,frËÍç“óÑÃÜxÑÌ8u&³çÜÈC¯ï j´>&#gœÂÏ ¸|ö,¾qþÍ<Ûvóß]ÆoNÉ4¾-u¶˜ÆI%µ@Û-%·ªuJ©5×)s®gNS?ü{µÒ•_múçoÕͧSNí@#ÌûêÚ‡ÉT ª ›}W…R Ô¬ô®Çœ'<¥šT¥ºœÝp9]#Õ êùS2UÉ
«`ósêôÌ´äGª
õñ‘ê½Õ¨g.*Üý——Ôã~¯bËÔù.uü •R;Õ¯&9ÕÀ«V¨híoÕ‡ŒxÈ"‹,²Èòµ\ž0“÷Û± ¹vb>¹Çó×ÑßãØÍ–«?¦ÕÓÄÚ§¾I‘µÿ¢}êð C#KÞf÷`T¤Š·ßk„cNc¸#™ÒœœðÇ:ÚÛioo§½c;ONïãþ5¡
þ¹¸mìLÃÛJºÎ‰
“*' ³¦õ[}ú·£ûk·m ÕAÈ”N_ë!ѹŠßÌ)Å=ê"ž¬,åûoVR¿t>3röÝÒ:~tê¦Lé^&~›{g‹‡*'JÕ«/°%ãt.Ÿè Œ™w6yÛ²h¿!Y#õ‰SóÂíü)| ?¿r¶#Ú?}+¿ãT&L˜Ìô™s¹åñz.~åS\VˆˆûšðéR2'sõ™ÞýÐÌÜ+ËH·[IxðÄB!¾Ž&[€a{6çÌÇøãŒùñNàÑ_,aNÙ[ܸò)îzæ
nX ìÇzhûýÉY;¬¿A‡Xÿ‹s™ù¼£ë²&‰µB}¼F¡
4S’öN¢ÎJGë;ÕêpëÓ_ýs8}¸ô˜m–$Û ž ͤ ¡):Þ-ïðäßáOO\ÃëåæÅûþÉ°[Vö:ñÏCågkYëù¢Û:t9ѪWyaË|ç²2RWF¸äüAT=»-‘äÊÙ-°†_ß¿ŠkïýS× Éþé›oÇ甯oEñ)+>\Ò.žûñ\Šþö;vvî“°’}ì5Ì=Ï…w¥²àÅo3¥ÉB¼} ª…B|=
³Ðuáêý˜²góËÿ=nšÌÇ9¯c¯~‰uëY²3o
²C_³*â'‚“Ü4Ë~Ï·-a3ãC±¯ØØ5òk Æì™`ÓlK*Ï%ðT|Â’Š$^b Ìi§„ ³=lì%ÉÖÙ÷ÞŤw º³>‡êÃþíŸÃèÃ}Å;¨mgé1äZþï+”¢;Þã_[aöø!¤j+ í ÚD«XôÜfîÿÞ·8î TðÔ‚ þÔá8;_¾‹î{Ÿ Ï° müªô ‹Y¥“P ûi‹frâ
gX4‹õkü]‹¦ñïj!,Bñõä>HB³3óá§8sÙ-Lx£ðé»g!ÛQÉÐ /UMѤ¶©[ÉÆÐ \ðó{¹úÁwi´0"}O=·‰PíËüäïäýûþÅóñ;y~£™ WÍçg#êøßY¯P§ fO½ŸßæâÝ1†_r?¿ÓÉ¢ ±Ó`øÓ
Ô9ŸësÈ>üª½ô&–¼°õØüåA¿~¯–xÞI ¢_F},…\ü«{™¸í]>\¿ƒÎD#Îø>÷N„òŸ®Ç»WKgÈØ2Êz_ /ÞÉöŠø“ºª[_åD©zåÏlxð^~õHŒå°p[4©röûYë[ί~û9×?2þöOßÒdäÈ| 9C˜~Ù=üú¸8Ÿ|ç êu ÚBe „[Ž¯bþ[‰„5^|5Äm·¡òÁbò¡,„âëɘlížù¿ª¦ñuá s×c©eê¶77ªÏV•«Ï^¾V•Ú’¼mSCæ=©>ÙÕ}ñ´X³ZýÄ*Û´çòtç>ø¦ªðt=ݹù
õใ÷ºTžÑ¹ôœ çÝ 64ĺ.b·k™zêšqÊ¥%¹>êÜûDÅÞ¯sÍX¨¼‰î“Å ÖÇP ÅÅhÿœ÷ÐbUéë9a-¬Z+—ª'ÏÉï: ñ@'i¦ÍTó)UyÿØþ¬Þë2D}ó¡WÕÊêNï®M°nµúÛݳUµ¯ •R‘7Õ™é_ôDÅ”c)Q·¬îº$ã²ëö=9³ïröœ¨èÚsÂaî\õº_)•Ì‰Š†úÇÀÉ ysÕ«õz¯ŠUÆÅêɦ)wO]ÌÅê–uJ©ªÕ8{×c) RÕJ©eWäﾟ,²È"‹,²|Ýû ÿ%¿!†òýO«ømû\ܧþN©B!„è&é!„B!$T !„Bñ¥úïšþ!„B!Ä #ÕB!„BH¨B!„BBµB +îÄy3½T“þBñUÕ&Ü4’ûvNæGeà2¢4”
†™pÚïÇ:÷—£ÖöÿrÒÏÿ]lv¦üx'^â¦ÈÉûðHfÊñ%„P} ;'½;…_îœÂs ôëÈdað™i8ÐÈ;=ƒ,ÛáW¥à'ã¸ånºÝ‰õˆ¶º¿êÜ»áh´]ËÎdÞ˜_ݵ_¹s2÷~8’‹®v‘jîªÇÐßNä—;§pË–=û\³0ñïSøåΉ\r¬ékýv?jï±>÷…›+×õ쇮}qÿ²Ñ\ñ#7¹©òÁôýc÷«ò>ìßÏ̯a»„¢ Y¾p ‰(åwT“}E*·©û"÷Ì>Zy?ë|äÞô_³ZÈfÁ
w„ Úmä McÚ}#ÉòmàÏ‹âè¡`&Ûû²0‰@‚HäÿìÏÈ£ªf2²»þíÙÀo³1°ÔIÙw‡1jl5\Û†'. Pÿ…Ã_MF?3exZ!¡úð¸æŽæžG{ ¸"•¶1[øÜ·O€Èp2ýÎ"N>ÇE–«+œù*<¼Óv–U©ýʱ5‚vöüÏÏóelèìvÆ~¯ˆo\žÉ 7$:Bly©ž× í =ØR8î‘!œt¢ƒœ\ 7XÿÄþñ× á„Á:(@s9˜øýBN½0Ù¨š [Ÿ®á•çÂÄ£ÖvÍé`⊘ùÍtrÓ ºÓÇšÇkyç•=õ1.À[W°ªÉÄùc¹é
+E3R°,òvEéD¬W¤V{Bu8’Ĺ¿Ì”>VÆõsÌDßÚʃ7z 8\ÌýdÇåè|:¯œ…Ëô#²ßÚÏ}¼Wû_€_UÁªF…ãøbn[˜KúŒúÙÀ{õH
oñÑÞý[7=k'¥8€SÎO#w î:lÓSâ„Œ FÚÕmz"4¬P»-Žu€“‰wà›gtO)2°¿b[ÛÙælNÆŽê:šì£ÓÉØÜNuûá¼çM ¼q(gO ¶6ò—»µ>ì¯ú ÕãÝbgú3£¹øªtrÓâ4o Ò 4á ìdÄ$K’ŸQ‡þÌ4Ô®£ (O&!¾¦#Õ¡åu<» ÌÃòƒ
È;à¬éú¨{xøKˆ˜“ÃŒ)¬z•c¢à®±|ïzÑëxöF/½gXÆàœ³-àëäo爐,¥ù\÷B>î‹óüK?•»?ñ㬽i¯®33é¥2æ oaô¹)XWŒÕ™¾Ë¡,Ÿ™Çj ûùûŒ-,ß¹g„'ù>kc«?‹²œ ʆ›ØQƒ¾é&¾ÛJ¿¿÷û¡û[ßïÕ#B“Ëΰ+ó)ˆGhjU]Oô(ßÁöÐÍbÆ•¡ð' öOÌ@»,ý×öèª üö$0;-¤¦šÈ½i7^kcèlÖ·|D
_±@uŸ$˜x¦…ág:°®‘wj*f åmïa„4Ô
¹ê©hõGóx·Ž À¬c5 ÈÛߨàƒ
üóqÜz…µß?ç
_Gã -=
šÛå›]ñõ Õƾa#”/
rÚR)¼g ÷_ã§ü m¬z¡í»Œ!¦MN# -“o¾“¹÷Ó.;©@`Ÿ—%tšÊcp¼
Ç fà° PŽ4À¶¶Öï€ú9qeLuáØØÊÆ ]§óýVêIcp†“’|*2ÁGѺÚG§²;)•ŒS‹¹ö¾(OÜå!ÚÞõ·å„;Ie t(¸0
§¿k¤:Rý¶¿T‹Ÿå‹ã”]h£lŽƒw¶›8î +eͳ"h¸æ~ï—÷j²öþÐðû]lÞ7DtBÝiTÅu|mI -ÚÕom×È>¿ˆy÷æQœ½OÈË0 xtô@ûKéìx©“ð™Y¤Ÿ‘EÞ¯Z>ÝDùüý(zÒýlæ˜ ä Q>¹y'Ÿ7«$?[ú»>Gúx×HïêúŒÚÔÊg• þ&<75øBˆ¯w¨Vj¯Q·}¾1©´‚‡×æ0ý›YŒ;ÃÅÄ[\L¼%Ÿ.ÞÌ›+uC÷I×,Ý7·ñ{:ðôþ‹Ç©í„ýO7WèÝs€5S2u6PNÏöÍÚ‘ÿªR‡®sòc¨A>¼e«æâ|¾óqƒ®Ä˜Ç½¬ïŒ S³¬|¼qŸböÝÙ”lBqÂGä í/tv>ߎ÷Â<2ÎË¡t•qn`K3++€Öÿûýпžú彚,_eGÇ»=À–´°fi„˜êÏ~6Ò®þi»© ‡K—Ç`-ζ?Ö³¶_Üɦÿø©]ÀëÇ:ÚêÇ0<‡c³buÙÈÎ;ÜîÞþ~»º¿LT{€-Û¡hh
³—1¥2\>ž>q;U*•Ó_ÅÔ, OUoÈ„{l×f;+b½þlªð¬ ÁŽ}b1?^9€Ž°‰Ìœ §oeç
¼ýajgúÓeLmŽà‰›É d¡éž
üîÙÉŒ ºÎ}¿>¶©™”ËE'§pòKã9ù MõÕöw—g1gz}2ž™õî3 ¨y´š@²ÛsrÖ+c8Y³3¸ë‹4¾¼•m-ŠDJ„ fKPñ¢—@;¬\šà˜3Là‰v g@ÔèþŠEXó{ ³~“†Ó4µòï÷b»Gã¢ýºßûèçˆÑ÷*X†fsâL;v`ô59ä?·“ÚðÑ?€
õÃ@» ÆÛ~(ñ>ê#¹ŒÌÈæÛoÛ©ÚÇ<Äq¸?×i|¡‘ºS˜i¢¬[â°ÏEY÷ãí Ÿ<œÉÓóïxüW$ÞcýUŸ£s¼GÖ5±¶ÉÍôüt.YZÆÌzpïó‘ ±þƒ8Ç^d¡ø—cùÉÍ1,E–ä?3ÚÕñÕ:v„âK©¶ s1üÄôÝˈÓ]¤õþ܆øÏ-;Y·)6+9EíëBÄ4@Sýº‡]ÃR)›‚½9È翯âé߇öºì\xi-/?íÇKžÜ"3¡ÊʪA<Âêë>çÙ_·³£NÇœg'{…Dc€ÆÐaü5òPu6” "¬¾ösþrokÞè೅ͬÚØ}9ºHò#Ç}µ}Å5›ùÛ_}´‡,¸ ÌÄvùYù“Í<ýlØpàQÑõŸÇˆèZœBÞ` zKˆŠgjxòÚ:â wDð+ ìcÕÊ8JÅ©yÉÓ5BÕ%O¢ í/…çí]¬j¦;44R8œrú¡Ÿ“x¯êÕí¬\ tj¶Ñòe]¿ÛHÿiWm?ä{¬µƒ—¯ÞÅÆÍqL%.F}#“áÃ!ÔbûúXÒsõÚvÞ{»ûU›šX¹å‹MµPí Þ¸½ÿ!œvŒ)©÷XÕç¨ ï~?o^VÃÊOc$¬Vr²´µí»’NÕ϶ñÏ è&2Jì8M ¼Û||¾<¶÷VŸ™‡l×WíØBˆ~¦Jºáp~Ž˜peB =ÑÕ6§¾1†³FAãƒxì©H?ž¼$ÄéTj*§ÿëf
O°ù–
<û¯Ø—úõU«O²c(=Wÿè¹µÌ@Bˆþc‘.8Ì/× 7W® B~Cˆ–æöb'yÙ@ÔÇ'oF%P ñ¤ÍÎÍß³‘p;ÈuCâ³zÞ\üåدZ}„BH¨þ?ÃdUÔ¯ “=ÁAQ! ë´,kgéÃu¬Ú%_µB|£‹ôáVÒ‡:°’ ýÃ&^ûaÍQ©Bˆ¯.™þ!„B!Äd’.B!„BBµB!„ª…B!„P-„B!„„j!„B!„„j!„B!$T !„B!¡Z!„B ÕB!„B ÕB!„BH¨B!„BBµB!„ª…B!„ª…B!„P-„B!„„j!„B!$T !„B!$T !„B!¡Z!„B ÕB!„BH¨B!„BH¨B!„â³ ôÇT†Í¹·³{"Úºž–µ/ÒXÛÂŒ}쌛ÚÌÖ ÅÛóRsÑ?;›º…÷ÐìÓ
TÊ}ÈN8™Œ 7&âÄÚÖÒ¼â9뽨ݵ @Ö”«(5»m´¯{ŽÚŠtµo™¦ìÙ ?÷rÒB¯ñù¢×éI¬c LÎqW3høplæñ¶54.–¦†^õé¯vi.\㮦xÂ4 vˆ·¯¢ñ“ghjô `[«³Ám !„Bˆ£ª5“›ÓBhõ|ªk#˜œÅ¸'\AÁì|/ßK“7A"“MÛ÷ÅV4¢èñ„Áj$PZ
ñÚשYÓ„nLÖÄK(8ÃJxÁoé+ÀAÚô»ZÚBãÇói÷h¤–^Jñ‰w ùn£º.°W‰¦ÌY”žs ŽClõ ëhé¸O¹‹’Á
4~4Ÿ¿‹ôñWSxöm¨W ÉïÇv™±ü # B üOT6‚«ì[žõ]ôW ¦eŸ %o—‘m !„Bˆ£ª{è¾:‚m>hÛNÀŸMæ…gáJ³Òä
“ˆF@³¡í—V-h*Š®
r:Ñíϳc{Ïÿ7àŽ&kv©N áXâ œA¼òQê+·‘ ‚ Å9ìgdäbª °;§Œ£hö%X6>BMúw)Í;À&µNÊòJR ¯ù#»*P@ #Fê¥?"ÿ˜"Z–W“è¯v™‹È8UûU«VSÐÙ#uÞ- ]HÛª Ûe`[B!„âˆ08§ÚŒÉ9”¬±Çc¯¥-ÒõpÌO3ššm ©9ù˜5
ÍlFżèêðªdNK^Ù(4ï<=óJt!¿ÂRp,N{WŒ7¥Æ•$Ðк'xšÜd|3P¹®òÀuèc ÍìĬ í™6Åë[^fú¯]š£”t+·a>æN&^u R*io[Á0,Zíê«…B!ÄÑçHµkÆ ˜2£ç´¾· O÷T‚®àìÆdJÁ9ù.FŽÓô÷ Óh6CÌC"ÙPz£.» —èUÔ¿ñþž<¨ÚhûÏ34§È` IDAT¤ŸõmFÎMgM¶!H¬„ µþÝáßVz ŹëÙþê
¢ öü@èk ªÄëƒeg’¾kÞ€ŽÙ5»ˆÙº¦»¨þi—–’‹…0þP sN f«»5J0…ì\,&ˆêFÚe …B!Ä—ªC«æS]B³çà,9›ÂYbþà.¶W¶w‡j3šm9Eq¼
&2‡¦¥Ó ÑNôD’µ }Jõk?Ö^B昋tîðúÔ·F &g>vkžM á7 KÙp–žFFÅ6Ú|qpL¢è¸R|KoÇ{°9ÄFÖÑwÐðþK¤Ìº”—Ýó`Wà®mO~þíê%°ê'”o4óÇIK¶ÎImK!„B ÕPû»çTSC ¡=çq†”MŶ}1Ñh;º2cÉ;…t})U«m q
ÎÍ&T¤•x²¡Z…ˆ´Wi¯Â·« ó¼;É 7”Æ6“°Ž¢hÆÙ˜Êï r] ŠÅ4~¶„â Bñôt¾»mÐlÜöT˜ù$“gö.x.c®ÏŽ—ï§#¿¯uî£ÅŸ@oy‹Ê‹1;s°˜"è–“yÑ%¨»H¶Y‡j—
·'›Ã Q? ebKµA¤…xBÃ2ÈXûìCy¿ !„B|9¡zoš¦ ”ó 'RI]Fbû/¶šéT·“› Ez¿`ˆë~µ©kÚ·f/À‘'ÒÞ±gæE¤O‡N®+‹IýÙ{8i#uÚ É^Jå;oâ ê$ú\§wuô@ºey߸ Gt
UÕ_ðòt{·K…*ñú!¯t–ª•Ä2w6D7VW
•T¾-!„Bñ%…j³k )˜Rrq•Î¡0OÇ¿¬œ˜^Âñ\òò›hXÚˆÒ¡:J~Y.‘u>ãáÓ”IFÙLRü5„Ba4[>®‘sÉIñÐZQÓ
C[ñz- 8þ*òoãõ+lgRTh&¼n Ѩh+áhï‚íX":è^"ž–®é(FÖAÃä,Ä‘‘‹#w YÇÌ"ÝYKÓÛOÓJ"Ri—^KËg›É?ñ:†M±ÑØieW’Áfvl®ëZÇHlK!„B ÝP¢A…{Ú=Œ%Ö±…Ö¥÷³«¢©+0ë Â!@_A»§ël¸på
"eçëLæ†#v¬®‘äŽ=—‡ˆm-§áß hØÕ}ýi}õo?'\Ì Ù÷S©ÇSþ;v®ÛÙÏ77±â;£Ç¤÷Öà«yŽ-åÿÁHöŒ?íB'Rñ[¬WS<ñ†O ½cuo=M«¡ç$³-!„Bq$${ !„B!Ä>d²B!„ª…B!„P-„B!„„j!„B!$T !„B!$T !„B!¡Z!„Bˆ¯©ƒßQÑ1•asnÁíì^E…ˆ¶®§eí‹4Öv 0c û ã¦6³õ…Gñöº/Š¹è‡ŒŸMÝÂ{h6zsÿ‚i{?ì_rU¾®ÿh.\㮦xÂ4 vˆ·¯¢ñ“ghjôï¹Ø¶e YS®¢`ÔXìVH¶Ñ¾î9j+jЀû (œp29nLĉµ¥yÅs4Ö÷Ü°Æ„%ï4
¦žIÖÀ˜5xÇg4¯x††ºÎ=Û2R Ã4L™'QrÖõ¤×ÝOùG[÷¾ ¢‘þé]Völ†Ÿ{9i¡×ø|Ñk„tƒåXF2䲻ɶ Šá¨Xðüq9p„B! …jÍäÄæ´Z=ŸêÚ&g1î WP0;ŸÄË÷ÒäMˆÆÀdAÓö}±(z<‰›ckv,f¯„í• Ý¡4AÂßs7@3ö‘ßcä±C”ÿ‰ÊFp•}‹Â³¾‹þÊôøtÀAÚô»ZÚBãÇói÷h¤–^Jñ‰w ùn£º. $PZ
ñÚשYÓ„nLÖÄK(8ÃJxÁoé+0å“3ý"Ò‚K¨}o 1S!YS.eÐ" ¢-0X ƒMOJVÙ…Œ
ˆ VÿìaÊœEé9—à8œrô Ô¿} -¦=;UsL pæyØj?#¢ËA#„Ba8T÷Ð}uÛ|ж€?›Ì Ï•f¥É&€fCÛ/ÕYÐT]Ob¼VKÁbÓ‰µTl÷ïÿ¼¹ˆÜ‰£QµOPµj1-1RçÝÂÀÑ…´ÚAÂ2÷à â•R_¹ìø+Îa?#£ S]€:Ñíϳc{OÁðGG“5»ˆT§…Žp
4þë;4%âÝ¡³ _pçN##ÝF[ l¬>†nÅ1î
ëh~ÿ lÓoÅ}8ýÓ#e E³/Á²ñjÒ¿Ki^’å¨0‘–mDv¯Ÿ{Ö,œ¡÷زìSbrÿM!„BˆýœSmÆä JÖØ㱇×ÒÖÖ ¹b~˜Ñ4ÐlIÍÉǬihf3*æ%™L%«9NÂœ‰Õ¶Ö× ¥¤» X¹
ó1w2ñªûRI{Ø
†aÑ ÝCȯ° ‹ÓÞõMé£q¥ 4´ äš0§%¯lšw
žÞsXvj
³33ƒ1ãõ1$Fpõ ¬íqv6‘P‡×?]Íq“uò͸ÛþBåºÊ÷¿‘rz·{À… .Q´/}_TµB!Ä£Z_+¸fü)3zþ×Jë{ ð„»ÂUWpvc2¥àœ|£FÇiúûi4›!æ9x@-ž®ùÆêc´õê ÷˜±•^Gqîz¶¿º‚h†ý°ÊéÝ𠲧†µm!õu>9Z„B!7T‡Vͧº.„fÏÁYr6…³ ÄüÁ]l¯lïÕf4ÛrŠâxLd LK§¢èIL©VžÅl}i1`Âä*%kÒµ”œv7¦ÐíÔìê=o8J`ÕO(ßh"æ³÷ùv&LÎ|ìÖ<›>ÂoA–²á,=ŒŠm´ùzÍV}Jõk?Ö^B昋tîðúÔ·FzGPÌÙ³vÎå8v=EÅÊÍ쟓UŸþÓgÿ8&Qt\)¾¥·ã
«~ègÐÜ3ÈÏ‹áyïc 9X„B!¦Ïé º¿Ž`[
ú54/Œ Mi¸Ë¦b3ÑvteÆ’w
éúRv^%§à´›P‘Vâ‡Ä$ü[i]ö'ZBé¸GcT¸…8)Ø vH‰úý(-[ª
"-]Û²Ž¢hÆÙ˜Ê ¦rõbW>Φ…¿ E;žâée˜÷J—!"íUøjÞ§öÝÇh–?nh¯Ñ0çÏaÄù—c¯yœÍK>Úë$=Cõ9"Ô?–A³qÛSÉœù$“¯{)×ý…‘Ã>—1WÝG®Ëd¨Ÿ÷°‘:òDìÑu4íòÊ‘"„Bq–äV×Ð4
H ¨˜=‘JÚè2ÛA°ÕL§ºÜü(zÐËÊ•ÚÞO…*ñú!¯t–ª•Ä2w6D7VW Ù p¤Ä‰´wì™P©ÁÓ¡“ëÊÆbâ £çÝšzEjçñ ™=kÕclþx5±}^g¤>GÔ^ý£ÐkÿÀÆEö^'ÚHv'C²—RùΛø‚ Cý¼›yîb7‰ú Då@B!„øB¡ÚìHJF¦”\\¥s(ÌÓñ/+ïº
DÂK8žK^~
KQ:´UGÉ/Ë%²Î—ĵšSpŽ;ŸôX5A_ eË'}ä\r ^Z+º¯¢¡×ÒòÙfòO¼ŽaSl46AZÙ•d°™ ›ëºÖ mÅëµ0àø«ÈO¼×¯°œIQ¡™ðº-D€)“Œ²™¤øk…Âh¶|\#璓⡵¢¦;^ÛqN¼ŒL>¥¦¢ Kæà= k%ì ¢ŒÔÇ(s)hæXÍ ¥ À‘F4DŒõO´•ð^á׎%¢ƒî%âiéþ1a œž¬:‚t„Öî@®¢'„Bq˜¡Z%Dƒ
÷´{;
J¬c KïgWESW`Ö=„C€¾‚vO×Y~áÊDÊÎ%Öé5 ª5;G1YegPjbÄÚÊixï%vÏóÕ‰T<ÆëÕO¼á@ïXEÝ[OÓÚsMh}õo?'\Ì Ù÷S©ÇSþ;v®ÛÙ] ;V×HrÇžKŠÃDˆ¶–Óðï{¶eÊÄ9 l“(9oÒÞumyŠõ¯DL¨A&÷9Œ˜s&¶žŠ¯gt1èU?gý’M$ õOõs÷ª®aØñÒî ÈQ"„BÑWÌä:iB!„B|&é!„B!$T !„B!¡Z!„B ÕB!„BH¨B!„BH¨B!„BBµB!„_O¿£¢c*ÃæÜ‚ÛÙ½Š
m]OËÚi¬í@aÆ>öÆMmfë âíy©¹è‡ŒŸMÝÂ{hNêF(¦Ì“(9ëzÒëî§ü£{ß™Ð\DÁÅ¿``ÚÞ¯ò/¹‰Š*ß^å˜3'‘;n&YE#HM©gçßî£Ù¯ï¿½ìÙ ?÷rÒB¯ñù¢×õ¬b LÎqW3høplæñ¶54.–¦†^7µ1²Nm?d-Èšr£Æb·B"°öuÏQ[QƒÞ³1#ëîC!„Bñ…CµfrbsZžOum“³÷„+(˜Oâå{iò&HDc`² iû¾ØŠF=nüfÝZÊP²Ê.¤`üxl@ü€+Ù±˜!¼þ¶Wvt× ï»þÙp s3Ã+%Rù>-Ëß&äo#Ú¿.¦ÌY”žs Žý¶“Žû”»(Ü@ãGóéð»H 5…g߆zåš&7Y'ߌ»í/lZW‰ýä}Š1;1k C{¦qDkñzÀW€™j”u …j#uÖ=„ü
KÁ±8í•ø"
Súh\)A
]Û1²Ž‘>B!„ý ª]3þÀ”=ÿk¥õ½xÂ]1RżèÊÉ”‚sò]Œ §éï?¦Ñl†˜‡DR‹û^Y³¹Hã¤úã5PÍ´¬zšºÊ†®Ðh)ÄgEoZEcù:B )CçQrÂXB·QYíÌØJ¯£8w=Û_]A4aþoMB•x}0 ìLÒw-ÂÐ1»b·1šfl C«ÔYµÑöŸgH?ëÛŒœ7šÎš&lC&Xÿ;j»G›¬c¤…B!Dÿ‡êЪùT×…Ðì98KΦpÖƒ˜?¸‹í•íÝ¡ÚŒfBNQ oƒ‰Ìáƒié4C´½ŸSšò,fëK‹&W)Y“®¥ä´»1…n§fW ¬nlVW/¡}W;
¶ÿ™”’‡xÌ(,Õ+‰;&Qt\)¾¥·ã
$õê;hxÿ%Rf]ʈËÎîy°«µíÝ£ÇÖ1ÂH1aræc·vàÙô~Ó²”
géidTl£Íïê“>×1ЇB!„¢ÿCµîïžSM
†JôœÇR6ÛöÅD£íèÊŒ%ïÒõ¥T¶1tÆ)87›P‘VâGlè3A¿•ÖeÂ9øgd*fç®M$q`IíuêaÂC8ZJ&f“ƒf㶧ÂÌ'™<³w™ssÕxv¼| -þzË[T.XŒÙ™ƒÅA·œÄÈ‹.AíÜÕ=¢« ¬c¤)}ÕâæQÍ8Sù T®«C±˜ÆÏ–P|áO(ž¾‚Îw?E·XÇH Ê1!„BÑÿ¡zoš¦ ”ó 'RI]Fbû/¶šéT·“› Ez|@Óö¹Ìv¬‘@ ò ‡c]·‹¨,¹8Ó ÑÒ@<¡HÔþ‹ì½N®´‘:íN†d/¥ò7ñ{×ZG4¡[‘÷ pD×PUݺϬ#ë BŸu-µ GJœH{Çžr#5x:tr]ÙXL°÷½Îÿr ɥʅB!Žx¨6»’’‘)%Wé
ótüËʉ) á% Ï%/¿‰†¥( Úª£ä—åYçKîZÍæ R22Ð̱šAK€#+Œ i" ˆ )8ÇOz¬š /€²å“>r.¹/;ºOÖ«£ec5ùÇ^Á‰~vÕ°¸’|g+Mïoí©¶ŽöÞ° KDÝKÄÓÒ <5LÎB ¹8rÇ‘uÌ,Òµ4½ý4!µûFßë`¤Î¡x½ ù‰·ñú¶‚3)*4^·…h”u õ¡B!„HÚÁO§sLeØÜïâNíÓëØBÇç‹ØUQÕ5gXË!oΣ ¶½Î篼BHSö%Œ™{.±n¡¢Òc¸"¦œË;çLlûfΪŸ³~É&ZSo pø( ©6 F¬œÖu/ÑPÝ´'š2HŸðmŠÆNÂa×Hø7ѲòÏÔmo>HCí¤ú;Fæ/îuóÎãÅè1éĽ5øv.¥¹ü?ø½îpch £ï»Î¦ôctÂÅäÀ ©Ç³e;׬"¢\Çh
!„Bˆ~
ÕB!„BCdBB!„ª…B!„P-„B!„„j!„B!$T !„B!$T !„B!¡Z!„Bˆ¯©ƒßQÑ1•asnÁíì^E…ˆ¶®§eí‹4Öv 0c û ã¦6³õ…Gñöºç‰¹è‡ŒŸMÝÂ{hö醲½%ï4
¦žIÖÀ˜5xÇg4¯x††ºÎ=Ò6Qpñ/˜¶÷«ýKn¢¢Êg° +ö!P8ád2rܘˆk[KóŠçh¬÷îÙ–u09Ç]Í áñ™ÄÛÖиüYš¼‡qao
SæI”œu=éu÷SþÑÖ^7Z9Šm·ŒdÈew“m?@à P±à/øãûG!„Bô ª5“›ÓBhõ|ªk#˜œÅ¸'\AÁì|/ßK“7A"“MÛ÷ÅV4¢èqƒ÷è3å“3ý"Ò‚K¨}o 1S!YS.eÐ" ¢-Ð]ŽfÇb†ðúGØ^ÙÑ ð$ü$ÊI ´âµ¯S³¦ Ý6˜¬‰—Pp†•ð‚ßÒV ¥ã>å.J7ÐøÑ|:ü.ÒÇ_MáÙ·¡^y€&OÜxœNJVÙ…Œ
ˆ™m×wPÿö}´˜öì0Í1™ça«ý¬ûÎŒúG!„B Õ=t_ Á6 ´m'àÏ&ó³p¥Yiò†ID# ÙÐö Š4E×
°DÿúM‰xwX,Ç DƹÓÈH·Ñ÷$T,6XKÁvÿa–£Ýþ<;¶÷¼hþèh²f‘ê´ÐŽAÊòJR ¯ù#»*P@ #Fê¥?"ÿ˜"Z–W¼¥·Ç¸(,¬£ùý'°M¿÷—Ùv&Ò²ÈîD{Ö,œ¡÷زìSb
cý#„B!öŽ¿ÆV3cr%kìñØÃkikëŽe1? Ìhh¶¤æäcÖ44³ó¢'3¨¹; h˜9˜i%ìâ,XÍqæL¬6Ëá—Ó«ùæ´±ä•Bó®ÁÓ=‡E3;1k C{ÊŠÖâõ€-¯ ³áFÅ®¾ƒõ¯=NÃÎ&ê«Ôv
ó€ \¢h_ú*¾¨2Ü?B!„bo}ŽT»fü)3zþ×Jë{ ðtOè
ÎnL¦œ“ïbÔè8Mÿ1f3Ä<‘}%ýŒS)9q,ÑÏçÓâÙ3'[³¹Hã¤úã5PÍ´¬zšºÊ†Ž ¬ RO`Ôe7áÒ ½Šú7^ÃßU¨¯”Iú®Ex:f×@ìV fëšîb¸mê«×v SÙÓNÃÚ¶ú:ßþÏ ¢„B!D’¡:´j>Õu!4{Î’³)œõ æîb{e{w¨6£Ù†SÇÛ`"sø`Z:ÍíDO$[
söl†s9Ž]OQ±r3½ã ò,fëK‹&W)Y“®¥ä´»1…n§fWÀp9]
û”ê×~†-½„Ì13èÜ;áõ¨o€¾ƒ†÷_"eÖ¥Œ¸ììît• jÛ“ÿ*¶ ÐÜ3ÈÏ‹áyïcÂÚO‡ê !„B±—>§èþ:‚m5ê×мü1v4¥á.›ŠÍDÛÑ•KÞ)¤ëKÙµz”œ‚ÓnBEZ‰'ª5ÌùsqþåØk gó’ºOœ; ÿVZ—ý‰–P:îQŽb° "Ò^…¯æ}jß}ŒÖh ùã†v—£Ð[Þ¢rÁU¬{é66,¼•Ï-"„vî"Ñï»á(· ©#OÄ ]GÓ.ï7sÈþB!„I…ê}ߦi@¥@Å<è‰TÒF—‘ؾ‚`ë'tª‰äæ;Ѓޤ§æ<ž!³çbzŒŠW5òbÍÔ?åôÔÔ´oy:z ‰H(•¬éàˆ®¡¡ºµß/+wÔÛn „»ØM¢þcÑ/Ò?B!„ Lÿ0»’’‘)%Wé
ótüËÊ»®‘ðŽç’—ßDÃÒF”mÕQòËr‰¬ó%>í8'^F&ŸRSÑ„%sðžŠÅZ û‚(RpŽ;ŸôX5A_ eË'}ä\r ^Z+vtÇ>å˜2É(›IŠ¿†P(ŒfËÇ5r.9) Z+jºËÑ09 qdäâÈ GÖ1³HwÖÒôöÓt†’ŒÔæ R22Ð̱šAK€#+Œ i" ˆ ݶ÷„ïÔ¤» ´vÇþSC õB!„0ªU"@4¨pO»‡±Ó ¢Ä:¶Ðºô~vU4u4ÝC8è+h÷tÅ®\A¤ì\bIÜ(Ä”‰s@Ø&QrÞ¤½ŸkyŠõ¯D ;G1YegPjbÄÚÊixï%zæ,ÇêIîØsIqX€ÑÖrþ½`O9XqŒ¿ÑcÒ‰{kðÕ<Ç–òÿà $¦žÉ}#有çâë] zÕÏY¿d‰£Ùöî ¢¹†aÇK»'pÀ 8}÷B!„è-©ëX!„B!ö'“d…B!„P-„B!„„j!„B!$T !„B!¡Z!„B!¡Z!„B ÕB!„B|M üŽŠŽ© ›s ng÷**D´u=-k_¤±¶…ûØ7µ™/<Š·×}QÌE?düìlêÞC³OO¢:¦Ì“(9ëzÒëî§ü£¸ƒŸ†9s¹ãf’U4‚Ô”zvþí>šýúþeeÏfø¹—“zϽFHß]A
.þÓö~…ÉMTTùº_îÂ5îjŠ'LÃa‡xû*?y†¦Frö¶ kÊUŒ‹Ý
‰À6Ú×=GmE
ºJ¢>FÚÞg؇\@á„“ÉÈqc"N¬m-Í+ž£±Þ+,B!„èïP™œØœB«çS]Áä,Æ=á
fçÿÿöî58ŽêÎûø·»gzf4#F·±-É–lÙ’-|Áæú0Ta N°Y ¡Ë†¥€
©ZBŠ”![XHñ×
Éb²!äñ³É²$¶©/c¬[6º¢ëhf$Ïhî3Ýý¼„ïV[µ›ÿçF§ûüÏQ©ê7§NŸÆüÕ ÅMÌ\ TŠrüÅNrû/µVÜs©h½–Ú³ÏF
'm¥ãYt'óÏk"Û±•ðûo’NDɦOìG-¿œ¦¯nÀsÒÎ\84Èì}‚®Ž±É0ib&¦Þ¨ájþÍç6’l{žŽaðµ~“º«îÆøõã„mQðPzþÌm
3üî#ŒÆJšn`ÎE÷¡ŒßCwÒf=vÆn§fKqSèÛLχ! }6Ë6P{…“̦Ÿ2–‘X-„Bñ…†ê)Æx?©è8D»H&*)¿ö*|¥NBñ f. ŠŽrB¢u X9 ÃnHsâYr;uuýŒl}ýü¿#pbF n i¥Ÿ‘Íße8š9õíÜK¨_³Ç¾'è)»›¦š<Ý î$5š8ñzžêe ±úž¡sçò ç)¹þ.f.¬#º³[_ 3 ÌöSèx’ÁŽO1ÔØ+xç=ˆ¿¶µ?9qŸéê±3v[5äº~Ao×ÔE"‘[HÅšzJ¼Æ2yùB!„ø2Bõdb›X©^|®Ìnú¢Ù‰ó Lü(
(úLöî²ÀÑHýy'Ë•eøW¬ÆE˜Ê+ž¦ÖëÂJt2º÷út éK
Pñ•; D_dÿž\_9Ù¨ý8µ†VŽSÏÏ ».®xš(óAjקh‹6²x¥ÎÐÿ{†Ñ(4ÔÎáô’³36#F:aá¨=¯«ƒñ¬…Z¶Ÿ;Er(r$˜OS±_³ŠVºˆšÖ”øÛÄ⨅B!¾´Pí[ý,笞ú)BdË&b“Û¬| Ã
ªn¼+î§eaÐo¿Ç°¦A>†YÔn‚i;êÔ81B;nÛC:ëÀ=÷z.܈#}364£ $IDAT Ý1@Coº9Õ{éúÍr¦Žëdù\÷a¦
”^òg+`%Þùý C˜€â®ÆA†D:VUƒætâræH¥rPYC…œ V”è¼LÙU·Ò|ýB÷„Зbî}‚Þ¾„íz쌽¨šK.¤åÆ;ð)€ÑÉàïÞ !™Z!„âË ÕéÐÝŸFqUám¸šºËŒööýtuŒN†j
Eo¤ª¾@|H¥|þl‡5È Æ0¿ÀJt'dº·1:0Š¤F_ÀÝð83µàèþ€‚g9õç51¾ý^â§Ù lÅÞâЫo*ª¯‰ŠåߢáÒPÓ÷Ò3pô>æ ÉߧmŸJ>Q ´è¢UTo—sŒØþwH¨ ¨°t¼M—âoÿ”èxÁ^=6ÆnSsú#ºßx½¬ò³®cÖÚ°ùG F²ò !„Bq¦=RÏHô“Šö ü‘÷Ÿ¢7TJ u%º
äF1,
GÍÅ”Ûص.ÆëR±²
_d¨6 X€VrÔ£‡fŒLw9šªà˜µ†€«„òË~ÆŠÛ~É9·½Hó|/”ç¬[ ¢ÚwüpMÌÄ!"ï=O8]F e*`eÂp£{\`¦È%XŠ½D‡lØþ¸œ-Ô¯¾µíq:v½ÅðO³ÿµG +0çüV´yÒz¦ {‘5[i²£Œ÷l¥ïOÉ5\2WÎWB!„8CŽâš+(Š˜XXù†YBéÂVÌ®GIE4[÷R Ìa¤â|‘™šü0É$ëæãÜ30±?ØQ·ÌðÓÂì{–}¯»ŽzpR§dÕF+·Óñï¿gº›‘ ?gx0~ÜaÛ
Zùrª—\FEýJ܃|ö/1’0ÀÑLãPé:I÷™·ißô"‰‚¾T 5—R»òJ*fÎ@S
c 3²ãe†úÛ?üÛV=€VOíu2³ôØ&‰mwÐÞ9nï>Øìkº9B!„öBµ¢zѽһ ¡»/‹êC`éMÔ® bþꇄâ&f.ªE9þb'
9Œ‚ýwô)î¹T´^KíÙg£…Z˜XŠ›Bßfz> a賩X¶Ú+œd6ý”±ÌTŒÕñ,º“ùç5‘íØJøý7I'¢dÓ“µ½ ¾ùaõHÑŠg)u—}
½ï㉷ ÚéK
Ruþ_QšÚFß–ƒäÕ:*ιYWxȾöѤͱ۪P\84Èì}‚®Ž±ÉÐnb&’EÜÇf_ÓÍ¡B!„°ª?Ï|ãý¤¢ãí"™¨¤üÚ«ð•: Å3˜¹,(:ÇgjTŠ•Ã0ì®×:ñ,¹ºº~F¶>ƒ~þß8±r]¿ ·kêç?‘È-¤bM=%^c™< 7дÒÏÈæï2 ؕ͜•!þ”ìç©ÒOàòËñ¦·pð½È[6û2‡þ×o2 “·ñÔ,ükWá/Ó‰&3ö†n« @qãÐ
òáNR£‰3¼66æP!„Bª'h+Õ‹/À•ÙM_t2–å˜øQPô™xÊL²ÑMÃÊ Æv¦&Oj×}ìÝe£‘úó¦k¯¢•.¢¦µ%þ6±©½'Jþ«q¦òŠ§©õº°Œî}…¾Ý'©GA›q-³,Fßú
ã9Ë~_ ŸêÉ{y«ÐˆJåÏðÏqšz ~œZC+Ç©gÈç
gvŸéÚ=‡B!„bÚPí[ý,笞ú)BdË&b“[-¬| Ã
ªn¼+î§eaÐo¿Ç°¦A>†YT ³Ù¸äBZn¼Ÿ þî
SÖQG ƉÚÉpÛ ÒYî¹×ÓpáF é{èèŽ ——«¨\u)Îèk ö××ñÑÛ
-&÷É#„cg¸ïø4õ(º3U ô’Ç8[+y€ðΗèïÂ,â>Ó¶)v…B!Äô§¤w>Âþ7îçÀïŸä³Oƨ¸üÇÌmª@ù§iSÔ
!„B[¡úX
Š¢ &–V>†a–Pº°³k©ÈrØZFuЃ‘ŠóåŸ1Ùƒ:9Œü0É$¸ëæãœzzÒQ·Ìøб!_›E`N sð]’¹3è P¼Ð¸f=ÎΧh÷r΀‹GQÏü>§kSÌ
!„Bˆ‰¸4mÖóÍÄí÷£º«ñ5£®Æ ñ^ÛÄIfœL¡šš`ˆ¡íÃXD»s[«É-Õš ·ß¢Íĩ➧"ƒ‘
‘IfA-ÇßzîDétEâk^O•;F¤½g"òý„÷u<÷&—%èKâZp3Ao„ÐÖCÇlËPJPæƒôîÞ·kØé Þe7RÎGô´‡p”Ï>2™ù™ñTQã?m=¸ñ.ù:eùnRãI,=HYózª=q"í½Ç|y9ý}l´)b…B!Ä4¡Ú2“äRU?`ñ*€ ù±ƒD¶?Ì@{h"0Û0v0›x‚/Ó±ƒlëZò‡ãE…J5ðU¬»}êƒ9ËÂ9`tþ„½ÛöcâÂék¦zñZÜ %ic蛘<«™™}ÿÀ!ÇÔ/þ-+ÌÄ~B[ÿ‘þбGÃ)¾y¸ˆ3Kž¤}©åxgøA_NÃ×– {yø9ön~çÈqxvBõéêQ\8fdÇË õ >r¶â÷䯙³t Fw2üŸ/Nœä°mµr
ó×~ƒÒô|òú¤c¯•/§zÉeTÔ/ Ä=Ègÿò#‰ÉFŽTœs µ-‹q9ÁL~Ê螟Ó×Þƒa8q5^CÝÒ¯à¯
R ÝÍÈŽŸ3M›¢úB!„§ ÕŠêE÷:Hïz„î¾,ªw¥7Q»&ˆù« Š›˜¹<¨åø‹(ä0
¦½*Ô Uçÿ¥©môm9H^£âœ˜u…‡ìkMš€†«ù;4ŸÛH²íy:†Á×úMꮺã×>.¼«å—ÓôÕ
xNÚ¡ŽgÑÌ?¯‰lÇVÂï¿I:%›žª×Céù0·)Ìð»0S(iº9݇2~ÝýIÀÄRÜú6ÓóaCŸMŲ
Ô^á$³é§ŒelÆj£—Á7 "¬ ™Dų”ºË¾†Þ÷1Ù©a). dö>AWÇØdh71'¾ñôc·Ñ¦ˆ¾„B!ÄéVª§2ßx?©è8D»H&*)¿ö*|¥NBñ f. ŠŽrBbs X9 Ãf°4‡þ×o2 “®ñÔ,ükWá/Ó‰&3 ÕS½l!Vß3tîÜAÞ‚Ãá<%×ßÅÌ…uDwöòy„w/¡~Í ûž §ìnšjŽIŒhÁ
4ô3²ù» GOòêmÇL³ý:žd°ãSL 5ö
Þyâ¯FíObbëú½]Sý‰Dn!kê)ñ:ËäíÝÊ
Jöóòü.¿ oz ßûèÈ«Î7Ý î$5š8õýN;v›mìö%„B!&⯽fªw.‹/À•ÙM4:ó L4}&%UA4EAÑ4¬| £˜ ¨'ƒ¯·
©ÔD8UÍw? wÔõV&L7ºÇfŒ\PÊÑKtȆ)˜
ŽYk¸Jಟ±â²£ï½ž³n9›Þ_=D¸0±ÍÄQrÔ#zfŒLw9š
…úÕW£¶ÝGÇž~,Þbøãm̹öûÌ9‡ÿðÑ‘°o¥ÉŽv’ íd|`íú—ÌeøíE®êê”4_„+·‡ÞøiÚ™˜‰CDÞ{ ïì©h™ÃgP§ ûÃŒmÌOÂœ¦¯ý²Z-„Bq¬‚Õvƒ¯¢(€‰e•a˜%”.lÅìz”TDã°u/ÕÁ F*^TøR¼Ð¸f=ÎΧ8ðî.òǯԦ;ˆ' ¦©Gç,ÀÝL rû:)XVß³ì{ÝuÔƒ“:%«6ÒX¹Žÿ=ã)”a’IÖÍǹg€œ8ªñ–‚ ¢`‚RR‹Ç] ;:vdŸw¶‡Ø˜Aµ¯‡Ê)Vá'?TÏàøom9ÌÁwIæìLØÑ}XÓŽÝÀ´3?Óö%„B!Ž3æ :Oª5ßLÜ~?ª»_Ó:êj ïµMœJaÆɪ© †Ú>Œe@´;G°µšìžqûg5ã»ìFÊùˆžöŽòÙG–Ðó2ã),£ðÇ^tóÎÑAiëÍø9@ïþ‰8›‹É {_GÖ #N6ž Âý„÷u<÷&—%èKâZp3Ao„ÐÖC+ÐéCÄãf\p AóMâ ½öJêë42{N¬ «åø[/Ãè!Î èA|Íë©rLj´÷½š«”, Ìéݽ'ÙòâÆ»äë”å»I'±ô eÍë©öĉ´÷Ú »ù±Ñ—B!„8Z§Ø
œwüo,3I.eXõ¯È‘ ;Hdûà ´‡&³1±mc£±‰§ó2 ;ȶ®%¸ˆ ¨åxgøA_NÃ×– û»ðsìÝüyË ÛþÍœe·3)c;éÿ·—ˆØzÁÌ”™}ÿÀ!ÇÔ/þ-+ÌÄ~B[ÿ‘þÐäñzF/ƒo>
^Ǭ5S $ÖöO|¶ç³Éq¹púš©^¼·ÇdÉEÚúã&†Î`߱⛇‹8£±“\«¸pxæPÑzµ%:' mchË«gÔ×é ù/ìK!„â†Ý
p
ð[™ !„B!ÎȺ©íµ! FæC!„Bˆ¢Œ Á©'О“ùB!„¢hÏŸ ácâEYB!„ž` ˜Z©N ÷ɼ!„BaÛ}“9í¨?fâh½U2?B!„BœÖÏ€ŸLý ÷Ë Kdž„B!„8©Wo ýv’Fo +ÖB!„BœÌÏŽÔ§
Õ0±býp>à•¹B!„áF€osÔ–;¡&öXÿ ÀZ$\ !„Bˆ¿Ð0ýSà;OÕH)â†× —+˜8:¤ZæX!„Büfâ¨éÝÀàÿÚ¹èÿˆ§ü»=i IEND®B`‚ stem-1.6.0/docs/_static/prompt/events_variable.png 0000664 0001750 0001750 00000042147 13115423200 022765 0 ustar atagar atagar 0000000 0000000 ‰PNG
IHDR Õ † 6v sRGB ®Î é bKGD ÿ ÿ ÿ ½§“ pHYs šœ tIMEÞ;f£>Ÿ IDATxÚìwT”×öþŸ)tP:VTTMÔȵPƒhìÆKŒF¯½]ï/&7jŒD£±ë׫IÌ7–4£IlñÚ hE,TA"e(óüþ á pÖzÖbÍ Îœ³÷>ïì÷STx:v †è 9€šAA„—‹( ì°@bQ…TOùçE f0;
‚ ‚ ÀR ÿ,)©nàK ¯‰ÍAA¡HÎ àJQIu# û Ó<AA¡$¢ øæ%Ö“êß!O¨AAA)g ´ Mî ‹ »‚ ‚ ‚bܳñ9»|Ì›¼„˜5ÀðE«ð¾ŸÓ£»+AAÁ f°S#gÛ¼
±Ë‡ÊÊ í{ÂÛAóBëѸÅÌÓá¾°ˆ!`î‰Ñó&¡“*P‹¿žw4ÃÎg-®e¤"xA X”¢ïƲ³ ‚ Ï„)€ájäìC]1rÀ&Ó°ý‡uV×ô…Ö“ ³ ƒ½š£yËžøøšD’øëYPê¶ÜM,àÑÔf¥è»±ì\®PWC»™ßàB‚ ¤ ·cVûêeó‹Êóü,A¡²Ò]‹œƒ]CÈJDxh" }€)bñ×3¥ú¸ýE/4
i€ŒËÁH/@‹:cwáà'pfé :ÌZ‰ ;ÔÈÿw+«‚~– ‚P‰i |B¦æl·¼.ýV¡yﳌYuàç ,’‡;»ÑúÑçÕäë þÀK÷IRÏ„ïù¯^5ij`=×Ü–ÄÌÜ÷ÒnŸäæ -XUýX»´µ9ñ ÉÃ}iûŒ}SWkÇ)k¾ç‰°h&gäµ&‘Çf5Îo·Ö‘flåé;:’dfìynŸÛ™šüz”´YU¥ G?ÆÛ:’ÌàÝ ™L2dz=š þy)üeMßïRÈ3céöx½Õúópæ_ÜÑÍZ‘O5ncy¦`gŠj’¾+µsIñ£vdå™ÈôÜÿO¾¾KûÕ¡™1ãB©Ì_å'dêÞAtʵµÚy0I#o-y…æõ³D"‘HT™•QdRmäƹ‘ÙŠA7¼øö"'z6ÔP]eIeAçÙbð6Æ3žÛ· §§'===éáj™SŸÊŽ>ë¢HÞä7s³g¯¡œ·3‚d×ûØQ¥´ €0¯ÇžƒÙ7½;¼ÎI[ÂHÞåš6–FOªM=ç3Œdئi ÚÛ—]:u¥_ŸA|Ý#÷³TÖl»ô*©»ÈM“Ù±Mg|oc©ã‘ñu©UÚfßØqŸÌ¾Â/gb¯Àᜱö –ER])ýeÎWƒ"¨¿þ!›š*sGÖ«ïJKhRo:C2opQ33e>ÕÚ°v#Ozzu碫Oi"*)£ ~´îœz‘äõ• àG¿ÀÑ\|èÉsœÕÐô¹_˜4µße0ÉãÃjÒãï¿1é¯SœëU—o"yö ÖÔTÌωD"Q¥W/j4tèàÀ ks~^R ÙŠ ìq§__+ZjŒXÆ€ÆZ´^Å»¼ËU-žür¬5ž§I^™ß$ÿéš™?¸Jòä¸B_ŽÅÕS¤l¸WG^šãQ8ù4ZRÂo»[ý¥_c g¥óÀpWj %\ö °?ƒ¼0…uµÊÚ¬uŸÌs$/Îlß›@þVIu¥ô—š.#O1;ékv©¢¦Ëð#ÌæyNq×Ò²Í:FëŽrˆ£J‘O
i’¾kg%ñ“—Th‡¶Î$ž#yv\ÍüÿSä炙‘m-•ÕcÞâF0™ßø8²Õ§$c¸±3»ïJ!o.fssãÅèóü,‘H$Un½éCv6âŽÆáçwÿÄ‚F!Ø0;7 –^Õà³Ä5,ŒXÆHX6è
ODãо›Ð彨 ÇÏ¢Ï.h`ÀgiºböÖãOE¶> ‰Wþ™•i™ì’Q Ýá¥1ƒÏ—w•·{…>Û»™ Ž p4QÖf ÷Žh€h =z™å`âQÅó— É7¯ ÉÚ µm ÑqÄkPà C|\a]£1lï‡âæC–» ^Jãçq²®âf*`ãZUñ‚½ôÐѽE+´jõ¤Zv]€ 醶>gg7Gí:1éxYO†žŸ%‚ TF´Å½iZÓÍÚÃ{puÔ¶Éy·uHË6~ã *tD$ ¨TVaR “vïÇ’zû±`r ~ºt *_,ûþc8¿ ©Tj¨‡¯ùcqhᬄ ¸•®°ÍÔƒPAV•£ð«XþJ¿uú.hÖ¬š6Å’¥ZŒ+ -þW¸õ9" MYÐ/0~4EßDdé•Z¥¸mL½‡+!1E—gN}JÈL¸‰X£†‹ÔY1ˆŒ v››%pÿîñ®ðy~– ‚ð&ÕššÕÑge
x·4yô{0'¶ÄácéÐéWÆ D÷:XÁÁúÉf§^;„Ë€®¾î0;šóôÓ¬ ü}œË¿áZš²z`áßæj„Í¢ÿ„äÔsÝix2IÓg"-€¥ ,Õ@’ÞøJ
ÛP@ûÖ&ˆÜŒ" †*hs굸„ð
h‹“ÁH{ÁUÙü•ŠóIÎð›0—‚0v:¼=·sCüÁˆûŸ:ü•ÀÚ Ö 1Û0*²³’ø1?CøéIp)ê͸ÿC»:ãp"UcNá`$0qHGؽ±z@íЃš+O#Έ7ãÏó³A„ÊÏ“óBªÛqìõV
nÌ!S«³Vî\Ñ2)c€TÕûpw*™~zGø±GßÑœ2Ò“¹ ߺ®ÏYø¶}ÞPô Î÷¾,¼ðMI=¦
9çÉ;;9»_gz·zmüg󈎼þaÓÇvC°dÛ
1döE®È€£9qh#ƒv (qþʆ W„“LáÙÍs9²?ýzõã¨iÓXË$w
mVÙ²ëºH’ñ<4Ž}ý}ÙãÍe +rNµŠUÛ.apŠž±{dzž‰ø ¡váˆã$™ÂÝ}í©R;sè~ ÉL èoÿ¨ÍŠçTÃœ-—E’ ç–IýØ{ÀN Þ¸P{Ší»";+ˆŸ"æTÃÚ‡Ûÿ*ʆÅøÛÒM^mÉ–-ŸT‹¦5i¥V;&¬ûÎoLg2/ É×_ ÉŇ“Éôß8®Žö±²¥UC>K$‰D"C*ªÔ´ó4£yq UÆ ™²îà5<~'wã¯ÌXžYíÇêêü-Úîá•9o'ýùÔÊߢMa=æîý´÷cóöÓ§11*˜_
¯¿ÛFÞ‚.×Þ\qü ³H2+Ž¬õ§½ÚˆI5@h Øaêf ¹‘œÛ ,ÞÛ˹ÍÌó\)i³©ýßÛÉs1y›Ïe0!ü(Wõr|l1š Ì
Í-sŠ#Õâ/€€›tƒŒÝÄNÖ9 ß6&ò2ç641̧y ºqáÁHêH2;žÁk{<Öžl¨¤LIñc¤¤Ú¨ÒTgûYÛ’˜»!aÈÎîP½ˆE“FˆUÅŸ%‰D"‘¡IµHV°Ú´æ¼“ä½µü›¥ØC$±*‰D"QqÒÊì—2@e×Æàbñ´½'ôH¾ŠËwRÁrØ|‹úý0í Ó1½u<¾ ´gRÅ_åÙ_/3/]¬
‚ åIªËó&˜½ï ¦¸=½ÈÝUQò™ç²`Ð`ª4€§Ù1Ìnˆ/OÇ#[üU¾ýõ2ó²Åª ‚PnQòðMAAJƒZL ‚ ‚ ’T ‚ ‚ ‚$Õ‚P©YÕ–˜ºó86õu.px¡®Ý†¢‹«‰HA$©~Þ˜Àµçì¾ f=@TðNLoj.ž ²rGûÞðvД¦Øù¬ÅµŒT/h ±a)ë{s~9ŽåÝ ârdÝCÌaô²ÿàÐÅ×ÐB‚WA*g?Zç!Ü—N& ZÄá~ ÙѧŽÎöŽÙ EëU¼Ë»\ÕÚ¢õhXcôQf“|ø]¯üÃ@ƆKeË.ë¢HÝ ÎjfYè”H Ô8öàêk$£6ÐÏ^-1,‰D"‘ þòœžV+x›1ÜÐÖR W– ¡¦*¼Ö’µTbÃRȬé¼B L¨ûØ1ðNÔ¬?‡ÒÈ»ë;ÓF%1,‰D"QåJªMÍÙny]ú¬B[ó§ü£±Ê(‘U~žÀ"¹<Ç#?a1É×?ü—ž !ßó_½j:öZ] §¬ùž'¢™œ‘WK"Íj\ÄñØÅHëÈN3¶òô ]îÉÐç¹}ng:hrŽ¯vèÿ uŒáÆB7 fôZN¦ÿÌ7ìU
ê¡vdå™È¼S¸“¯ïãÒ~uò.Æ>wv£µÂ>iÜÆòLÁ.xl5 hO%¶¡Ú¦%'n9ÉÈ”Ü7³S}~ýª=~bÅvcÈ{ëØ®JñG¹7œ}žÌ<Â15‹øÅEãÌ>[n03ë¿|ÃEŽÎ‰D"‘¨"%ÕÚFnœÙŠA‘tËo/r¢gC
ÕePFÙÏètnИ-oc<ã¹mp zzzÒÓ³ëV3Í-cGŸuQ$oò›9ƒÙ³×PÎÛA2Šë}ì ýônê9Ÿa$Ã6MãÐÞ¾ìÒ©+ýú âë <ýVY³íÒ«¤î"7MdÇ69ð½=Œ¥ŽGÆ×¥ Úif’QË[ÑâQÒïÉùa¤nß :ª•Õ;§^$y}%GøÑ/p4 z@ò g54-Á>žôpµTno
k7ò¤§Ww.ºú”¤ZI{*
-ÙvC ™zŒKFø²mko¶÷íÏ1ãû°®écý3•Adì¦v´*iZ“Ë0þ/+›'F»=™4[¶á†˜œü=vc[ZÊK$‰D¢
ô¤Z£¡CöXÛ˜óó’âÈVü`;ýúZÑRcÄ2Fúi^Ska‹Ü§ôf^ ò:Søc {ª”Ö“—Hpµu&ñ ɳãjJÂŒ6uA[›Ï•T+hO峡-öêÈÛëÙÓY[| mûð`6ùû·’ojLñŸWÈį:³ÊïkéÜu
—,™JŸ’>S$‰D"Ñ‹[ûWäÒÅìlÄ ÃÏïþ‰B°av n< ,½ªÁg‰ jX±Œ‘°lОˆÆ¡}7¡Ë{QŽŸDž]ÐÀˆŸeáÑ ^3ø|yY$H‚ú8lïf8zÀÑ€>ûÖüŠ´Zƒðf æh2b$ê%~‡•¿ÅƒJë)‚¬„«¸™
ظV…/žgiOÅ´a̘Œ]úw°çÞ]œÝõ)¦x¦ˆ
T&0S)% Yš™ˆˆû€› žln¢}†9sVà`t–,«A„rŠ¶¸7MkZ£Ù@{x®ŽÚ69¯ñ¶iÙÆ/c TP=þŠÊøFS©ÔP!_
òÇâÐôBï1#·Òs~ H8ô¾MÜ¡c^Áü0¼;²îl]‰ ¨§ÈŒO,= R?Ù_£À‚U‚áí©¨6Lûsú×ÿ-†aø°øàÇiX|&½{ÎÃøü€fz+kÀ»¥É£$ö` Nl‰Ã ÇÒ¡Ó¯Œ±H½v—1 ]}Ýav*4çiµY=øû8—õ4#~VØ~„r Ú·6AäŽ`<|Ê£H>8†O7EàÍwf`àK ±¿€ù«Ï!ÕÀz纇ÐÁ
ÖÚÒV„¿ÒX;ÁZ$–A¦W¡m˜‹?v}Š?v-Ǽ¦3p4ä¬z{3š-¾šŸ<§…áàŸ@oÿV¨ tÑÅźy x×¢öFåÿÊR`ˆ:uyÓüÕØ¿|µ<A„Š”Tg§êaçeħàÜ—±8þõ}DƲLÊ‹ì¨oð
ÿÄÁíÆÖ¬bk¨¯¼µï{ÜƆn;pÛˆ‰aöí혳r.þ7ãW[€U?žGt¦\=jáþ®Õø!2/µJÇÅuŸàôôÕؼ HÙ3_…g>C=ÊÐÝ>д¹èóѵp ¢µnð¨z
¿¸ ƒî)ôI¸t"
˜> ÿš‡ïblQÇü6nýé/µ
«¢ý‡Ÿ¢oâ! ø# ñ: ÔìØnÈƵèÊ›³îàç-g°zõ uߎO¯?½ U^}=«ßÃÎ=7žLª-_ÿþûÞqFÛýŽ:ãN<º¡A¡|QÄÎ jÚyšÑ¼¸…„Æ*cÌ=„Mk2`á ^y³[BÒŸ?qa@B[åc¡" BãÀS7óÈäܽղx?l/ç63â ß $o2¨¥…áõ±ÈÖ>Üþyýæmcgʺƒ×ðøÜã2cyfµ ««Ÿa1¦C7.<I IfÇ3xmÚ«
mO%³¡Æ‘¾ wóbLú£íöÒ£/r÷â>¬mödÿTv¾ü<ŽLÙ7–uLž¶(´.ÇÿOG†üƒMQô–zŸË–z"‘H$U ‰D¢²‘†Ž_ð õ¼´¬ë“77*KzÍ:A #¸ªCÕ'N\‰D"‘H$IµH$ÊMœ›þý&1‹¿Ïl˜ÿ«‰Ú†füÊ$¦óøœæ´’ÓE"‘H$ªÐ*åŠ6AŠŸ\•ŠÐUh~m\GFÞëjk4hi‡CÓÚâÏ. …b*AA¨È¨ È×¹ ‚ ‚ ”µ˜@AA$©AAIª…
ŽY _´
ïû9•‹cÓñ» ‚ HRý PY¹£}ï@x;h^h=·±8C‚y:Ü¶Ñ æž=oú7©"wi/ Åï‚ ‚ Iõ‹ÉšLÃö ÖaX]ÓZOvÌ. öjŽæ-{âãkŒ‡‚ ‚ TTdK½IV"ÂCítHs‚ ‚ TT^®'ÕV ðy‘zz\à‚I§S M½x¸³¬óÊ™ÖÄë þ€K÷ R„ïñ¯^5aj`=×Ø–„ÌÜ÷ÒnŸÄæ -Pµ ¬®®ÖSÖ|aÑHÎÈ›R’ˆc³ç·[ëˆN3¶âô H"3ö<¶Ï팂³”´YU¥ F?†Û:‚ÌÀÝ# вm¯ê¿©¿ƒ¯uYÞ>×w úÿ c°±e2ƒ×‚p0ýg¼a¯RfCµ#z,?€ÈD¤çÚ0ùú>,íWf†Æa%÷» ‚ T6^¢Óí,èÜ 1[ ÞÆxÆsÛàôôô¤§§'=\-©• }ÖE‘¼Éoæ fÏ^C9ogÉ(®÷±Ë9JZI= a^=²[;ozwx“¶„‘¼Ë5m, ·K[›Ï‘<Ü—¶ÏØ7SÏù #¶i‡ööe—N]é×g_÷Èý,•5Û.½Jê.rÓä@vlÓ™ßÛÃXêxd|]j•¶YãÄ7vÜ'³¯ðË™ƒØ+p8g¬=Á‡$C¦×£É3´½ªÿn¦>üŽ¾Öeå÷’û®vƒ™dÔòV´Èû?SOÎ#uûÑQІZwN½HòúJŽ
ð£_àh.>ô€ä9Îjhª<_¿‹D"‘HTÉôòuÚ¢õ*Þå]®jmñÄ{šZãyšä•ùMh–÷º™?¸Jòä8ÖÔ(«§HÙp¯Ž¼4Ç£pb´¤:…ßv·.ò}M1<ž•ÎÃ]©y”lÚsÀþ òÂÖÕ*k³Ö}2Ï‘¼8³A~ lù[$Õ9ö}
±ÙÖRYýŠú®væÐdÄ'lažSÆÌëC^g
ìcO•Òzò’ê¾ÔÖ™Äs$ÏŽ«™ÿÏ?•Ìï"‘H$U&ÉœêÇ°lОˆÆÖ}7¡Ë{QŽŸDãýa]ÐÀb#¢ *œqàÔÓ—.À;=^Ejj$Ç&£Š)aeúÜçÝXxt‡—Æ Ö_ÞAÖ—½íGàfVÉm6uÆGo#³4íiýÂNOF¯ýšœ{¸gô´«7 'C?F÷ŸÃ¼cQ‹«éFì{Z öùiß›Mæ#ø¢Éˆ‘¨—ø Æÿ*§£d%\ÅÍTÀ˵*4 ²_b¿ ‚ BeE’ê"QAõø+*«0©I»÷cI½ýX09 ?]º•‹/–}ÿ1œ_DTj¨‡¯ùcqhál” ¸•®°ÍÔƒPAV•ª=é! £[³ÃLTi¿‡—ë1¥Ëd 0# ái yWBbPä'Q,½û"áÐgø6q?†ŽyóÃLðîÈZ¸³u%N<0 ž"wÇËi«J‚ê%÷» ‚ ¼¤IµN]ÞÅ45ö/_ƒÑYeXæùAÝCè`ë'»Ÿzí.c ºúºÃìThÎÓj³zð÷q.ÿ†kiÊê…|›« 4 ‹þ’SÏuD¤áɤZŸ‰´L –v°TIzã÷95l?B9 í[› rG0 ÏÔæÔkp àÐ'ƒ‘ö¬>H»‡«!÷ U] +3 á!qñ¯ÍiýÂOO‚KQÄý ÚÕ‡©Fê; >8†O7EàÍwf`àK ±¿€ù«Ï!ÕÀzŒ‡Æ;åÍï‚ ‚P™yúüË6\ “7…µ--˲Ìs”ªz îN%ÓO/㨠?öè;šSFzæ,PSÙ±ëúœ…ŠÛç
e@ïá|ïÛÈ •ÔcÚs.¼³“³ûu¦w«×ØÆ6èÈë 6ÍŸ¯
°dÛ
1döE®È€£9qh#šqn-T6ì¸"œd
ÏnžË‘}üé׫ GM›ÆÀZ&¹ ó´YeË®ë"IÆó@Ð8öõ÷e7—1¬ æT«,ÝØäÕ–lÙòIµhZ“Vj¥ ô=o>T݉<••«@'µõ1§Ö>Üþד~/6~ŽŠìw‘H$‰*™ŠySãÌ>Ÿß`fÖ-~ù†K¡EVF/ó\eʺƒ×ðøôœl%3–gVû±z^eZ“ ÷ðʃœ·“þü‰ jÑÔÀzÌÝû1hï%Ææ¾M}£‚ùÕðÚù».ä%s®½¹âø=f‘dV ÿXëO{µ“j€Ð8°ÃÔÍü®×SÛ£¤ïƲ³¨üļĘH$‰DEKö©~‘d%"<4Ð>@‡”òÒ¨lÜþ¢…4@Æå`$‰—‰1AA'Õ…dÕŸ'°H îìFkä Sþú‡?ðÒ}’Ô3!ä{þ«WÍücÊÖ£q ÈmaIÌ;Ô9íöInžÐ‚U ?~\[›Ï=ë“jkú~—BžK·ÇëÖŸ‡3ÿâŽn9GX««µã”5ßóDX4“3òZœÈc³Ó Æm,ÏìLQíQÒw¥vÖ:²ÓŒ<}G—{J÷ynŸÛ™šÜ÷ÕŽì±ü C"™wzvòõ}\Ú¯ÎcÇ}+WUÿÝL}ø }Ë0Ί헊ý¡Ž1ÜØÖ²Àÿ™ÑkA8™þ3ß°WÏ>J}!1f´‰D"ÑK«—¨³* :7h̃·1žñÜ6¸===éééIWKªBeGŸuQ$oò›9ƒÙ³×PÎÛA2Šë}ì¨RZ@˜×cÏAìÖÎ›Þ ^ç¤-a$ïrMK#&Õæ|5(‚úë ²©¨2wd½ú®´T&õ¦3$ó53# šzÎgÉ°MÓ8´·/»têJ¿>ƒøºGn{´6¬ÝÈ“ž^ݹèêSڣȆJÊX³íÒ«¤î"7MdÇ69ð½=Œ¥ŽGÆ×¥ ´îœz‘äõ• àG¿ÀÑ\|èÉsœÕд|&Õ
ú¥vƒ™dÔòV´xt#çÉùa¤nß :ªh ¥±*1f´‰D"‘$Õ2¿ ¦Öxž&ye~“ü'Uf^üà*É“ãXSSŠùœ¶Ü«#/Íñ ‰Ñ’j5]FžbvÒ×ìREM—áG˜Íóœâ®¥e›uŒÖ åGU„'…ßv·.áIkÉí)í|WM1<ž•ÎÃ]©y”LÙsÀþ òÂÖÕHx
´C[gÏ‘<;®fþÿ!©ÎiëSˆÝȶ–ÊêWÔ/µ3‡ È #>a óœ2f^ ò:Søc {ªÊÀ>¥›{,1&‰D"QI’9ÕaÙ +<ûnB—÷¢. ? ˆÆûú ÅFD=TV—Ö©+¦/]€wz¼Š:ÕÔHŽMFS ÂÊÔˆÛ®è‘|ó
’¬¡¶# G¼5L1ÄÇÿMj Ûû¡¸ù°ü šiáÑ ^3XyY_>öf´ M€›™Oþ_VÂUÜL¼\«B [Égµþ a§'£F×~MεIô´«7 'C?F÷ŸÃ¼ÇP‹«éFìWZ öùiß›Mæ#ø¢Éˆ‘¨—ø Æÿ>gûHŒ=
‚ • Iª‹DÕ㯨 ¬Â¤>&íÞ%õöcÁäœ-îÅ IDAT üté>T.¾XöýÇp6rkÓoF„¾ š5ë¦ÍC±d©ãß
@‹ÿÕ n}Žˆt+dAK”‘…Uj¨‡¯ùcqhá2#·ÒhŠNð²ô€JRܶôÑÙ¿a¦ª´_ÃËõ˜Òe2Ž?˜ð4€¼‡+!1E×ÉœÏ4Z¿@$ ú ß&îÇÐ1¯`~˜ Þ Y w¶®Ä‰Ïß>cÏdž‚ ÂKTkáÔå]LóWcÿòÕ8U†ež Ô=„Vp°~²û©×á2 «¯;ÌN…æ<6« gàòo¸–¦¬ XxÀ·¹áA³°è?!9õ\·ADžLªõ™HË`iK5¤7¬?Ù ¡8Ÿä ¿ 3àp)cט¡ÃÛ3ñw;7Ä ¼lp} ¥°v‚µHÌ6̆Šì ¶ ¡ €öM¹#eù “i÷p5ä ªëdef!<ä".þUÀ]?CøéIp)ª‚¸ÿC»:ãp"µäÏRÚ/>8†O7EàÍwf`àK ±¿€ù«Ï!µŒì£Ä_ÅS‰1AAPðõöTY¶áú˜¼i¥miY–ež£TÕûpw*™~zGø±GßÑœ2Ò3gјʎ]×ç,TÜ>o(zç{ßF^¨¨¤ Ó†œsäœÝ¯3½[½Æ6þ³yDG^ÿ°éc; X²í†2û"W dÀ€Ñœ8´Í•öIíÂÇI2…»ûÚS¥væÐý:’™<ÐßþQ›Ïw…9[.‹$Î-“ú±÷€1œ<¼q¡öÛwEv¶aÇá$Sxvó\ŽìãO¿^ý8jÚ4Ö2Éwûä|WXûpû_EÙ°tsªU–nlòjK¶lù¤Z4I+µÒ…Š
ú•7÷ªîDžÊÊݱâ§tRXöQâ¯bǩĘH$‰D¥X¨¨qfŸÏo03ë¿|Ã¥èE;Æ*ó\eʺƒ×ðøÜM´2cyfµ ««ó·Ô X¸‡W ä¼ôçO\P+K=…õ˜»÷cÐÞKŒÍÛ«KŸÆĨ`~5¼vÎÎ,×Þ\qü ³H2+Ž¬õ§½ÒDflþÑ
2v;YçlÛfë·‰¼Ì¹
ó9å ¨qèÆ…#©#Éìx¯íñX{J°¡’2v˜º™Gn$ç(‹÷Ãörn3ó2KxLjøò‘ÝèfR†ñUR¿ %ζôÝš@ò&ƒZZ^AöQà¯bǩĘH$‰DÅ>´E¡Ù‚ ‚ ‚ Š,T,Ϩ,àÚ¸\,ž¶Wˆ éÑWqùNªÜ ‚ ‚ ¼È´
ò¤ºübÑ
+®Á·§¹»ª5êO>ƒ4±– ‚ ‚$Õ‚ ‚ ‚PQQ‹ AAA’jAAA¤ZAA$©AAIªAAA¤ZAA$©AAIªAAA’jAAA$©AAIªAA¡’%ÕZ8u™Œ—L…³¶ŒË‚ ‚ BÅ…O•e®!I2vc[Z–e‘H$‰D"‘¨‚ªø'Õº›øåç›ÈÊŽÀ/¿Ü„®,Ë‚ ‚ BE•›] ‚ ‚ ‚ðŒÈBEAAA¤ZAA$©AAIªAAA’jAAA$©Ê³¾hÞ÷s‚¦ÂF¹
^›°«g·„¥xTX}¹LZµ%¦î<ŽM}+î5L¾/„J‰®Ý†¢‹«I¥êÕK¶9·Šv>ky-#•Á ZТu©¬ÜÙ¾w ½ 4ÏÞ ;§^Ô3nS;ZZuà–=Ïÿ½µåÅ^6üdÈôz4©¨þÒºsêE’‡ûÒÖm2Šß+ñØQbŸÊi×8VËéuLeõ*ÿq"Lú•Ó[V¥ºŒìSÚz4ncy†0’ÿ+Û÷…ø«’]ŸÍšòÿ] ÿÇ5´x ©¤çj{ÁÝÄ M]`VŠšÌ›LÃö ÖaX]ÓRÜÒdA—©GfZ&XðïÊþ@£þÛøæüEü~>?Mo–ûTN×!? öæZt¶UÝ_ÆÂ(~¯ÄcG‰}*’
%VŸÏuL¹¢²Eç¥?⣖Á˜Ý±/–ÿ‘ }Ù§´õdÇìÂ`¯æhÞ²'>¾&Ï/Ë:ž+§¿*àõYŠÅÝ{bMbol8°~ö?%Õ¾|Ã2·¿è…F!
q9I/¼9ó
î%#;Kƒ{ÉiHŠMAv¥ö^›7 ¯ìé…–[ºãøÉ…è²¹7~±è‡Õ+šãÛ¡oáI,Ÿþz©y}!±ú|®c†ØYa’Þd*ÖwÄÑw;bÅÅÔòý "+ᡉ€ö:¤È•¦ÜS.ýU1¯?Ù±?czwá²[nCã ‡ñ ‚?U|ò¶©9Û-¯KÿUhkþ”ÇÜÆ*£DjGöXq˜WcRskÉ`ô ßp^w—B?1©«µã”5ßóDX4“3ò~—Iä±Yiªô'µ#{,?ÀÈD¦çK¾¾KûÕ¡Y^«üë¢HÞä7s³g¯¡œ·3‚d×ûØå|ï(ý.(éÚkĤº\~_”V•Ò_r}.t3è2ŒÿËÊæ‰Ñn>ø¨ I54:tp`µ9?/)ŽlÅö¸Ó¯¯-5F,ó¬‹w,Zð£pR| kh
^LRømwëê+f ñYÚ:“xŽäÙq5 9Û¢õ*Þå]®j]¶ìKê—¦Æ ÏJçá®ùíSÙsÀþ òÂÖÕ>¥nÛ îÕ‘—æxÐ Ö}2Ï‘¼8³Aþñ© O´tî:…K–L¥³Öà>™ÔÌMçbø þ2·ÿs6¿½w›Ÿ÷¨^ô
Ii¿hŠŠ “†œJòìDÖÑæô§öøÓ$C8³IŽÝÍãŸLçÞ¾Õ Ý¸•äwe¾°eÀ^ y{={>ƒí”KM—‘§˜ô5»TQÓeøfó<§¸kiÙf £uG9ÄQe¼±cÀ¸(µ
§«!V
´sI²íÃÙäïcÜŠýÿbíSkÙút$^ù7º›fV¦P°pÆÑ£·‘Y²U}è3Ì™³£³ nsfä1öU'Ø8v—§Àûè2\ u±bðÇƨYÖ;ìdFâðá{€G¸›çôçökq$»)FÖ 4pl×
³N`ë‰DÅó1•ù" fLÆ.ý;Øsï.ÎîúSÎÀåßp-MaÌ+¸öæç ™HË`iK5 ŸåöûÂ8T6Éõ¹àu®¼ë Q{£òi¨ <9/¤º Ç^oÅ àÆ 2µ:k9ªÊ®Œ!ó SNpíŒáì0˜³¾
#™È o8=š3§xÞÌÙrY$Épn™Ô½Œáäáiþ´9Ö>Üþyýæ…V®ªª÷áîT2ýô2Ž
ðc¾£9e¤g©”Á3Ì‘ƒÊ† W„“LáÙÍs9²?ýzõã¨iÓXË$w¾RCι@òÎNÎî×™Þ^cÿÙ<¢+Ð/•-»®‹$ÏAãØ×ß—=Þ\Æ°§,T\ÿÌ‹¿@¨«±û¦HÞû¦/4 ÿwŒ=?ƒõ«4㢫·¹¹½•2?×–s˜¿}û¾Ã }1$#¸¶‹m¡9¨0mĹ!$ï'‘©û8ØéÉERÅú]‰/P•í?ÜÄeÓ†²GGo¾æÝ™oÌÚÅhfñè¨Í7S±jÛ% NÑ3vïxÖ31ÔÎ. qœ$S¸»¯=Ujgݯ#™Éýí [ä[ʱcÀ¸(µ
§«Ï+VK)ƒì\’´¬;ñwêÌéõMž~ÈE±ö±c×õ9 ߶ÏÊ€ÞÃùÞ·‘…¾)©Gɵ·Ð.*1döE®È€£9qh#åñS^¿/J{ «¬þ’ëó#Ui¿žÑ¼ËÕÞ–•o÷¨Ô´ó4£yq UÆ m¦Br/g“›Œ;'
m3eXà‡n\x0’:’ÌŽgðÚ ´W ¦¬;x
ßÉÝ4&3–gVû±ºú9'Õ ¡q`‡©›yäFrî6Y¼ ¶—s›™?*cîÞA{/16o}£‚ùÕðÚù+¾MÝèÿÞNž‹É|´}aBøQ®êåXø TãÌ>Ÿ?ë6e*Úùlàè ì眻}Že3ÎØÊó¿_äùoƲ¾©B)Ü’±çÊ£ OÈÛ‹(“ÑÁÛùO?·"Ó¨iß{ Lú¯?mUEoÿS¬ßKò…Æ‘¾ wóbLú£íŠÒ£/r÷â>¬möøg™°Á¬ÐÜR§8ÒÙÐÌØü£dì&v²Î±½ß6&ò2ç641îØ1h\”Ò††ŒS‰Õç«¥=
Î0;—˜€Ùùòó82eßXÖyjW‚}Lk2`á ^yóvÒŸ?qa@ü-ÚÖ£èÚ›· ˵7W ¿Ç,’ÌŠã ký•ÇOyý¾(õu¬²úK®Ï9åërüÿtdÈ?òw4ªTIuy“‘ýRj<—2oò“–åãØTµMkÎ;™AÞ[Ë¿YŠDå7VË—4t ø‚÷¨ç¥e]þ°C$×1‘1¶K´¤×¬Ô1‚«:T-ük\ÔKx¢¢ 1—³j´jlu5oLXù/8çÓ^x»,ê÷ôLÇôÖñøzÐBœI_I¬–ÏX-d#ö§ è>Ù ÇVîÃÏ÷š ýҫȨˆ]QYÀµq#¸X©€—ûFIAAJýð]L ‚ ‚ ’T ‚ ‚ ‚$ÕO`Ö ÃÂû~NåòXðòçE¼6a)VÏn K±† ȸA$© ˜{bô¼IèߤŠðs)â¼v,½…m·‰ØMí`Uð-«ø< ‹PìF´µTXAíyŽ÷4M¦aûë0¬®éK7 ¬j{ÁÝÄ M]`V
ûT,*ŒCu5´›ù
.$èAê‘pq;fµ¯^à×$3Ôí·;ÏÞA R‡{ÁÛñ.Eü⤆uã@ÌÙø3ÎEý…ìôßñnmí3Ô#ãBA¤úùcZ £?[€.IÛ1»¿?z
ž‹½&½ñþ_a¨[þ×µ‰Ãk±dþüs »ªÇëI;~íо}ûGêôÆG8“ Äü²á:…õ(lð¼ÈÆí/z¡QëVh2l/’d\ˆC-êŒÝ…ƒŸôDòæ1 ƒÍz èÀŒ®£}d¿,mÜÿe!FöòÃëCÿ ~5{ ýôoô¶/ý*K4™°¯COõI¬›ÖÚÄ®èlÃêA„rFѧ UkÇ)k¾ç‰°h&ç˜ËD ›Õ8ÿÈO#;ÍØÊÓwt¹'Yžçö¹éPàXrë@n KbÞ!¦i·Oró„¬Zàt+U•& µþoërŽ9½{á"“I†L¯Wøh^3ûlyÖã†s?KkZèÿ¬Úob “øŸÎUr_3ç+ ]bôùoøÿâÆ;dܦv´*®^3ìJ"£Ö°³Ê zJn!ǸŸgpdIRwûx¡cÜÕÎoòpµ¼U½1mØã»2êS¶4aÕŸ'½§æÃÝhm€ßÕ6-9qËIF¦äVÂèóèW͘{êZÓ÷»òÌXº=~ZZµþ<œùwt³VÏ·±Æ²¡Ú‘=– `Hd"óNÊM¾¾KûÕyòˆ×ç1.Ì_å'dêÞAtRçÅÔ`þ’FÞZò
ÍŸRoÕž?17øQs³GÇQ[·]Áð¤ãœõJŧg=YŒ ‘H$UcÊsΚ'Ã6MãÐÞ¾ìÒ©+ýú âë –¹GKZ³íÒ«¤î"7MdÇ69ð½=Œ¥ŽGÆ×Íßàݼ {
d·vÞôîð:'m #y—kÚäÖ£qâ;î“ÙWøåÌAì8œ3Öžàâ’jË6Ü“ó]»±--KÝy5‡ìc:/pf“Çfªr¾ìs7p/>©VѦóÞã}n °§ºÐñ›†ÔSL{”&OpíôaìÝkgn½J=¹½¯SN›458öÉ+ÿdcÓ¼
ê½¹ú.™ôŸ®9‰Ê‚Î
³ÅàmŒg<·
nAOOOzzzÒÃÕ2§ E~·dÛ
1dê1.á˶½ÙÞ·?ÇŒïú¦Æ ^s¾AýõÙÔ T™;²^}WZª@“zÓ’yƒ‹š™)‹g
k7ò¤§Ww.ºú”¤Z‘}ŒdÃ<Ÿ^_ÉQ~ô ÍŇ <ÇY
M ·ë9Œ MíwLòø°šôøûoLúëçzÕå[§Hž}‡55O míÞÿ8˜LýõOÙ¦JÞÍ‚íK' \fhÔf2‹Eœàæw[ÑF]ôQÓEÖ#ãB$‰D+©Ná·Ý‹|_Sc g¥óÀp×ü'\*{ØŸA^˜ÂºÚ§| m ÷êÈKs™çH^œÙ ?¶ äoE%ÕÐÒ¹ë.Y2•>Î¥? ËÜãmþ”HÞXÙ‰¶ª§ŸŠTl2¬ËwOe“çfÒäøÓ•JJªKl!'Nš4äœP’g'²Ž6ÇvµÇŸ&ò(Q2m42{ûV/ôÄТõ*Þå]®jmñŒ~·eÀ^ y{={:—å)fjºŒ<Å줯٥Šš.Ã0›ç9Å]KË6ë;Ê!Ž*EñœoËÚœx®øÓ;‹³ÑlX„Oµu&ñ ɳãj>ö4ºìÇ…y‹OÁd~ããÈVŸFŒáÆvÎì¾+…¼¹˜ÍÍ _ÞAVÞ"=} ¶w3 =àh’;Ó©+fo=ŽðøTdëÓ‘xåßèn
˜Y™B
À½# GÞFf‰Ÿš…èCŸaÎœ8UŠ/*X¿:
?œÞˆVF¡û¬ÿ!éÏ•4k23½uØ»èK\Ï|ñíyDf$ ¾xt€»yŽínÿ¸G²›bd` ˜@Çv½Ñ0붞HT|¬¦2¿'áÀŒÉØ¥{îÝÅÙ]ŸbJ€'lŒ>M\ä›WdíŽÚ6Žè8â5¨á…!>®°®Ñ¶÷Cqóaù;0TéØy"ú®âf*`ãZõ±{Ïs\¤âììæ¨]§1& O)Ú+q?bD‹¿¡kß X~¢>>8öÞo‘³DW]Å
5« ×wmÀ×ûÇùà£Ø6ÿm||Í:¢šJY=2.A„òÆ3o2¡R©¡B ¾äÅ¡é…'ig$àV: “ú˜´{?–ÔÛ“ðÓ¥ûP¹øbÙ÷ ÃùQa=Ôêçµ I
Û¶óñËÁ÷áôßhýÎDfJ ²£÷båÏ©Øùö4X½M¿
ý©ñ8¯7®ß¤ý¹ý뇖Ã0|Ø|ðã4,>„Þ=çá@|¶Ñ¼™~ë4"ô]ЬY4m Š%KµÿV Zü¯pësD¤X! Y°LPdCMÑ7Yz@¥V•AÛŠÃÌ„›H€5j¸XAƒÈ j¸¹Y÷oá~ÁÊìdܼx7/žÆo¯ÀöÆo˜:ã5,}ó0R²tÈPÍ%çÆ 2cp%ÐØ»¢ªˆÏ*¹ž‡2.A„Ê’T§†íG( }kDîF‘-<àÛ\ð YXôŸè àº
"Òð(©N½v —0 ¾`q2i%4ש˻˜æ¯Æþå«Ÿé©œ¶Æ|±÷}¸þ· þöö·¸[š{æ0 Щ‡¾ÀéÏè c¶§PÛê£gwgðÒA\Ï3ª>¿}…˜#ï`b·ë¨Õ86áÜ{컜º‡ÐÁ
ÖÚgó{ ±øcקøc×rÌk:GC>Áª·7£Ùâ«È4R7³Bq>É~fÀáRÆ®1C‡·gâïvnˆ?xI†ÞéP‡¿ÒX;ÁZ$fUäéö1º
ã² Ù1§p0˜8¤#ì¿ÞX= vè€A͈•§÷´|ÙÐPksîøðNGÓüÚÀiÑeDe0¯‹¿ÕRÎ^EB–²zd\‚ åŒL ˆÄ3Ì©†Ê† W„“LáÙÍs9²?ýzõã¨iÓX+w‘iCι@òÎNÎî×™Þ^cÿÙ<¢#¯Ø4g•-»®‹$ÏAãØ×ß—=Þ\Æ°§,T\_ªYVl».š|ð#ǶmÎfÍš=RSwÛG‹+UæÎlèÕŒÍZå×qäƒïߢw³fl\êМOm¿ó ÉS£\ /PT\²ö@éÜÑkË9Ì߇¾}ßaо’û ÏIDAT’\ÛŶðƲaQósæ#?;Ïu\˜°î;¿1É<¼x$_}$ N&Óã¸:¹óƒµ.ì9ï_œ2,~>>ôï7Ž í¹Kò ÿÝÍ.צl8ë,õü‹ßï˶:qäšPfóW´b@=•}\ˆD"‘¨‚) v?SR
v˜º™Gn$ç®&Êâý°½œÛÌ<Ñ“{?í½Äؼ}ÁôiLŒ
æWÃkç'¦nôo'ÏÅäm¼—Á„ð£\Õ˱ðÆ™}>/ÅÖa&õ9#¤è±xz]rw °hù)£Š(ò`[V)P_•N[™ÈXnlkYôbµ’êQØž’KGö\y”á y{Åe2:x;ÿéçöØBÏœÅ}ö½wðɤÿú?eA¤)ë^Ããwr–Ë3«ýX]ÐïGú.ÜÍ‹1麓 }‘»÷am³Ç?Ë„
f…æ–:Å‘ÎjƒØŒÍ?ºAÆnb'ëœ$ÝÖoy™sšÏy‹Î ºqáÁHêH2;žÁk{Ð^m€}ŒaCC’êç4. ©Îö³¶3$1wC œÝ¡zþç™Öã[ëñrŒ.oÃ9FÝÉ}Ýi^0δÎì>ÿ;†&ès¶ÙŒ8ÄO¸ç÷Ii=•z\ˆD"‘¨‚i7 LC¼\2m<—2oò“–åcµ¬MkÎ;™AÞ[Ë¿YŠD2.D"‘HTá4 ì èÄ•|›—ª
ØÚ»ÿÖc"¿¸–ɸÿö¡“æÅ·Ë¢~?Îû÷qÆgßåú»ÊOà""‘H$ªhÒåæÓ €EbÊ* 62‚$³ãøÇï°Y•òq‚›Å+sùÕWK8ÚÛ^ù r‘¨’ ‘H$U(-
ïö;€×dñ¦ ‚ ‚ (â €Ö Pðð— ¢Ä6‚ ‚ ‚P"Q¹ù3 Oª¯ ðÍ͸AAA(š3¹yó•¼ ?I! Àÿ0ড়ë&‚ ‚ /! – ’›7?¢¸ÓŽí Ð @s 5ÅŽ…QY¹£2Oþ„Óqáˆa
Ã-ÿ¿]9 (60¢ˆ!€è.·ï%I’Ÿ…‰óJ9íXµ‘P,² IEND®B`‚ stem-1.6.0/docs/_static/prompt/help.png 0000664 0001750 0001750 00000121654 13115423200 020545 0 ustar atagar atagar 0000000 0000000 ‰PNG
IHDR ø ä í©P* sRGB ®Î é bKGD ÿ ÿ ÿ ½§“ pHYs šœ tIMEÞ ¬˜, IDATxÚìÝy|õýøñ×ìn6›ksß„„î-* H+Ö¶Ö¶Vë]E{X[µj«ýêϪÖ*ÖzŸˆ( H¹ W Üw²IöÞýüþØ Ì‚}? y< ™Ì|îyÏg?3«¼`&0(²€„B!„Ç«¨¶ _ ;‚9€Ä¾ EÀT)w!„B!úÌgÀÓÀ?CàÏ#¥l…B!„8i6 ÷¯ O€ÿð#)K!„B!ú' à§/#Ëq„B!„è>.êôøiÀûÈ’ !„B!ú³
Ày‡ù†Ãìøò)Üâ˜xý#†0$0ùÚ_ð£™Ù„ Çq™×ð•R¨}Û'sˆ“Æ#„B!ú§©Ý1üaü9œ2Ô†S8oƒ;ßç©ÏÛP!<²¯þ¿Ì >’‘cÏçþ}•ˆ|.}ð}¶µø7Ž:¶,}”yöݦ„QpkéŽýÛVn/4÷8FDÞ ~ûê:êÜ}º*Wóï›&k CÚBV)…ó£«É1íû›h¦¿ØŽ¿ä¤÷l Æ,®þ,ž¿|È
“‰?[R sQ¬ô(!„Bˆ~àGݱü7üŧL‡pÙ•yØÞû;+ÛThíme×ælÜXJU× îû›YrS! ¸œ§Oá¬Ë~Í’MuT·{»÷ñPñô… 9š³ïÚ láîsF3rÄ…¯¾“l8ìßÒªU>‡Ú¸¢R¹Ëÿ¬&E¡ ZM±]ùK~ Ò
ûö
WÃ[¦Ü›nQÃFþZmóW©GÇGô8–I
üÙz¥ÔÇê¢ØÐÕ©l²É&›l²É&›lǽ-ì9ƒ¿¨g´o”ÈÔï%rÖƒC¸£t8?ü}*E…ƃf}CµOð,/¸Œmoó÷’öoþºòMî¹ê;œ7ûûž_ý÷~œ×½ÈD‹á´û?ã“ûF²é—ræiÓ¹â¯ÕLûÃü÷‡¹˜ô&ÁMáYgRÐþ\qÞ9œ{Ñuü£y:¿_º’?Ÿ§ÿë½-lÞÐŒ6îZ. Ô×
”œä³ùñ9áì|ì~–6ú²§“Müœ"¯ãÑEy‡VÁ2”+¯ÌfÓ“ÿa[éžÞ’Î% †!wÅB!„ýÝþ˜¾àѿѨ’§&«YªîÞ;Ný©{»çAjæœ(i á>ÁÞ™DLP©Vªù¹é*æ Ùðîü 3î¦Ü_¨
J©’«3””1k‘úÂëTËd(㾿ӒÔÜÝJmø…Ê5éœÁ?̹ˆ£îÛ¥”ÿ‹E*+ˆ|â&¨_+W>Õ©Jß|X]7#OEiÁÍà[F? ö(»zíܘ#Ÿ'm¡ZåkUÏŸ§þè3eoø§šó|Ë˜Õ ×uÝ@“‚0Ux{©òWÿEMˆ|Ùd“M6Ùd“M¶S`+0 3¿ûû|4~ÖÈ{×må·C6ñä-õìn‡Èá œýÇt²"B¸O"G.ä’ŒfÞ|ú+:z› oÚF¹â³ã13n çìçªñî{XÕßÈËç„AJ)Çóú Ç6Þü mØÙ "_þ¶ÕüyN>ñC.áñ²|nx§ŒšÏÏYIFýQ>üßxÔؘ?n¥£ìQ&F T*TüëfžrÎã¾…y˜ù›¡—]BÚÆgx§Ê x(ã%v¦_̼"‹Ü !„Bô3MÀä#ýÖœ ÈK“˜8?‘ÝoLQU. ¾Ðï£O£p é¯óÌ×:ö÷âöÁ¨¡šf@£‘Í;?lv #»›©p OY*”_f8†¥6>lÛßçñßç©ÇñÆÆ¿ó½o’÷Óì:þÚ]·…jÉÐñY˜—nÅ
€†1ÂJ´5‚oÜ*tá¡ß¬æš{~Éøu=~ žÏœ90ç=N…çñƒþ䢋sÇ×›pI§B!„èÏ&›€âCjÌNäâ¿d1qì¾)m?
5²òÙF¾þÜ‰Ë º}‚=† ÌI¡áµgYÛ|ní;>d³šËéÂØûŸµt í<~O¤ÚzKkXÓ§¥ÃŽÏØ} 7
î=Ëxkœ72—H»Ž—ù›>åùU~ž¸þ—œñ· ³¬µ·ÄzÙ»ä×üëÞ¸å,Úæî±³™›[Éß.ºÇËÜÝûF0jñR^¸äþvÛ=Òk„B!ú±buèO}v?ñÃà ©‹uÏ5ðÅ¿[ØÛ NÈ>Áˆ·ˆ‹“ëxùÙu Ë,}U/së_ncÅMËù$á·üõÍõÔy¢È(È¡å¿ñÆÞ Ñ«¿mëàš¸ýÍ,µ%’¶’§ÿ½ýñûø›¹ï¦h–îð0xÞoøCq¯|ïözu&È”ÅÜïaôÎ¥|²amþX
fÞÀ=£aã °u•9)Ÿ‚ŒhRD9Å#‘ÜEÍö2šÜ
¼{ù×Ï~ÇO¾º›w?µp÷ý/RRmbÜPë‘ÏÝñ%>¼…k Ø÷¥Å&2fÌeH×—üìãõ”î_ÿ¤ÑðÊ:¼—ÎåœÌÙ^±ïçVr‡`DÏuRÞ6voÛK§_z–B!ÄI’‡[œ¯T|Q¸² íaÑPí£{³ª³žoQªú¯jbäá^9y˜_cÎV/w(Uö›a*|ÿÄÉjê
ϨOwÛº_qéU-;ÞU·°|㘦Œ Õ#_Ô*¯RJyÕ×;O%zœË¶Imªõ^”Y½Rý¿EÃU´DžÌ¹êÒûÿ«JÊÛçPJÙ«¾R/ßužÊ Û·_˜*¸µT}ÓVu{¡ù ‡pãÇ_«þoùNÕÞ½‡§e—úâé…j¹çC¶Ñ ¼Mþ®z£S)Uò•nJW >õ)µêj•a88aƒoV[”O}vUº2ìÈö0\ï¨YVy¸E6Ùd“M6Ùd“í$n^û ý_ì ^ܳ”©ÿ˜Àà¾Âq2ÓbÄ
kwñpËw‰Ÿömr§(„B!ú é’иÉ?äüØJ–<¿éä÷B!„BH€œ´xNûá,¬{_â_[œRkB!„B )tæTY¢#„B!„è•AŠ@!„B ð…B!„à !„B!$ÀB!„Bèb:bäoÀØù?eԘĄޚ·/gÝ’GØXÙ…?‡Ëÿ|7©‡ûã½÷ó÷{—`ó„3ìrN›} ƒ ²0ÞÖR*V>Ë'¯/Þs+‹îšOTÝÓ¼°ø1êÝ 8vë¿yᶨww 7j*>ôòÃAí¸‹§î›Î}²sï[LË‚Ú§ÎᥕÍÇüôp_åÝæ•(„B!ú"À7å1á–'9-ð6д» T6ÉʼnÁØÇSKÕú\æ0b
Æoêšœx«ªñªÀá§?À•‹ÎÄài¢½
"“‹È •É§¯õ8gÚ"Îñ.ÿ~g7þÃ&J#<ï"„wÿoð rbߥ´Í â9 yB!„âDø†¤©flcùíW²¾Éh#hŽÀtºê\ÅŠGW–Dñ¯?dæ hþð^]V³?@׬gqÖ‚3±à§áíŸðê뫱û c,Ö8/ >0ö8oòÅ·2äËë(=ìÔ{4éS'F »6›É6Šáʼnlý¢1¤ïùì˼ !„Bj‡]ƒ¯œM8À@
NŸH¬9ðº|Ÿ½½{vZß¡#Š.%× ´¾Ä²·º\ _;¶æ®ƒso3^ÓΘ3Žpí0‡‹(¦¸8
Z>äë÷VàÀ@ú”±Dh¡-“’w!„B!Nh€ß¶Œ^ø;².zœEO,å² ÿ”¢±A<•k"*;#ðMZõ_Ó¶o }XI¹ÃI ˜CxσUý‹k:ˆ8ýWŒJ7ãhæÜ ® ŸÑPñ15n0 žMVth#ü“’w!„B!Nd€Nš?º¿ßøÞý
*[HŸx
ç-~¦?Ðõw/XQjÿŒµ1ù»Ì¾û9.»ëv2Ã{îÛJù+£Vå3~Îd":PÉ“&ŽŸÆ
»p;˨¨L£’ â"9 yB!„âÄø
oëzJ߸‡ÿÜ2—ÞØŠ"ŽüK®$Ù¬çÐ^ìuM hIÅXM½ÿ…¯ñMV|TOXÞ™X{þÂœGáð8À@Ö>âƧßåìÀ?kBa!/–¾Ï»B!„'.À×"°fg XFâï ¥¢:ð™ˆäï‘ÿ?Ž ïQ<Ó&ç`êíï”ÚwÿFå!¯4¦N#7 º%ì--¡rO; –¢³H0‡°DNVÞ…B!„ÃÎ-k±çpÞ=¿!ËÛ@sM n-‘¤™„îÍïÓè-zg,ú>Éæ0br—8ã>¾;Ú‰·ê_,}ésìMoóñÛs¹ì;yä]ý?ýn%6ñG‹ñ[?äó×sÙÙÉû“St±€Úþ0¯?ð>v†”\ùÇIŠŸÌ€õ
Ž‘2ûO|oŠ§Ç}Ã×|öÔS4¸uÄ÷'1ïB!„Bœ˜ ß_Ï®/¾"jô¦ à³í¢¢äŸ|úê'8haédšxЗ=RF’“D ˜±öwQûêÕü»ågL=ï<²R²‰”£–ÆÒUt ö‹ž Ôð ugÝJ€OƸ| Ú·íÄÕ½ Ý߶‘ÚHŠÉ%op_õðicÈIëqH¯‡µF}rró.„B!Äñ ¼R!„Bñ /kB!„B|!„B!„øB!„B ð…B!„à !„B!¾§-’¨â •+YêBˆoc‰ã’‘‹|O¢Ô©Á2I|k¢+Œ™ ):ï |~ö5øOVJ¢¦1äòkˆÚ÷ƒÚGX÷ö|ÇÜJSˆÎÌFÕ¯£ËyH®´h¢‡Ì$Ùµ•ªõå!èG9W GO†¼œû[]ôe} ©¯=Ž f’4j&ç{ÔV€kA_Ö…ôÓã¬Ó~KHþ¯øF,#ÿÀ° ‡ü¼†ê—ï ¶]¾í)¤2:›pƒ|ÜI PŽ¯ØýÊn ÆxϺ™´ã<ž!~y玧õõMt9Ý'4í¡:×ñ GO†ºœû[]œŠéßžú:ý«/¯§â¸*þ7Ûè—¾×ö‡ØRiÁ4à'Žƒêwÿ6‡ O‡OJ?¤ü¸w<Èæ–4üœÔÒõwájíƒ ·Üø2”rBƱþ|-Kˆok€ÊYé–è4Ü-{q8ùò\s.)“’6( ³ Pn<-ŸSþγØ\Jß>Æ 2çÞGJÃ}lX^øHÉ<–Â…¿Ä´êFJ75¾²×`%fØd
ŸHT¤ åÜKÛ¦çÙ³a+^DzôÜGN$÷;‹ˆDü]e´¬ÿ•[+ðóýÁ½¤G÷GɆbG_EVÑX",('î¶2ZK §²²4+±“~JÖÀ\,Ñ4ûl›iZý4Uåû¿ò8dùêµu’{ù]$†þ›rñ3¤ì‚ÊïgòÍò˜~
ﾓü¶Í4”X[‹Ç:ìJÒιÏË‹©ë^Rš|éà-§ê[¨OšCÁYñ-¿ŸÚOw t:×RS²§7†˜a HŸñ ÜKî¥ÁæÓ—æ`ÎuÜiÖÓû²õe]„(ïºÒ…õ´ÅäõѲúqªZ5" æ‘9s1aïÞΞê®î૘䢱°ýö”TáqûÐÂZ›ô׃fÁ’1‹û=v² ¯1kñ¥dž¿˜°·ïdo]ç¹ô¤Ùˆ9ÿzŠ¦ƒÚ©]QŠÃîB³$a´µt(¡ëú²ýè«/}“+½•s¨ú ¾4÷:þh±ÄŸyÚh^ý-í&,Yg“™ä„šžk®ºèõ®§Ÿö¾ž¾"!ªS-2˜˜jßÿ;öד7ÄAÝÒûpºžS/¦¥úY:ýúÆŸS®ýˆS=À7aŠŠW U¥t:|À.:ƒÞGÏÝé$²†'b[q#{v¶:|}¤?F^ÑÌÛ?Àå͹ ð5о»aÿ»Z 6ÿ&bÒÐêët^@t¤ÇoÇÝfƒ ÷HyŸ@fQ"®õw²{ݞpÜgÎüf#è*¥uïF|@G‹ëü…$¤ÇRßÞ=›’|éáÆÓ^ƒÏ܉‹×Vƒ£õ7 kiÞ½>æÖHâæ/ 1ÝJƒUg]q®ãL³¾vØ—ý«ïê"ty×QÎÑ“È š€óëÛ(ßP…Ú«+Ñþ@Ƹ‰ÔÖ,Ç Ï±ëcZªÇWÜöí´WmÁت+Pßû éã'P÷Ö'ºÎ¥+ÍÆ|2&ÃXÿO6¿ûáaË+tc]ßµŸàêKß9XÎ!j‡ºÓÜËøCô$Òs£p”,¦bc` m¯uWôËà.Ò:®úúrw=ýô(û˜zï;!‹ïCU§A{Ãlª ÿìõ[i÷n''?‡ð0NW0ãÏ©Ô~Ä) àÛ±zŽÖYW3øÊqØË¿ yÇ'4UV÷Xî¡g =7ÔÈÐÂ0Nû+c§ šŒtLpùCs. -¢ˆÔ‰sIÎ @¸EÃçp`0€Ûd
qùèÌ;6ZöÖ5K¡œµ¸¼â|8ûÒl‰ŠB#pñîOiÖ×û²õ]]ôeÞ
±EDÐFsUÛN_=íÕmdä%Ü´ ·çfÞ[C[UéùÅ„›>Ñu.=iöD&Úö’¯ŽXV¡ëú®ýôe}…ª êMsoãÁ: m4ÕµÐ?æ7¿¥õ Õ{ß Y¾ND*ݽ*åC í…ÄÇ0þœŠíGôë ümËÙµd
‘¦˜?•Œ™³Èl|›²÷_ÆÖýú¥Þ÷Q(šÁpħ¾5MCÃFóG¢®õàÖ®|û ¤Ò“žÞ{w*)3o'˺‰š•ÑÞÚ‘ÃÈ>w>a' |™8ÊÀ¦™Ð𣂠ÔÔÁÇ
a¾N _ -hý3ÍzÛa_ö¯¾ª‹¾Î;ýámÓšâ4«@—Tê¸ÛXhÆÞS¯¾BÛµ\ ü€|S9Ê°}j}ÕO{ï;! yuÔiïqË¡ÇT~ÿ NÅö#;ôô›”ømØËߣòÃ;ÙðÊ‹8“¿CÎÔƒýÑöñwáq!6“áH
n3¬D'qµVãè±9míÏlëIÏQoÒ±&j¸J_¤¶l ]ÍtÕí:ö FWz<ø|@X,ÆCêïÜ…›8¢ÓŽóšÁäKùðûS†ã9©ß‰ŸpLfÉOóñžKÇq‚j‡zÊPÏ>ÇÛžCT>Aåýx˹½±Äd¥ ȧ1•ØÌ8hÛŠëD¿ÅHLz ´oÇ¥ó!=iVö2ºœY8–ð¾ëú ýôe}…ªêJ³ŽñÇß¾±Xs2BtQ>òµ ¨¾ü-«w=}'dmLOêˆ[š.©þ ëžþ--NuBÆŸ~Û~ı…>'|¦Ä’Š%Ò‚)Ú€9!‡‡ O[=^¿"ˆ {ñîRlMõx}fÌiù„áÇeß·°LÇ>ª [Ùn˜<—ã ÔW7£"
ëq3ªºJ¨Ú<›Âw2Äòõ{öàñ‡cŽMÂ[¾”¶NŸÎôèৣ
b ¿KjóR::]h–¼ÀÓäA "=ÊŽ£¾†_@F‘6GfãšvÖàïXI]Õ Nø%Ôë´v ϘN$Á½¥!¨|©.œÍ6(<ô‚Nlžh̆4•ÕÈù;Ëpxg?þ{$7á1Äc1—Ѹ£Zßq‚HóqŸKÏqtµÃ Êð¨û„¨=‡¨|T0y?Þôt®¢jëEŽ½‰AþÿÐÜj ¢`.±-4¾[äzn’/ k„…ö6 –¼ï‘o§õÃÕ¸u6 ¥'Íž2j¿ÚHÂÔ«z~uÛ7ápxÐÌ ˜
;õ ²±®ÛO Ö—
U Ô“f ãÏþz uù†—i¨iD…9èúd${äk®¾üí¬w]}§Ç§
ÆÔyžæÚ°uéGA-ëÑU§:â–¾ úkûý2À7^xÅ=¾è*óüß“Ùó‹®´0 Z,Ö‘?$5"ð¥rTÒ¾þQöîê^»¦g |¸J ¥,ò²‹®%dà.ÔkÛAKûþ'PèXµ˜m —‘5ì"r ,€ oû&ꪗ>çÒ3¢ÕÒ°ôQLS.!múd»ïŠ»*h³ñ _PéñàXÿµ‰?$í´_¤:±oý?ZÊjðû›iZ~ ÆÓ¾Oú¤Ÿ‘¤ùð´ÖI‚Ê—›®¯ÿN}üÕ¤œñKRTG =»jðsN×*?]†iÒ9 œ9 ü6º¶=AóNAw0i>Ú¹B•f¥£ U†GÙ‡µçPÕÁäýx˹‹Ž•÷RæüY#¯#ß ¾¶õÔ~ð,5A¼‘%¸ cÑÃHr¤eßIã§RYÑ Äô¤Ù‡kÛ#l±ŸOæèidL;'0Cèm¡kÇ3Ým#DcÖ‡í§Oë+T}PGšu?v:VÞÃή«È,^Hþ#àÃkÛNKû±<ø}”kÒÓ—¿õ®§ïìŸ',u‘&
²Ï :|9.‡
®õZ§zâ–¾ úiûÇ6ÁRÖÿ³•oEѼùx–ý” åò|»ÇÌBêœ?“í:ÂwP!N=æ<ÒgÝMfôÇl]òºúëžÉø#Ã$Eð¿ÂB䳉rWãt8ÑÂ3‰q ž
ÔÔÙ¥x„Bˆ}1³u<©£Î'5¹ƒ–ÞÀ.ß.$Àýs´Š""ýt2e æQv\u_°ç—huÈíB!Ä~aiXŒÛ©zóÏ47tÈRqÊ‘%:B!„B|‹¤„B!„ _!„B!þÿ-’¨â •+…,„B!úLÿyÈÖ”Btf6ª~ ]Çó5Æ¡:ÎqøÑD™I²k+UëËý0QÓrù5DíûAíQ^ƒÕ_òÞ_Ó#„Bñ? ßL.âg‘wîHŒ1õ‹ãôÊñ»_¹ƒ-¯=@]û©•÷o[]!„Bœ
$òêïü]¸Z»À`Ç-ïáB!„½8ñ¯É4ç’2y!iƒò1› åÆÓò9åï<‹Í¥ÀTHîåw‘~˜Ø¶ü~6,ÛŒÐ"'’ûEÄÇF¢þ®2ZÖÿƒÊøºÓkzBeß7Ë%tâõEc2‚߶™†’§¨®hÞ_è½ækÿñ’H¹ør܇Y¢£7ï!Ë›•˜aW5|"Q‘&”s/m›žgφxƒ© L˜³g‘9z:q©)¾Á½Û†‡)[·YÔ#„BÑï|3ÑS aH~ uŸ¿F[› ±ÄøèØþ5.`Ÿ°Ø$Â’æPpÖplË臨ŀr5â´»‡2¦; ÕÕ†O³Ux9Þ¼‘½õnÇÑ“žøæOÙ[²§7†˜a HϬcï’{i°ùtæKG€¯· CÂBôÄß1d˜‡¦’Whn´cʸ€ã†áüüf¶omDéJsþÏ(š>j?¤nG)» Í’„Ѷšæ†NéB!„ÇÀt¢oŠŠW U¥t:|À.ÝÜxÚkð™;QxñÚjp´ & õ5о»aÿ»Z 6ÿ&bÒÐêëPºŽ£'=!Ö±–æÝëñ ‘ÄÍ_@bº•[«Î|顳 CqG5‰¬á‰ØVÜÈžôÕWAúcäÁ¼ý\~ é1å“1y Æú²ùÝC{s%„B!þ‰bǶê9Zg]Íà+Ça/ÿ‚æ ŸÐTY}ðò=eD©ç’œ=€p‹†ÏáÀ` ·ÉtRÒs,”³—,QQh‚ãÐä«ïh±ÃˆÐÂ0Nû+c§ Z¼é˜ è
Öµ¨ÁD[À^ò•÷B!„§N€þ¶åìZ²†ÈSHÌŸJÆÌYd6¾MÙû/cÓûêDC*)3o'˺‰š•ÑÞÚ‘ÃÈ>w>a'#=Ç̇R i¡ÏWŸøe5‰2 IDATš††æþD]«çà_g«Àì¿RÒ …B!N¥ ?UÛ°—¿‡½ü}ªãÏgÈ%—‘3d[Ö× X‚âwâ' “ù0oî4¥cMÔpmx‘Ú²ÊÀßØ"p{ùf |´ã“ž>)ý ò¥|øý€)
ƒÆá?qГ÷ã¾aÛŒƒ‰D'qí®8úƒ°GI²—Ñå„ı„ïZÞË,¾‘°ŒsHÍÒ°mú›Ã'=W!„∑Üsâ AôØï“šdA3š1E¦•9ž„¬t¤t+(#ÆÈd"’†bMt ”/LùdÏþ9©Y#ˆ5o¤ao 2ï/„Bq2|-KÆi¤ ›EjñÙ$9ƒøD? [ž¥¢t÷Á¥¯‘®Žh¢EÊÐ3HÌ ŒÉQJkU=~Õ‰½ª-i")#. µh:Iù…í•ØÊ?§Å®ï8Á¤#áyW™‹!ÖŠ½tŽ`ÞC¯+À"_øð4ÕbLDJñts s”ÒRU`ýhyU¾ðà®^‰ÍOLÞÙ¤=“Äü DÇ€sO ¿¾º@ákúŠ–&á“H.>›¤ÁSHȈɵƒÖªºiV>´ø Ä'8h[ÿ.mmNé¹B!„G
CA&CÈœGú¬»ÉŒþ˜KþA—Wò%„B!ú7ù&Û#0XÇ“:ê|R“;hùè
ì^É—B!„ ÿÔ–†Å¸ª7ÿLsCÇ·çcŽok¾„B! Kt„B!„øV1H!„B!¾B!„B|!„B!„øB!„B ð…B!„ _!„B!¾B!„B|!„B!„øB!„B ð…B!„ _!„B!¾B!„B|!„B!„øB!„B ð…B!„ _!„B!¾B!„B|!„B!„øB!„BH€/„B!„ _qÆ4Ç/$#+MJC!„'˜IŠ 7f’ç¾Æ‚ó3ðm¹§ ú »’R9•hQÓrù5DíûAí#¬{{
¾> ð3I5“ó=j«Nõ#…èÌlTý:ºœ~i\B!Ä©àkÖ³™ýÛÉ·îû‰ƒŽŠUl{ÿ¯¬Z]ŽGᣙùÐ3G}óïÝ%×òä_á1d1æÞ·˜–µOÃK+›9lll ÈÐKngòÔ ÄYÀÓø5¥oÞÏg_”áîùQS¹ð¡¿ jÇ]ìOVb¬ ŠŽÊRš[Ä œÎø ¿À“R¾±ÌÀQñ{KKº·•ì.oÕ P’)¼ö9f͘@œ¥ƒŽæÂ’Ç2rÑ?¹`rjj„ç]Ä€ðîÿ
žCNlä›âIèî •t‘DòÈ+˜yϳœ6(êØfS˜ ¸KظïkÈCt̾ºØBCM aIÃ)˜ý W^w>1²Èªwþ.\{q´TãöJq!„âÛ—%:[Yõð6µE“óýW¹äŒDM OĪw°ïߧ…ÿú9Ëv9-~͸„)cc@maÅWóu-$Ì|–…ó‹È3ÄÕ¡Ñ MúÔI„QÇ®Ífò†bxq"[¿h<äf¢”Ïÿ°€M™ÿäßÌ ÏIJùw/Ò ôš É§Ï ð–¾JU×Éœ-ßʪ‡¯bS+X†ÞÎU·\BôˆËÉ{-ßâ¥á¤Ž»€øÌ|"bb1 ìt–ÜÃö5º7X‰vYÃ'iB9÷Ò¶éyölØŠ7˜*3$7z!™ÅcˆWx[×Ò°ú9j÷ øäI‹œHîw ‰ø»ÊhYÿ*·VàÛ·SXI¯&£° ³Á‡§¥ô|woé1æ9÷>RîcÃòRü æ±.ü%¦U7Rº©!°Ÿž2ìu¤($÷ò»Hì¾ÁN¹øRöÝ?•ßφe›Kžt”¡®ôèJ³ sö,2GO'.5#€§Û†‡)[·Y@$„Bü£òáóv_.
†>(h 2ÿtâ ö¾ÎŽú@Ôºæuç‘’4™ŒØÇhlöCD1ÅÅQÐò*_¿MÆ°9¤OKÄÊ÷¿lÆSɶז0iô"b^@Žu ›Zƒ¼ä‡¡x\à ⓵8ûÅj?Ϊ5ظ„hbˆŽ0 KèxÊÐ"‹I. Û_`OI ·-ÜŠ¡µ©;ȳ=þn
‡yh*ù+UvL0`üä»nfûÖFŸ&Ea=m1ùC}´¬~œªVÈ‚ydÎ\LØ»·³§º å*§yÍ“4uµáÓ¬D^AΔ_áo¾‘½õnÐb‰?ó.´Ñ¼ú1ZÚMX²Î&3!ØœëKOhÊPo9UoÜB}Ò
ÎŽmùýÔ¶xºË¤±ûy}iÖ“žÞ÷1bοž¢éã öCjW”â°»Ð,Im-Ü !„ ÿÈ
÷“ÿÇ°˜ÒÓb 'åËWã8(*H`į¿dÄþÿ¯åíë±£Kßé-Éñ ÁÞ„»ûª¬
`Z‹#6ÚÍn̹20\>£¡ÂB{yƒg“ý;: ¦øš·Ð® VK$Áj‚Öàá°1Ø
8W²igDZ•pÔlæ=1;Tá.†ˆL²Ï¾"°ŽÜWC“ÍÓƒsSc÷"åGy øé&Éc×Ç´TóS"-jYñ¸‘=;»—†ÕWAúcäÁ¼ý\:¢=-z™Cp~}åªP@{u%Z È7‘ÚšåçA|
´ïnØÿw]-›1i hõu=‰ôÜ( %‹©ØX8Nƒ¸¢_õD»®ô„¨ õþ½§½Ÿ¹…¯Ç!ýIwêNÏQö1å“1y Æú²ùÝuÕ±B!~÷¯ãíþ·—šðö—õߘ sT|E£½û§®-t ËëIÔÑ"¿’'M& ?Uváv†SQ yF3$7š |k>k>®Œ"íŒéD î¯Rs̯Îi£aëvœ
´¨!dˆ=Æã1ãÏk˜±ÿÿ~ß}ŒòÎþúm8ѧ?Báà}Ï?tÒôÖ/¨¨s…ö&"vZÆieì´C~iOÇd@Wðgˆ-"‚6š«´_=íÕmdä%Ü´ ·´ˆ"R'Î%9{ á
ŸÃÁ nS +¬C°ÐFS] ÇS3ºÒÓÏ‚Z½e’zL´ì%_Ip/„Bà—òáM?¦yÖ˜N*icF±¬,ðýŽg
¾gSŽ™Œ¹;Ó"R°h ´wzÁ\@áð8 ²~ô7þè@àŸ5¡€°_s¸g'MI#ˆ× hnòéʈa t²ûÓ sXÚõ ?zÈ[töÇè^ ™,º'º5SD`-q÷ï:TÍv:í6:ë6S±ê¶”ַƼO¹±¯ˆí;Í%]Ê»%ôK‰4MCÃFóG¢®õàèQù:ƒ|¨¶—Åg†TRfÞN–u5+ ¢½µ "‡‘}î|ÂzÜxÖóÞòxr×Û]1JÒes':Í¡¢ýCÉ[¤„Bˆo„,½_G»¨}ëOìt€¡ðgœ>,”_ÖãÇQ¶
À€‹œbÌÄ»˜d€Æ/©i÷cLFn\ P¯Ûx[Oåžv ,Eg‘`>Ì¡Ã 1o 1€Úù•¶à¦ùÂó¿Ç H k›vužÂ÷uTâ ˆ+&%Ú ˆÈA4@G%ßÁ7[+ ¼œ~-o<ý6léÏÁ} óµí £z3¶êÍØjvàt‡>Áþ¶Í8°lÄÕZ£Çæ´µ üi“òá÷¦( ‡4b{)b‰Éêñ–(c*±™qж—0¥cMÔp•¾HmÙºš+èªÛuÐM„¿} b±æd ×·ÈéJ¿ ±™˜úêmJ~'~Â1™
Ç–æPµ.{]Nˆ, K¸¼IJ!„8ˆ®eÁÊö)Ÿ½±•Áó‡2äÒ¹””þæý¿M`ð•!ÎîïqñýšÏžzŠ† ô”Ùâ{S<ßܧz _nºŒ™Ã‡1í 2¦YÚØÙýúË4{MX‹Î PÛ æõÕRpå o$)~2L4ìŸb/bʯszr6À»ÏŸ› â{ÍJÆ™S0Žõ¯Sï<1…ï~‡íÍó“8Šú€ñÍ`MI ØJÞ¡É
DI#=úýg U›gS8âN†X^£~Ï <þp̱IxË—ÒÖs½˜êÂÙlƒÂóH/èÄæ‰ÆlØISY
þÎUTm½ˆÂ±71Èÿ š[
DÌ%#¶…ÆwKkǽõt´AláwIm^JG§ Í’‡¹G/RûŽ3ê6ò
/ÓPÓˆ
BÁ-SzÒC;¶²Ý0y.Ç9¨¯nFE}® âûÎ2 ÞÙÄÿ IÆMx ñXÌe4î¨ÖW†¡â)£ö«$L½š¡ççP·}‡Íœ€Ù°#P§Ò=„BH€ÔP”¶/þ »æ_ìîC2…×>Ǭ±1@ Í“<–‘‹þ‰Õÿ]ÞXÙŽÏ H»òõ 0ü(àÆíéq‡ž¶ˆsg¼Ë¿ßÙ ’™(SÖl
w ·µéÿCO-UëKp™Ãˆ)C¼ ü
¨jrâªÆÛsÜ9bšu–³]pÅh£eÍ4 Ë ¡¿ Wk츽DZGoh¸w<Èæ–4üÇ1 ªã„(0Ó,x+_§|M~s £ç‘93 Ç‹ÓæT€sá/(œ˜K×Ƨ(«ƒèW‘uþÏñýç4vÈxØ×mì¸ÇÌn¿Óʇ×+¾\w¾%¾!i*…™ ÛX~û•¬oòîÂ#hŽPv<7- ÝÅ« †tF-~—³r éýÛøïÇõûgQ´ø}û—òù °©3“âŸü›™£ó™¸àB6ÿîE:Ó/aÊØP[XqçÕ|] 3Ÿeáü"rçÌ#qõø\ @á÷ö•Bù\¸<
Âü*ùâ[òåu” w߶|ú ¢oé«Tué? ê\ÅŠGW–Dñ¯?dæ hþð^]V³?ˆïY‰‡O³¾rr±£¯"«h,
”w[%SYÙØ'¼€ÔqŸ™ODL,F€Î’{ؾ±h‘ÉýÎ"âc#Ñ W-ëÿAåÖ
|ê@w0gÏ"sôtâRS0x±mx˜²u{åm°3ì
²†O$*Ò„rî¥mÓóìÙ°5p³e*$÷ò»H ï® Ÿ!¹ûèÎÕ¿bˆ:”1‡Ì¹÷‘Òp –—Žk KáÂ_bZu#¥›BW'S(¼â'„o¹‹Í_–w·™Hbg<Æàä(]òv½±Œ9—”É I”Ù(7ž–Ï)çYl® )N¿†áW߀É~ÛfJž¢º¢9'=y?¤ S.~†”}×–òûÙ°l³þ 2,‹¤‰W“QX€ÙàÃÓRƒ8h3$7z!™ÅcˆWx[×Ò°ú9j÷6£°`ñ7
¢žcßàéY1á(¼òZ¼ï_Ï®3±“~JÖÀ\,Ñ6æ³m¦iõÓT•7†°éLOµ³×6¯ë£v uá×s ͪ¯|ôôw GîÝϳg÷¾ÿo¢Ó=”„󲉊2Òæô‚1›”ÑCQ•±kõ*<
Ú‘òw¿¤ÝðÙÛûGª=•l{m “F/"vàäX_¡"ÿtâ ö¾ÎŽî»ÿÖ5¯Ó8¿ˆ”¤ÉdÄ>I¥Ãøñù
D™ËðÁ5Ÿ.ÅçW ßí?à{›ñš&pÆœqìzí8Ó>„âqI€ƒŠOÖâÍJTáäLùþæÙ[ïÌèå_OÑôqPû!µ+JqØ]h–$Œ¶–îÁÇBôø») æ¡©ä¯T5Ú1e\À€ñ·’ﺙí[QÞrªÞ¸…ú¤9œ5 Ûòû©mé¾±´7õýÍ”s+Í00{æ’rœ~À”NlŠ_Í:\ºP3Ño&gP uŸÿ‘¶6;„'b‰ñnŒ{ê\KMÉjœÞb†- }Æ/p/¹—›Î“ ± A¹õ÷Z,ñgÞÅÀ6šW?FK» KÖÙd&ôÜ)
ëi‹É ê£eõãTµjDÌ#sæbÂÞ½=Õn¼¶HHÂd V£Œxl¨ðDLtÐéð‚fÅ’QL„) ¬ÇÅc v%içÜ€çåÅÔµ‡jªË§/=:Ú¼r¬f×vb4Ä“pÎm¤ k]è9ŽfÑQ>úú{3cŠH1Íö1í¶@ÙhùX£ÁþÕNŒEw2l¼™Ú7 £µb3ó0i{p«Põ ㆮñ§·¶Ú¥¯œuõ‹ úûÑ&¨Ž«3fêízê¢GúÛVP³ÖÇáV õ~Ý î\G-Ç^¯_zƒî~”æ]›Dp~Û2>zas¯<ƒ¬‹ gÑ…MÔ®~
ïÿ‹míÏlDÍfÞ³û<á¾æ-´+ˆÕI°Z¨KLó+{nÿ¾Á¥!LkqÄF)·» />’È›{SA]ÇZVûü€3àï›j¨ú+š®æìÓŨU¯ WZÃ^Ä`+à\ɦ '®PB˜æPÐLŒÝïSQ~”ÇA0Kµ¨ d%âZ'»×uϨ™ÃqŸ9ó0
×c×Ç´T;Ð`hßÝ°ÿ¿]-›1i hõu(S>“Ça¬ÿ'›ßý—ÿpé™DÖðDl+ndÏÎÖÀ@W_é‘W4óöpùÝxÚkð™;QxñÚjp´žÄ›U;¶ »àôÉÄżM]»-ºk¤‡Îò½A,¥0aŠŠW U¥t:|À.:·kÇZšw¯Çt´F7‰éVlº?Ù EjÑ“HÏÂQ²˜ŠYÀöZqE¿Üß~´èIdMÀùõm”o¨
ìS]‰–ð2ÆM¤¶æc<m0$“A#là/>-‚Ê—î¢1"
-8 =J±«”Ö½yo1c¿„ôXêÛ›CtsçÕŸžÞڼߎ»Í ïqÔ…®ãô^>Õßõ}z5䊟¾]Ô¼ý*ž}÷ɘpÒéð`LJÁFx˜{—’’1Àí M¿Ð5ntŒ?½¶ÕåfàVÎ:úEPýýhBÕÆBÔ/´¨ÓuŒá=oPJiØzô±êH× }× ½O/}9¨²ê'iÙµIàƒ“ænàïkGRpÆÅOMöÄkHŸx ùO]ÆÛ+ëzìÛFÃÖí8hQCÈ ÛGÑãGujÜJ ñßÓa|¨èq
凔ÓÆaqøøû¦VÊ_ùµcoeüœÉ ûã§Q¤1À½ñUjNä«sB–æP'úôG( ¼ïŽ©“¦·~AEKÇ#-{kû9-¢ˆÔ‰sIÎ @¸EÃçp`0€Ûdê Øm{ÉWG À´ØaDha§ý•±Óù¥= “ýƒ_ßÝ
ãÙ³ŒŽ)?"q@2õK ‹Å¿“šú® ŽcǶê9Zg]Íà+Ça/ÿ‚æ ŸÐTY}Ôˆ•³—,QQh´öé'ë,´ÑT×rÄób‹ˆ æª Ë¢|õ´W·‘‘?”pÓrº:jð†en¶6x`"!3Žw&gÕg4÷å=2*"”wløt¦§·6² Z>¡ìïËØZÊ_]ŒÙ:¸â¹d̾Þø-5M®ƒ‚®Õ·³q³O§—˜áÁž¤÷~¡gÜpëô´ÕÃÝ” ZÎzúűö÷“Øštõ -¥ïÆðP^/úª/÷mšCumAøãm]Oéë)}ëÏd\øó.Jþ%W’¼æAš÷ß–}ÆÇ òý§7°„ÂdÁ`80«kìñ»cNxÒâ5€šÛ 8›Ú€t´ÈdÌÝP‹HÁ¢´ÒÞéÁ×Õ† <›4µ–/:9}þl2÷ îÖo|$äk|“ }ŸùçœÙsi~³HÃ>*èd÷§qà
IšCÂ}ýClßi¼5A¹q·7+£i&4üÝÏH O¤—JÊÌÛɲn¢fåC´·vAä0²ÏߣŒT =*u”ôhhØhþèOÔ òÚ6åë â#…R }ò¶åXOC¥›¼!“±lY†%o ªá:‚\+æo[ή%kˆ 0…Äü©dÌœEfãÛ”½ÿ2¶#¾ÆÒÈ«v2òî´žsGªÙ£—_GnUDDÂH"+©Ûh$¹` ‘µ ÐùY ¨Ò_Ï'âŽFWztµùÃÍ WŒü ¨Ðß4|\-»pµì¢£ºãü;I >ˆº·¢œx±`Ž;îN@‹Ã eWãá×\ c¿Ð7nô>þèi«zÊYo¿8¶þ ª¶qbúEèÆp=ׯ+˜¾|Š¥9T×&q„j8ÂÖìlÂ÷ýÖßAKEuàý9É„ë c| •Yä¸bR¢
€ˆœDtTâ8ÖÏ` 1o 1€Úù•6/Ž²UØ \Äà3`&~ÜŇu¿¤¦Ýßш‹HÒ§£¶.aÛêÿ°×WÄfp¶â>tÌúÿìw|•Õýøß³0ök IDATÏsoîLîÍÞ „ÂÞ(¨ R\8¡Nĺ¾µÚZµ¶ZÛÚi[«µŽþjëúZÛ¯«E¬¸©¡Ù Ùã&wäîñüþ¸ Dxn¸ ày¿^÷õb<ãs>ãœÏ9ÏŠ‡ö·þ ÍGôú’ËeÜ RQ× j¹#—9n#*öj\;p¶îÀÙV/cBÙ_G€d³pÛ=m–4 å‹´×îÄmkÄÝQ·_e¥xjqûÀT6mŸß¡ÁÛ ‰ü}x‡ü|N‡úQLj› dk ÚÃ¥„‰D Yæ5Š Ƕµg’‘7´,èß½àpêЈOÃÛ4¿w Ûþõ"¾Œ ( “¥Þ>±”=â#‚ nxÇfE ;ñbÅR˜û¥oE •x±’”Ÿ¹¯ š,¬yÉ`ß…?Š¯OÀŠeìy˜úVÑU¹oÊB2‹R v ûMUò¨ðù} ‡+éHl¡â9Ç"Þ¿´³ƒ#MŠ·g?˜JÆ |™¡Œ”4´Öó¦)‡ˆ 5õ†ªúG…¯Æ+.âïqòxÅEÜêpU ¿8½+¦X>†2 ªÝQ+s<Û&º|Éz6çüü—䇺°µuÒH ‘GØñÝ*bCoRe»œ©i“Yðà»Ì°%3 pn|“ž˜§Õ–3çG+˜›Q€QBÛXûÂJœ õe>©¸’…Æ3ï·ï1Õ&aIK<Ô¯x[èoص~>Ø„§_aûN/£¦ÁÝqÐOOJß{¬ýð6®<+cÝa ¹gÌAx·® Ó7ŒG$Îæô®#C—@RaôßÒ<À¥S|„ZþÁª—Öˆ§ÌÇŠk= -—P4óF(+èsiÐçÎÇÄä:¡N\v°–]J–m®~?’¡8º3ÄÞö§–öÍÛI=ízÆžWHGU^oI—ŠN®¦§¶ˆ{#-;Q6ñ>Æ^£³©‰`DΚN¨aö~•=Vų¶ NYBÑt/6c èRÜølN(;‡œÒ~œÁDtrMTž®‰t½Cgß™äÏ»ØM}K¬ æ$N»š”@%ΞNBa ºìˆà÷Äð]*†²Gúkñ†‘2ã2Ò5å ºZº«[U5ŽJÿZv]DÙä{(‘_¡«E?f¿wí½fÚ]ŒŠ¼ŠOÆXº„\k/ÝomŒ.´ wârhI ‘‰ý½múeºº—1*OÂùi×0’ MÖå”w>ºöÿeת÷c› F 5>?dPÀÛiƒ ç“[îÄî5£ÓTÓS3ÄÔØBÅsŽI¼ËÉX'ž…¡¿¯×‡¤Ë"±ìRÒ
vzv ²n¦{ë.²æÞDñt 8qVvÑ´«%› >.5õ†šúG¯Jñ‰‹¸Å{œ|#nq¯:\M‘ãõ®XbùXÊ|¨v'™¼mÄ–àG:©[·ó”©¤E7E ;ëhÜø< -ÿ ¯¢ò\ÿÖ>t/\{+Ææ“œ Š·‰ÆŸ`Íò¨î€†úèëò’•iÄ”U€ân¦b%›_{žº®Ê&ÒIå_®Cþæ™uêT,iêÙÂÎÿü–?éŒw Ò‚›¨¨r€ ®#0õltîv~ž†—ÎwŸ¥ãÌ Å~ ƒi
'˜ ;u W2¬¥– 9äOžµßAWræ$
3Äÿ¢•Öø ÌÇ=k @sêuäÌþ.éR˜`_ÇÀ”ŸXžÓNתGÑÎYLöüûÈ× Œ(¹±;{]aü»ÿÄNÏyäM™Gî¼³££[¡^ÜÕÏÒ[×FDñàÚp?»]W’?þ"F–€!G «Aõ² 0þÊG©5ÝHAùÍ”LŠÊrVÓë8°ñ àþìi:S®'óô;ÈT\xvýe@ž®‰´Ó³y9ߘ uoáðÆ8D"% KV,“n"˘00
ÚŒcë£ì©ëÁ 1”Ý¿æV£}6E Ï…ˆ÷î'±Õ´ª\¬íÁµþçÔ¸¯%oÜ2J&jˆî¶QE¯cÐîn\ëAï[äOú%:Û·Òþîs´µº3"¼íÝ`ÝIg« ÇöÍ„óFàìõ ñe²&cÒJPp:‰ú5øc±‡yTùü¾ÑUïÖ§hO»‰ìSo']éúOíÿQe‹C<çXÆ;:ËÈ¿ƒQ ø ôl§ý½i ´)aü» ¥*á[Œ˜ò?”L†pß&ZÞz–žXöÀWjê
5õ
_%Nq·xÁÇŽ8;U§ñªÃUê9 ïŠ)–¥Ì‡hwb‘ùHÛ&Á¡ÃBüŽÆORŒÓ W¾÷ÜçÊþDÉÕ Äã'YÎUÆÝô¼R:2Qè#VÝ%_¨Œ»á%?]'ôñUÿtÅJÎEÏ+Ó¯¾N1k…>D¼‹Ÿø‰¶I´MñýiEÿæ(!¥P0o&ZÀýÙèò •ÄŽÓ˜³0Zñy}Hú<’'.ÆÜF[‡G¨GÕ`f6æd#èKÈ<õ2 £Ózù
‘-3Èš| Y.zß 8
RÄ»@ Ú&Ñ6Å‘à ü>i&Çê€njÖV#ÚðádBfŒ9sÉU]©xðw¬£éÍ—èóF„~Ô¨0õ|ŠÍG§¸ðÔ>OÕº-bÓWMB6M-ÿù#¶. "ÞÑ6‰¶)îy(ˆöE @ 8i:QB@ Hð@ HðàC2a.¿ŠÂI#E…) 4Ù¤ÍXFn¾õ˜œö-ˆÿ„BGÆ’7¹ó¹Ï¹ý 1‰ZâÄË«Ìó{Ó?˜>ø»`:šCr4y×1á†g)Ÿ^t„A¦!¡`1%‹ÿ´›þÁôŸbâ%·“•’pü_›Iâˆi˜
ò1Ðϱ0g"‰cÏ#³ íØ%‡Õ¡à„ãd‹‹£šàç‘>y))úã¼~>†òˆ:Ak•sPwKšÇ9?þ%eÙIQg öÐ]ù.[^{’ʦ~@?å¯|ç{3‘ºŸá… ?Aw4¹7síon!%²·ÝB½ö ®xì·äú?`Å]wRïãôǸéÖ¹hvÝÅ_ \ƒßr6þú'
¾=‚¿g'MŸüuo¾OŸ˜k€Š)Ÿ hþ` •QU./È–™L»âV&OH’ õb«ZÃç/ÿ‰íÍn$ËY,úÕC”XŸìÅÕ¸Ýï<ΆM
û¯—ô$O¿ƒ ¿}9é¶}ïýº£x7Sÿ¯zdM
igÞ} Ú%¡I,@/눤$ YRhœÉÈcî|Æ
Zs"A_ø¸-½œr.ÅߘAߊ
ܾÀÑÕÏÉ:òrX
N>›Š¸8áêçc(¨qIðѦ:Ü{»›‰$1éjNšEò¯®c]½ºSó4æ\ úÙLm¡~›–Âù³¢/MÌF/ƒ_“Db€‚«¹¯&‹ôÜ ”.ú#Gü„ÿ}ôM\ÃØ!M›¿ˆ²T °‘í»íqÖZ13øWNÍB]ôÔw11nI
o!É2X®]KH+šÏŒoÏ&M¾˜×?éB!ó¨s˜vÉL Ÿ%¼ñ@"nü}n=N¨O„@õCìèÍ&Ò×xDg#ʉ%4Nz?} [çÉR©ÇO?ÁITቸøZêYØ]p,ü½T²ö·K©èÏcÜ-ÿÇÂ)%ÌZz!;~ý"jH–ÌÙèpÈ@áé“16%2©4p4æl pî½z ¹–Š>0Œ½—k¸˜Ä‰W12ùm¶÷ÆšáȘ»€D T¹œw|w•ÓO£,`7k=áh/ÜdAò ˜„íbÃ#K©°'RxÝrŸžÆ¨ù30nxù4üè—ŒÒ G<2ƒ¤‘‡Så—$É<1W݈yð ÚÿÄç+?Ý¿Ò–,XgßJ~ÑH ‰&$ ìÜAϦghièŽÊ¬-cäU?%mà uÆ…Ï’1p»oÓع#zš²ëKÉš~>)y%“¬hd ýNÕö6¤´‹)Yp–$‘þjìm>Ì£&¢ÕÓõÑ#47õ¡ ’i#/¸kT戻–ÞÿKó®FÂÊeμøY2›°†ß±mõ"jô£¦\jt¨vüìpå$ýRÊ®¼SbŠ»†žÏž¥¹ª™ˆZ™5…ä-y€Ì®Ø¶¦2zŸneËî@»áN*+ºPTè0 ¯¸,Xg—‚âb F &Øó)]›^ £Õ>$v,$¿šü ³0›´(¾=Ø+^ iÛ.BJ|mZtç’7e>ÉY™Ñ)yÁnœÛ ¡öó=QÅÃ7ÔÊ|¸²«‘ùxŒ‹8ÔuªbG< ù¤ÏºžÜ²Rtr˜`o2FJs([(jõ|˜:SQcwñŽyÔÖ q²©àk“àlf÷k/3{Ê
X‹Î§Ðò2ÕjÚ}*:ütn¬'kúe”β'ídg} ãó3ÑÉïÍúZ>ÅÉbI"Ѩ=Ìõc7= ðÒøÁ|qömÅ׃W¤"Jç΢áOp Ç!î
¤² ý ×ÿ ëÿýºÜï±Û÷m®½í±ˆ/fÌXN½Ÿ’±az7ý™–> Séåä-¼Ÿ„·î¥©Õ
˜H:å~F—KØ?}’–.˜§PxÆB,ÉF¤f
:gÝMá¨:Öþ »Ýú4 Iaü1œ¾¡x7Q÷j
9…Ô³ï!ç ¢Cî8Œ‘U4¾»•€”‚eü5dŸý}‚¯ÜO‡#¡Z^ÿ!é—Pzæœk~G{oPˆxz5eÉ4ŽŒòiPõOš6¶ „‘ôä¾èsdS1II½´¿ó4ž¢Û( ã¥cÕøFÝFÑiÓÛú ý!Pü
Ø>ý+=n;aÉ‚¹ìj
çü€ˆíNöt!3(þîh#¤F?jÊ¥F‡jmv¸ríµ› ÷Ž§is„1ŒZLþé?Eë¿›ºF‡j[ 5:ŒW\H ¹c1Þ¦þƒ„4XÆ}“¼óî'aå}ìi÷ güŒ²ñAz6>NK·mîùŒ˜ñ#JüwSµ«%n¶Ð +¹òùÓ¡ý=Ú?¬Äëñ#ÒÑ8{:Rqò
U2«(»™»¸ˆO]§*vTÙÂJÊ?¥¨È‰mÓô:´òÏ"/5Ö¶@…-Téùðu¦:_S{¡ªNˆŸM_· ÛvâPÀ*¥‘jQw›l´¢ü5oÓuêÌ¿ ¨ù=žï3ÞŽá ‘yœuut¾u¸ g0æB%]Äh à[OE+îJSì«yÿŸ XrÍéä_ôgn¸°‡öM+ØöÎ?ØÝè8 ¸K™~ËߟTJNvà£aͦh/]« ¦ ÐO:ù‚PÒ‘5]%‚ô‰s1¥ÄÙäMÅ÷Ù=4lkA ÍH©¿%wú,ÚÛÖ4Í$¯<
ÿÖû¨ÿ¼i`$EOàŒ…C@‹Öl ®–Jú½a ŽþXŠxØ= û .¯qWÒ·g;aÀÕ«ÃrÅ2Rs¬t:l(:ÚëúQr¶áí Ä\öÀ^}ðÖý—ÞÖ/ûöæÂÓUSi 2& Oç. ¡*
K
Ñ'Hô‡wá¨ïÚ'~/XKî");©³C•Ìjô£ª\ªt¨¶r;\¹è~“–ŠÑµ–&HÿùSf¢Ûó AS 2 :ŒS\ì}ª§
GËN€³µå²_“3c& o|@Ð4›ü i8?¼“¦šè— :[ ç ŠË§¢«z¼l¡-!÷”éh:ŸgÇ[ïá ß8Ä5˜U”]>¼Ì wq§º.–Ø9”žg“3ÒŒwãý4nÞãh÷’\~‡úE¥ÿÄT? ªÎT󮸵jê„8ÚTðõKð‘ö-ýP×pÊhÍF$dpn¦ªr
}Ýf¼S$Lõò‡•³àŸ²`ÈH~÷[OÐÐ kFh&ûôùÀöå´yŽFâìÃöþ÷yzË$JO¿˜q§-¢`ÖäÌZLÉSW²rýŠ
-)£§
vÅi{q)+?éää?x]OâÜ?Q6zðãc?=oÜNc‡?®o‘å±ckéÚ§óp'ŽV;¹%cÑkײŽÇˆ“Þ=í‡Ð»ç†¿ÓwîõŒ¾f:ž†uت? §¹uÿiG Å׎?&³1®eÄÚ?VXæ¥(a”!ß”$c9Y³–Q0½A"ìõ"ËÐj¹MáøèpØåŠØpµÛatzÍ{„ÕÈ| ƒ~¸:$Ô†½ÅNNÉ8ôÚ¢±#% ™÷8Óæ 29hešÜ Ç’y4‰ðlÜü¥ ÓÑô¯‘T”= Bæã/.âW×
'v”G¶ŒÁ€žŽ^Ž¤ª•Ž¡-Žå»ÔñÕ¶_‚<ÁצO$EèÂæAr(:/Wk@–÷Øj "!d´&= AŽ´SýòïI¢õó ¦k #†ä{î¶*ú=Nú;vиá_ì¬l2ÏQ%ÆñL˜lú©ÿh;1§“‘Õk_7'Ô·•Ê×·RùÆ É½ðI.¿h,%‹¯!ãÓ‡Ø7¦QÉ{w}Û¹¯rÅÙYdOŒqu-'ÿW³ žSU£‹¦‹J€@ïÑZ$* ¦oªE"‚r˜Š8b_CÝËŸb1‡´’ÓÈ]x.yÝ+©}眾kñ˜í«0¼Ö-Þ{@DP")«œEæÂ{É·Tжþa }n0§àW0¬
;•£Q®aèðHË¥(1Ȭ (
NÑ;ê Á[t$IB‰íýéèÛ¿·¨„û£‹ßåxù³½EQ¾"ßØÿUeW-óñq©ë† ;ʤ¡cˆÃVžj[(Çâ]1Ä{ Ü'®í—à¤@Ý”o})/¿œ$@©yƒfg„°«/@ò82e@ÆX8‘D W3Þ°ŒÖ¨® ¦çKl|ã_´8ÃȲ0臺}%ë ºŠþæf^æ1¶í FrèK.c” pHE]ì ¨_.@2b)(@?¨½ˆ‹ÞÆÖèþ9Æ ôF³â¦ý©ñ‚\ö]æŽÿ: Þ¡¶Wãjݳuζj|aÖbJ˜HК‘P\ÄQ‰+Iù™ûtªÉš— ö]øCé¯#@2‰Ù*¶D‹8ñ4¼Mó{÷±í_/â˸€Â1YðWpH°¢9JÆVSö˜ý¿õ1>æWô ¸pE›ƒ%MÂ_ù"íµ;qÛqwÔ |w£ˆz´:yXú9åúò‘‹Ê5MvTž¾Q S#sÄMв5íáj^U:<
¾!§‘”“ Ž*üaˆØwàÅBb†_+Þ!?ŸÓ×/‘Š§·LeÓöÕ|u¾¡¦ìjd>nãâHëºáÆÎlº/V,…¹G´-&[ aý¬ê]±Ä»yÔøOÜÚ/ÁÉÀaFðË™ó£ÌÍ(À(¡m¬}a%ÎÐú&U¶Ë™š6™¾Ë X2Ó‘çÆ7é H¤
€„,Éû@H² $ ó’RÉBîsÐÞ+èôÅþˆÐaËRòÙœóó_’ êÂÖÖA@J#}D @`Ç;t Ó‚ó#>~}£¯Ë˜o.acåÓØB:RÏú)ó¦f ±LŒVn‹Xpçxü®M|ô̳Ñg}ÝQÜølN(;‡œÒ~œÁDtr
=µmDú7вë"ʦÝŨȫØúdŒ¥KȵöÒýÖÆè t×z:Z.¡hæ ŒPVÐçÒ Ï‰¡Ë·$N»š”@%ΞNBa ºìˆà÷ cZ‘âÁÛiƒ ç“[îÄî5£ÓTÓSÓ·¤HQSöxêÄekÙ¥dÙVáê÷#Š£»5 ØÆô×â
-"eÆe¤k*Ê)tµtW·î+û¡ô£¦\Ò±/æ1$x j²°”/&Ûj£{í¦¨<ªláÀY[§,¡hº—ÎVŠ±Œ„ƒ à©Òá‘úÆ 3Î'¢‡=Œ¡ø2òS<ô½·):¥È½‘– ‹(›x c ¯ÑÙÔD0¢GgM'Ô°
{ 7õ ÖÒ¾y;©§]ÏØó
騪Àë
"éRÑÉÕêã]ŠWµ£¢ìjd>îâ"Nu],±£ÆW'ßC‰ü
]mÝ(ú1‹#öŸxÕÏjÞ¥¨w5ò ÚâÜ~ Nâ?ÔG_——¬L#¦¬w3m+ÙüÚóÔu
8‹k º®½• cóIÎÅÛDã‡O°fùNBј¢û?JZi¿Ñ©/ $hãܯ4Maâ`§îãJ†• ¶\ G:©[·ó”©¤E7¬
;ëhÜø< -ÿ ¯r°z6„}Ýߨ»äŠó–2³ì%ÞÞÆP8—¢òä!×e’=6 LbK¸?{šÎ”ëÉ<ý2ž]¡·®ˆâƵþÔú¾Eþ¤ïP¢ƒ°}+íï>GÛàÎ%=k @sêuäÌþ.éR˜`_ÇÀÔ¡ÁÎa²dÅ2é&²ŒÑÌŠ·ÇÖGÙS7œ¹¡A¼[Ÿ¢=í&²O½t¥?*sm[ G=U”=nÙítzíœÅdÏ¿|ÍÀ¨“»»ó€ž´Í F;ûlŠž 'îÝOb«i ²ÈúúQŽ³r)>|íUøK0òœsÜN²õíÐÑæ‰Áaü•Rkº‘‚ò›)™}WÈYM¯Ã? ÆÉ7#‰n"äAñÔÐýÑ£47îæÁµá~v»®$üEŒ,5 BŽ
:ZWC\wíãßý'vzÎ#oÊñ%¾~ ¾”4s~üKʲ“¢£ZÁ º+ßeËkORÙÔ ]•«ŸÂ‡Ÿeœù‹÷6ÞÌ_ŸÜL(i çÜ{?£³’ŽjãëØBÍûæã5ÛðE@?å¯|ç{3‘ºŸá… ?Aw4¹7síon!%²·ÝB½ ¤ñWqê¢ÅŒ.ÍG„ú*i\ÿ ¬Xs8Ûæ$S>;ÐüÁ&ÕɽZ™eËL¦]q+“§N$I„z±Uáó—ÿÄöf7’å,ýê!J,ƒOöâjÜÀîw gæ‚
€SébNYt9¥å#1Ê \MŸ°ãµ?°i[§hH‡Dñn¦þ_õÈšÒμ›ìHv9å\Š¿1ƒ¾¸}¯ü9GŒa£.º…T‹€ˆ» gý»´mùÏÞc‡5èÆýŠ‰§~áöpÝl[SIÄ8ƒâKn%Ŭ 42žmtöO:šûP 9í
Æ_z&®•ß£¡}ð° Ig>NYæ*v¾ú*Þ0€„l™FάKH/ A‚ w=ö ÏÓTQGXþ|²Æ—@ ø&øhSH Hî½ÝÍD’ Șt5 'Í"ùW×±®~ÿSó¼›éö ŽŒ…ñ4D´)¤æ$£|]x²HÉžÁ„«ÿ†Õ{!ÿ^שZLËÜ?pÍ
g`èp8ì`Ê(§dr ½6ÌÂç/¢,ldûn{œ5[ÌÌ þ•Só€P=õDÌdŒ›EÁ¶ÜB’@ÁÕ¼‹@b iEó™ñíÙ¤Éóú']¼sp#@ñtÒ/g‘4â,Nù~)ÚŸ/áã&±á¿àDÜøûÜ {ˆ½c¿R$Mz‹ïg ©]A—>Ì©7S^XHÕëÿÄå šM7ÒüŸ¿á I&ýD I6£3kñnþ
Í~dóR&_CÞ9™D^þNõÝ~Éz6£/]F’g# ¾ˆËE—VN"~Eø³ˆ/@pr%ø{©dío—RџǸ[þ…SJ˜µôBvüúE {¯é¥æ ßcuÝ”–†<çãß-¥Ân$oé
.ŸŸNöÄhU&ø’åLÎ\z"t¼…å+6á +–ä®a
cȘ»€D T¹œw|[39ý4Êò v³æÞkØÚ$4& ’÷ÀQÄ]lxd)öD
¯[ÎâÓÓ5Æ
oⱿÇê§séxíU6" %Ìúù«ÌÉ-`ô”|Ö7Õ´£ørÚÅ”,¸ K’H5ö6 æQчêéúèš›¢ IÉ4‹‘Ü@ŠÕ„Dܵôný_šw5~ɤ„6çrÊÎ;* `÷æÝÑëd Iã¯&Â,Ì&-ŠoöŠhÚ¶‹Ðàst#ɇӯ҇4…ä-y€Ì®Y Ý4Ê–ÝvÃTVtE;Èñx—ze“z}æÅÏ’9˜O5üŽm«w¨óùXž“s#®ÿ>Z
Dœ;èÚøCË®Â7TvÔÓßî‚öíôÝã»ÿ IDATíé`Ì’«)šð;>Ý3dÏb/þ¾=xñÁ!ìjÁcs wÉ—GbR‚ú_J!uÎU$…ÖQûú“Ø}ooßJo¬þ£/%kúù¤ä•`L²¢‘<ôoü9UÛÛPÔø¼dÁ:ûVò‹FbHŒúFعƒžMÏÐÒÐ Û~·´—„väÝL:»ˆžÿ|Ÿ¦ÎÀÞæÐ8ýAÆMì îÿþ@ŸO‰«Ýà8Jð6³ûµ—™=å¬EçShy™Š˜ •Ð˜G’“g"تۣf•¯Œ±ü›ŒÔ}/±úä>ÚRâ´
³äú1Œ›žxiü` ¾8WÖŠ¯¯HE”ÎEÃ[Ÿà(„=ŽC5ý„C_Bdy ƒÄ±éi¶î}pd@iÜ=.Næcš$S1II½´¿ó4ž¢Û( ã¥cÕøFÝFÑiÓÛú ý!Pü
Ø>ý+=n;aÉ‚¹ìj
çü€ˆíNöt ˜!iH(¸’Òoœ…²ýwT:Üc qÆÏ( ¤gãã´t{ÐæžÏˆ?¢Ä7U»ºQБ8ën
Guбö÷Øí ЧaH
ãÆ»µ?–ï2c9õ~JƆéÝôgZú$L¥—“·ð~Þº—¦V7`"é”û].aÿôIZº `žBá ±$‘š]ª°ÃÚ+Ô@Ëë?¤3ýJÏœ€sÍïhï
ÜÛ¾CËsú·Ð¶q¾PIã—’³àv/ÿ‚.gX¥o ³žp¬¥£í
Š‹gbø|ÏÀ´™XÐDGðÇŸŠÞ÷Ͷ¾èÆ‘‘—€ï³7p a(™Æ‘Q>
ªþIÓÆ‚0’Þ‚Ü×£^7’Cî8Œ‘U4¾»•€”‚eü5dŸý}‚¯ÜO‡Cíùáíêø˜þÈD¬£ò;¢õ¨œEʨL”ŽW¾¦ =» Áñ‘àaÛN
X¥4R-ZØ›à§2ñ'Ÿ0qï•[XyÛ
Tï7‹§œü” Tüš·?lQ™œj1äFOäêü û`¾–Nz~ ŠƒÞ={ðǘé&]Äh à[OE+îŠUì«yÿŸ XrÍéä_ôgn¸°‡öM+ØöÎ?ØÝè8 ì¥L¿åoŒO*%'; ðÑ°fS´ƒ°_[žÅè¥3'èx>=¾IkDÖÈ{;&JÐK$f]xºªq*
DÆ$áéÜ…#TEaI!ú‰þá. õ]{ïp÷‚µä.’²S‘:;†èHqìmÏ‹gÃ/¨ßѸ7ɓ̳ɟ†óÃ;iª˜bÖÙ9OP\>]Õ»ø#Z´fø[pµTÒï
uô ¥Ð #ؾœ¶£²uŽÛûßçé-“(=ýbƶˆ‚Y7’3k1%O]ÉÊõCO-)£§íÕUÛ‹KYùIçþºÑ—0ù–§8sR2t¯`å ž Ýw<§÷zçþ‰²Ñƒ«°ûéyãv;†¹f@Qœô¥(a”!ß~$c9Y³–Q0½A"ìõ"ËÐ àÞ972&G‹gã¨ÝѶŸ KÖñ¥4ó gÚ¼ÞíÉA+ƒ?âÁ¹áïô{=£¯™Ž§a ¶êèin=
‹Ý»dk9FìØZºöé$܉£ÕNnÉXôÚ5„¬ã1â¤wOû5Rm¯¯Å׎?³‰>•¾o)i^ù ®Á9øŠÿ}ï¦_ÓÐâCÒ§c.:Ÿü³æ¿?¡¾Ví›ÈAæL3Ø‘TýûÜ¡ãÃ&³Q½©±Wȉ³r;‘³IKù7ž ãèÓÐû7ÓÔ抡NI„@ 8Á|múDR$€.lû}*ýò9øû¨æÓ¿ÜBE_9ó*®úýÝdο…’76P EçQk
È9›¤5F÷+„PáéèòÒÇaÑþ—î#mtŒã™0Ù
ôSÿÑvbN9+ó¾®P¨o+•¯o¥ò?’{á“\~ÑXJ_CƧ±o ³’÷îú6¶s_劳³Èž:ãêZöÎÄЕ0íö¿sÆX#áúgXþ§ÿG³ëxoYx¶>LU.š–+½G²ƒI%r2ËYd.¼—|Kmë ÆÑçÓx
¾q ^ëXG·ÿT2f|‡<ÛïimÝ7D’$$œØÞŽ¾àþIF¸ïºˆ}
u/ŠiÄ ÒJN#wá¹äu¯¤öWpªÞÊQAQ@Ú;
ëKJ —w©N‹Ó¿×"A9Ò×Æb¯¯ŒpÔ>Rl¾1< èÓ’ÁÓJp?ÝzñÛð j~kt>¸Ûk §?Îȉ3ÐÕ¿K` , `VI–\=ñ´D‡!#©e°Ã+E¿¼ét‡ñˆ˜SuU>°ûbý¼ Î^
¡¶wéóßCjÙZ 2KÓÔ¬¢?p,ì.Gug»èK™xùå$JÍ4;‡ÛÊKhL)è†$aW3^€äqd&Ê€Œ±p"‰ ®f¼áÞê·é ȸœSO)D{„-¾ä2F™ ÷‡TÔÅ>éáð2’KAúA
G\ô6¶F÷Ï1f ?° Š›ö7 ¤Æ rÙw™;Þ: !Yý‘3Æ¡õi^yèÏ'@r m@Ãöj\;p¶îÀÙV/0ü¡çpëc|þ̯è=ð«…6Kš„¿òEÚkwâ¶5âî¨;xãëÙJË›?¦¡ÁBöy?¥ ?io²±ïÀ‹…Ä
þ¾V¼C~>çSª"N<
oÓüÞ}lû׋ø2. pL–úÄ%â&èÙš7°}ì¡®=ÂwíËH¢ ´fänŽ8*ñb%)?sßs5YXó’Á¾ "ýuH&1;ùÈ¿XìñAVw„GP ásbòXkDË)dçjð×oÆD«å%$IŠv„ÀßCÆ4Ë>{Éɘ’õàï&ü»±u*ÊÏ%I/ Ýê Ÿ?RVk¯@U=$”œGjÉ"R
{è¬lÜûÿ1ÙýòÁWÁaFðË™ó£ÌÍ(À(¡m¬}a%ûç÷©Œ¾æ1’=ûþQñ|ÆÇO=E÷çœvÏ¿˜&%“œ‘‚ „w/§É!äy“*ÛåLM›Ì‚ße†
,™éÈ€sã›ô Ò³’ÿ®\•S|ýëÜzi3ÎH:)ÃkQÉ=c:À»uØ.j=¼ÌRòÙœóó_’ êÂÖÖA@J#}D @`Ç;t Óm–ó#>~}£¯Ë˜o.acåÓØ4ã˜rFA´ÁI˜ÁœÛþ²ïëþúgÚ¿Î;e†:qÙÁZv)Y¶U¸úýH†âè®3½¾Û¿@Q~Á¨…?"ôÆohëò¢¸7Ò²ceïcŒá5:›šFôè¬é„VaïF§]MJ gO'¡°]v Dð{b0‚âÀY[§,¡hº—ÎVŠ±Œ†VÆé]C:>›ÊÎ!§´ g0\COm‘þ
´ìºˆ²iw1*ò*¶>cér½t¿µ‘€¸ÖÓÑr E3ï`„²‚>—}î|L@à(Ù+Ò_‹7´ˆ”—‘®© (§`ÐÕÒ]ÝSR}¤ÏQçêÑXGbÎ
‘:™Ìéçav½Gõö=ÈbDŸRˆ1¸¿
ýö}óÐ5‰9¬VdC‰%—Ÿ¦ý6‚
(Þ
zÚCŒ˜~ y¾awJèG.&7%„ëãè s¶õ+ȸäF/J uë'¸Ý2ædcüãT•ÏÇÉŸUÛ+ˆ·òMÜ–Q4"{ §wÈD1ÙýPòˆ›¢…çBĉ{÷“ØjZc[¬}¨ç¨z€
ßP5èìÂïô“:í‡ŒÏ œµO³kˇ¸¿°íi>p€î¶RóÂC8"n …”™?cų̈mƒ}Uô¬ý%»ÖQDzèyÿA4§^EÖé÷’-ƒâm¤oóƒì© \T«éYNÕŠ>ògžOÎü¹h ÅßEcõS†Ž> 7Vo/ŵŽÖÚË( í¥ë³ÏÙƒªXì~(yD¢!Ž=ÒpPNÔâ§=ÆM·ÍEëü7/ýð×´‰s¢‚áE“å\Ê/¿‚àê[©nè
à8Aûµ*”BÁ¼™h÷gÿ¡K$÷J ˜Æœ…9ЊÏëCÒç‘@ àdA*@ D‚/@ D‚/œdh²I›±ŒÜ|+â|H&Ìã–2bòÈã·ò6HðWtd,y“;ŸûœÛ°“h©OÔŒMÞuL¸áYʧ «É#}òRRôGGfm&‰#¦a6 ï)’y coúÓLGó•š3‘Ä1 ÉÈO‹Oò|„úQoS@ N º‹Ž¶ø'Üø“Ë0¹ßàå»~F« Ê~ÍÍ÷œÞµœ—~ð+ÚOˆ2ŸÆ…?F‰ ”êŸòÔïVÒ?¸lWÎgê/Þ`^>´?u6/· °¢×Hî·ÞâŠÓ“¿D<;; 8wk¼±—,¡˜òÙ¹@€æ6áQµ”X¥<{Æ°ðággþâ7ó×'7²œÅ¢_=D‰eð¼¸7°ûÇÙ°©!z JÒ9\ñØoÉõÀŠ»î¤Þ
ÆéqÓsÑ캋¿<¸ß×ÞE%4‰èe ‘”ädD5~2Ë)çRüô¨Àí‹ýX6Å»™úÕ#kRH;ón²O¶Š#Ô@ _›?–DF_|#º¤Ñ—Ph}‹J»ÚmóÂøö¬¥±2=–1“I–!Òµ•– ?„»ét‡‡W°üE”¥lßm?jòx7Óí‰ì½ßÓÐíÄh,$Y \Í»$–V4ŸßžMš|1¯Ò…lÎÅ ŸÍ„Ñê·i)œ?+j”Älô2ø¾ö;FT?ÄŽÞl"}„…Ì1ŠâÆßçÙC@ì +HðO"9§Í&êvè( ?™ ãÒص®[åÞ›zßÿ)Ëßä &ßÿgBÏ;÷ðïÿv Áþ2æ. U.§ÅöI*åÙûå¾—š|Õu¾ƒt}ÙņG–RaO¤ðºå,>=Qóg`Üð&s6z 2PxúdŒM‰L*M 9ƒ _ã_2ÏcÌU7²÷CIûŸø|å§û%ÌrÚÅ”,¸ K’H5ö6 æQчêéúèš›úT\£ È’Æ_Mþ„Y˜MZß ì/дm¡Aã'ä“>ëzrËJÑÉa‚½mÈ@ ™$Ó,F^p)Vq×Ò»õiÞÕHX´eŒ¼ê§¤
øZæÅÏ’9˜³7üŽm«wDŸ©FæÃaœCÙÕ· ßùSv|Ò@ÔåLX<ÁèŒ÷©|ùŸxÔöRt#ɇÓ?D œ™pý÷Ñj âÜA×Ƨhm ø§)$oÉdv=À¶5•QytÓ([vÚ
wRYÑ…¢V?j8ŒM ä)ËÈ7£^!Ô·…®M§}
–ÿRóßÙöúѯs{늙”]s3¡wn£®M‡uöäĵ{عƒžMÏÐÒÐ-ö+Áq’àÇ1nœz—óÙۉ䎿„œ9Ó0®G唘£„~ 㦧^?Ø‚ï¸h9ÄCÙº,#²> ~:7Ö“5ý2JgYÈ“v²³¾„ñù™è¾æK ï&ê^A#§zö=ä ¬`*&)©—öwžÆStÅc¼t¬z ߨÛ(:íbz[ŸÃ«âšþÄ?£l|žÓÒíA›{>#füˆÿÝTíêF‘¬¤œñSŠŠœØ6=A¯C‹!ÿ,òRc“@ñ7`ûô¯ô¸í„% 沫)œó"¶;ÙÓ€P-¯ÿÎôK(=sÎ5¿£½78po÷@òªBf5ŠöíÂÖ
EÑmlˆ~5Òæ`ÍÔnû ¿êLYG⬻) ÕAÇÚßc·{@Ÿ†!)Œ?x€$ý[hÛ¸ _(‰¤ñKÉYp;—A—SåËTéGM/òð63–Sï§dl˜ÞM¦¥OÂTz9y ï'á{ij
rº 5 A,èÍ‚Î>}Z\ô{C Y0äŽÃYEã»[ H)XÆ_CöÙß'øÊýt8Ä'@ ‹ß¼ˆËŸ\ôåÍùÈ )2‚ÛÇt5h \BñèEä'¾Kµë«ËªŠ.b´ð§¢Æuß”ÊÄŸ|ÂĽßÂÊÛn Ú=ôšR¦ßò7Æ'•’“øhX³ ¯:£-à¯y›®Sïdþå@Íïiõ|Ÿñ†t ZÀâ:—¤5"kz)J%è%‹[D<ì ý™û¸ðtUãTˆŒIÂÓ¹ G¨ŠÂ’Bô ^׸õ³ÉŸ†óÃ;iªÑïlœ'(.ŸŠ®ê]æÙäŒ4ãÝx?Û;P G»—äò;ö’Z™Ã]8ê»öþÕÝ Ö’»HÊNEêì@!@ÐÑFX×Bˆ³
oßþsÌ%óáeö«ù¤8pV×ÁÜSHNZI‡#Œ”8‹)HÞ¦iÑšMàoÁÕRI¿7 ÔÑP“mÁV¿•0àê3‘|ÅRÒr,t9ûT¾ëðúQ壉‡·©”8›¼±©ø>»‡†m-ÑkZ›‘RKîôY´·ý—`Ÿ Æd¡•%ŠngÂ<#Í/ý”nc6Zzñz‡hÑ]IßžíѲ÷ê°\±ŒÔ +›ÅÁ1Hð±Óµ«
Ÿ’y #¬CþÏHÆìSСe[ ŸžÆv( 1…1#©ÞîúŠŠd&ûôùÀöå´ åO ûÍÁ÷ï¤?üE§Œž6ðçm/.eå'DÑšHÈàÜLU ä@ûºÍx§H ™0êepŸ¨stô$Îýe£'«ôÓóÆí4v Å ‹¢089JQÂ(Û¿æK®‘¬ã1J hæ=δyÜãÉA+CÈ2vz:z8“ŒådÍZBFÁô‰°×‹,C@«þ£š™U%ø„ 6Æ5çH‘Açö.²¦aˆÔÐÖ鎡T œþNß¹×3úšéxÖa«þ€žæÖè´£/3›¯ f3}Ç4É•UØT¶–cÄŽ¥kß5áN vrKÆ¢×®Áíj#”‹^g!aô(@Kj^2½\´¾–/~Á8 ì&³Q´F@ 8F ¾ûcþûè»è þŸ®˜² ÑÝfòÿç}îüŸ}‰þÌR¶Fð«(‘q<&[~ê?Ú~”À¿|þ>*yï®oc;÷U®8;‹ì©“1®®%¨ÈhMz@ƒ i§úåß“0*Dëç=$L× F :
p¢&ø<[ ¦ªFM§• Þaîr¢:ã‹ D"úF’$$œØÞŽ¾ý=W ÷D¤#”YÎ"sá½ä[*h[ÿ0Ž>7˜ÆSð+Hˆ¥“ BfÕ*ön¥«9@ñ˜S0ì\¡xJ׳¸bœß±¯¡îåO1˜CZÉiä.<—¼î•Ô¾ó
Î/]1 FQ¢W%ú÷©lGµ6=ôŠ«–€RŽ1uÆ´f:¶kÈ(Š©=ú?&þ²G(ˆa{@ Ûÿh²æ12 ‹Ž]
†ŒòÊÏ$U÷_Á”R}ÉeŒ2ë?>´¬¸iãAjæ<Ìè²ï2wü{¼½Ý‹Ö¨&r˜þ/±q'@"Ų0èOäÍûÂöj\öx<+H8 $XÑH|éhp¸õ1>f ‡&¶k"ö x™Eb†}ãA»U’c'^fa)ÌEîl¤~Ô¼J…M÷^3í.FE^ÅÖ'c,]B®µ—î·6P€p'.‡–ô™ØßÛF _¦«{£ò$œŸvQ,‚ã>Á—RÈ^€cw
ƒ»ßEìÛiwAzÒHŠG§²yH‚¯ÉžJáÐSvBA¶ÄûHMÓ&N0vê>®äX {c,šA!_,W÷® a_÷7ê.y„â¼¥Ì,{
“.ªNíС=Yf ÁC~Q‚x·>E{ÚMdŸz;éJ?ž]¡·¶-Ž³<¸6ÜÏnו俈‘¥ BÈQAGëj ½fýÏ©q_KÞ¸e”LÔ aBÎ*z >Õ2G"ítzíœÅdÏ¿|Môú°»»ó€çø·ÑüÑj´³Ï¦há¹qâÞý$¶šV"Š™ àþìi:S®'óô;ÈT\QyêÚö-|Ž´Ó³y9ߘ uoáðƨ])Y²b™tYÆè·ÅÛŒcë£ì©‹eÝBå£Ôšn¤ üfJ&EõrVÓëðÇ •v?¬MݸÖÿ‚Zß·ÈŸô Jt¶o¥ýÝçhkuöð¶wƒu'.P$ Û7γ×#BX lj“f¨„qÚcÜtÛ\´ÎóÒM›_X ˆ)Š’/¤ü²ù8^ÿ-=âdX@ ND´'MI¤
æÍD ¸?û]"¹Ô¡ËÆœl} ™§^FBÃctÚDr/Hð¿êü>i&Çê€njÖV#ŽŒÔ!§žOñ¢ùèžÚç©Z·ex‹k@ y1b“6@ à¤AlÓ"@ ˆ_ @ ˆ_ ‡dÂ{^~„òÃnuúñÞ.5çqNü ·üäjbÝoòòÝ?¥Å1ùÿÍ÷^†Áõþöƒ_ÒT kX IDAT*E 篊w'u¯Õ¡Ñ&’¼ô‡dˆ˜Dc1S¯üI# !w#κM´îþ¿?˜Mç3óÆÛˆm]OÅ;Ûð‡ ŒÄ/}œ|Ë_)ÛðQxg"]:‰ÅkÉÎŸÑ ìÀÛ¾¶^ÄÞ+åcP“x Ó.žO÷¸ûÄV¬@0ξ–¸’_pýí—G¸ÀutøÐ'ç1eÞ >}õˆ/ämØI§gàŽŒ§¾{Ѐ@Â0íJ&úÿ›¾ŠÜ„·©êé?^k!Þ à:¼ \ É“/dþ¿/$Ys>ï ]"IýŽ·ó0¡ I=ëVœµ€ ¿üŸÖ¹
“±Ž‹—¿Í‹oÕ ÿ
yÝ4ÎùÑÓœ›
;誳2O$uÖâ”Éjõ3J»Æ]Ï_ABn|ÝnÐxð‹½Q§ IÁbÄûÅC4¶)èSŠI›w+…¹¹ Üð.ß L–u=99»©kr
s&=±Å÷2mtï|’¦6Š)›ø ~HÄ @ Nm/Å¥ë.%Žÿ¿¿¾OИ±$kpˆpö¾CÏÿ'[kûNð} ™ç/$†vj+õL+šËìYÉìÿ´sHqºŸí¿¿‰Šž8r¿õ®¹ ™©ÎÇ´ý-¼GŽ©â“ÿ¹‰ŠÞlf}çEVœÇ‚›® ò¿_bP‰OêU÷Pðùw©RýjRÎ'?à ïÿøFövÉ€„6Ö‚äõ«×Šv©9–hêùÌtQýÄKÈ>ûB&¤§…õèÄYö{jö4¡º,ÒXˆ/ºœÙ 0ÇêPúšè©ø+eû <)Š]À”¯¯#1! ¹k°ïý3‡÷7 ø‰aé%—‘˜‡)>ÀCoéÏ8XÞöWýÒ%cj z ø Ø?¡þ?áô© n*d!aáíäLž‚1.|Œì¬¤kÇ i®ï Óbòoø†}÷Sùy}¿¾bIXþÓSߣêåðÈѳ…* ªµiæ-̾ù{è´rVÒQºž–†AO
UØ”˜ RÜLVþ ô™€½
0–{Dz£ŽÞ6´•ÓÝÔNÁê˜<û#*w5…eRxÛ}$ž{æÖp-v5 Äe§BÛc4îÝÑÿ®ŽC¸Æ Œ?T£ŸÑ|U›Köê_‘Öñ+ÊÞ¯
ÛF_LþÚï£Û~U ên èò™rýý$÷ßìH»êYÒÆõ¿¦lkexJO”bG D|Y©ð:¦ÇßyocÑÙ§ÆÙy
¤0ÍbÖ,3ØÿÁïÄ‘U´ŠÌÅŘ>{Ï°9]Fö ¥Ñ ¿X.p˜¯¿Ì³ב0ù2r-/³à» î .XUBíëÇþLéë« Òdfœ·€ú·?ÇáW=ŽÈõ3b»¾=ŸqhÑçÝAá…%ж…¶mUx=>$c
Z§]}q‘¸ù?%¿(@Wéã4wzÐe]Ƥù÷çû!÷‡‹aÅWm×Ót¹{% æüÈ]üB¶»h²öîbg‘ZX _ ±´™€_F2XÐtwõ:zâüÜ©í´òzz<`HÆ/ã‹ðíQ£Ê#1fÍÂÚLæ½ø¥D,E7’±ì{^y€vGúöcë„Éç /§/è2IHÓ#·îÁ'G×£ë0›öt}Áxâ‹n"sùø_þ9 NYM¥¿v?“';±íx»C‡1ç"²“NÞ3Ç'´·®aÚ´s0îiê¿ÁÀ[ùÜçÝNnÁT:ýQ¨¯½¦,%)©œûØâ£û¡Ÿž¯ŽJ°žæ
?š²ŠKgã|ÿ×´Ùý>ÓÙ?_ 傽?snvø
Xí¥Ø}ѸLs~ò9sŽü¿›w¬£Ú=pé
&›ÀWö1
FZý«˜6ýrrâ6QíœØgPòÿ£(~™ñ@ õïïäÃ
lûp( %“dÔÔæçÙÖu3÷æníØŽ»g+ï½°œÕ7^@ΕO²îŠ.Úv¼AÙ»Ïs ÁA(ýŒÜ®õl¾œkŸºü¤ô<ÞH:mÿ£ %„ðŠ¤ŸÖ呵¨õ9*ßÞ‚oŒ³$óBrf'ãÜv‡ú§,Y›!ó ¦ÎCpSøÜrŽºŽ#¿sÛ!!ïnâ3’¬íƒîTúñÖ~€½¥oØÒ™cÁ׌«¹Š^¯ ÔÒ;ÁÕÊ㮢»© pÙõXÖ¬%)3«Ã†¢8pV×Ây‹˜¿‘v‡Œ7 Kl€Þú&õ‹‘ÕÚb4™#±©k7¶º½ávuÇ2aÍM$gZèpv«²©ß¼Ì)f¼¥ÐP Ö—£ÍË„ÂïGaw>|¶ HÏ&FÑ'ˆŠ¯ŠÖ/ê(*YE|õsCîn{q}ö‡cî ÷ê'Ikü€Ž}›éjé`l®}b?TçóQôU² Èú^‚x»ý§.v@øÃÝžŠþÝ’cæ†ûöqt=™‰Ô…‹0¢¹¬Ÿ†6˜6él
¦ÄQ]î:FÜÄéÅ·„h}é&6~n
O
¶²;úé1-
uSÿÚ h+¾‡ù«
šÞî¸mï}gvŸÅŒ ®bÖù—3qÁ-d.¸†¼õ×±ñ3»JýŒÖ._„zî¡cÿAúÌLœ”¡žÇqç=Bþô•¿½t½y'
íêGŒ’y:qFð”î sq %a’bÐ.yœâ%C¾ôd¢Ó€/’©ô«I8 ƒQBözÑhÀ¯‹¤ ôàÜþº/¹™é7–à©ÿ[õ‡t n4EE¥ÜcGékÄX³i â&и×âÛHž”Šµ¼ƒ˜ôbŒ¡C´ZÝQ·Åh2Õ¦í2šÍHt«²iÐR€‘ ºÚíã¸%„ÿÐKtͽìïÒr\[‹uËÝt%‘µ/ï"vÒb’óÎ'kÅ%dwn¤æÝWpª-âÆ,ÂÐjVñî¥ã°Ÿi‹0îÛŠqÚ$”Žgqõ)ѵ…*™ÇjSE9:fWcS©è/’
ï’'€§…ÀP“ëißSGѼ•˜mÃdG9 ÛËéÜ·„¼knajñn*>%Z%¾*ŸWå«JXï'š
íáQ4bG Ã-•
á=ø6m
x
K–ÍÂ0Ù%=¦DsT½6} S&„‹ðöý¥4U•r¸1<ßÝX¸”$ýÐ:ÃMÛ›rÈ šüÿ༢¼°Æ0ƒ9×^K< z“ÃÎ!ƒâ¡íí?pxèB8É„eâD š ¹°7´„÷Ï1¥bÔégôv¯žÇ ¹§WK%ΖJœÕôù#œƒî©ÁݱùÅGíqƒeB!@gF#
-*ñb!.U‹¯»ï ¿>§#\Té2±$Køª^¢f n[îöÚ±ï
r⩇Ã[î£ìµ—èKý:¹éêmMyŽ²O$,%5{6ÉéÐ{ œH¦5«²…
™#²éˆ…àè6
9öá%KnVÔ_˜%Y‘‘¥ÅW·s˜u 2þÚW±Iç’‘eY¯½•8z &9-ª2ªòy5¾rð&!ÝIÄàÑkõ€N¯9u±#‚á§è„loòþ?Wqý•d~žÛ¿ÞN·#€>q"f÷ó¼ðㇱê´Ó.«uâ_ðñúõ ‰›Äô c‚'4ä˜?á/¼€@9ø{Þx(¼¨V“v7þæ.R1)IGÇY Šó#>Þ°ŸékfRðÍÕ”V=ƒýÈ·…,¾ç
ÎKˆIËøä¯q†Žo¬Ò½…O¶ÝÁu¥ í¸–±òg¿ 'ص ¿”Lʤlb å»túÕèçQ|*ÚeµŽ®g[Dæ<‘ž×Óq&n9 ¨¡mg9IçßÌÌKsi?X×@Ò'¡×TÓUÓz´PQÜôÙœ¿’̽8qè5‡ÂǸKi®¼œü9÷Q`| kc#}B
ÁúÍôôÊ´âê„üonÛŒ«×‡dœÞÉ#"LÄß@¢¿
g—• ¬GŸ‘G !|ž´DMžþ˜îxk÷Rr–| 8@]³#ú¶P#s$6 ©–TaS¥w;Íû¯$î½äi^¡£µÅP@ ŒiÊŽ6a
æô 1IsI+¹³k Õå'ØÉ)pkE © rÝNI"qÁ7ˆuTà²w!+±sV’•ÞQ}9›ý¨òUų¦fr‰k‹
Å”?¼GŠÁ?ìÁ¼œÄùW“¢ IĨ¯¡³º…P´bG 'šƒïźážï¸Å+/aÒÄ M ;kiÜ[‹<ä™·6c ¹ƒßn °[ ƒ{>Óäùä2ä]")%y 8 b`´PO9m.H‰ŸÂ´éI|Qy\õCϧÿGíªß3-û&ÎÉÿï6uÓÝá%=ÍDlúD÷aZ+6²óõç¨í8QçàźéYÚ—Þsäå,RÈJí§;1Ÿ=äÉáÜdg-
¥ÏñÑ?>ì_Ð;Š~4Id©h×ÎöŽˆô¬ª¼ NÏÚ3Õ=e| aŸçR²Ï^BÖ’eỜA;îêg±×¶Z´ëÇýÅ3Xo&í‚¸ðìÿßþc<¸¶?À×uä]É”F DÐQA{ËV@†P › E·ø2.¼œðÞÈîzœLy’bÐH XÎú6馘þp:Œcï£4ÕF0„U:›?Ë,óñ¿÷—ÞÊÓOU’~Ë»|s±…Ö§/âoÛûß5+%Qð_ïqiž“ª_¯dkà?G¹Ö“è®û'×.I&tà'¬ð-Ü
`ZÀ¥¿}Š‚Ø öýæëlj9Ÿ5ýY¾yãsƒ©ä1¾}ûyh÷ßÍÿ>ø>}Âu¿r(ÞÔ½V‡F›HòÒ ’ñkŸ&ñ¦]<Ÿî7*p÷}‰Û[‹™zåwH²¹qÖm¢u÷ÇxüýëôMç3óÆÛˆm]OÅ;Ûð‡ ŒÄ/}œ|Ë_)ÛðQx ]:‰ÅkÉÎŸÑ ìÀÛ¾¶^ÄÞ+ §üëøq1hô„'œOYÔÉ3®9ÊtS–_…Ùº†íø#:s ¾/)oDIžÓ&Ï TØât‹Ó ü#d¬ãâåoóâ[u#ŽP¼
;éô !ã©ïFAAö‡G°Š<ØÙC(
€ ¤âZ Ú7¿ˆmÉœÿM¦&¾C…]Á˜ÿM¦Å]o°§Ö69 #€a!³§[¨+Ó‘{á‚pã20h@ Œ¿‚„ÜøºÝ ñà
uœ²®^ÁbÄûÅC4¶)èSŠI›w+…¹¹ Üð®Aot•²®''g7uM®aΤ'¶ø^¦ÍîOÒÔfC1eŸaÁï*ø—Nfø«K¥=ƒPwÃiðòt“4qyµNì»6`³ú…<c.ðÔ«î¡àóïRuÂÍ4í zþ?ÙZÛw\G.û€B(8¨ãV”€_@˜Ñ¯%·o ´ò6.-šÃ¼E¹T½íbòòó‰!Dë[¯Ð 9 ä^0Sc g͈A‚ÖœQ Q?œèÐO¼„ì³/dBzZ€@'βßS³§Iý£1…ø¢È™½ s¬¥¯‰žŠ¿ÒX¶Ÿ`¿¿I± ˜òõu$&Ä"!w
ö½æðþäŸ4Ì ½ä2³ó0Å' Õ„¡½¥?ã`ykxÏYýÒ%cj z ø Ø?¡þ?áô©Ü•V—Ï”ëï'Ùþ7íªgIH/õ¿¦lkåÑÄ’y ³oþ :-„œ•t”®§¥Ávtÿ[mW‹ì¨£·Ímåt7µS°ú&ÏþˆÊ]Máë)¼í>Ͻsë ¸‡º4 Äe§BÛc4îÝAøëC¸No¨²©Z '=*³d!aáíäLž‚1.|Œì¬¤kÇ i®ï<*OL) n&+zLÀÞŠˆ¨ Ñæ’½úW¤uüŠ²÷«ÂºÐ“¿öûè¶ßEUE‡zŸW£ŸhÄŽZýŒ(Ëò?0ÃüÊ6|xì»# çãß½ƒÚ–¾¨øª¢vª¡šü3š?«°)jäQ›£NA>L½âYRû¿êÛñö•µ‡Û®IfÂÙkÉž5“A!ؽ›Ž ¡iPœªÒaäQ;jt¨6Õ´+j}Šœ9š-ÔÄiTbY¥Ì*lR§Ñh{bgä?h#¨;‡ V•Pûz¤¯BÐëBÈ!
±«™=]¢õ£ÍÈ!%\àûCG ü‘®¥Ø¨Ýðz‹Ö¼b-9ûj))Œ×>-m'è Ièña-#½äjf,°-íc_] E9ièÅ*Ä3-ú¼;(¼°Ú¶Ð¶
¯Ç‡dLAë´G0ïÍHÜüŸ’_ «ôqš;=è².cÒü{ÈóýƒûÃ¥øê±ízš.w²dÁœ¹‹@ÈvMýwg¤ØY¤ÃÁh,m&à—‘ 4Ý]ýA©'nÁÉÚNû'¿¡§Ç†dŒñrx@«–`=Í~„5e3–ÎÆùþ¯i³÷?óu ›PzwÓZºƒ¾`<ñE7‘¹üNü/ÿœ§¬ºícAq|B{ë¦M;ãž&¼ ðVþ÷y·“[°…•Î!7?zñÚ{aÊR’’Êé°÷RßݦøØ8éyT™%#ƬY˜B›iØ´¿”ˆ¥èF2–}À+Ðî‚”@â×îgòd'¶ O`wè0æ\DvÒ©ˆS5>¯F?QŠ 5úUž ‚N$¥ Ó@ ³–€³ÅŒ½Þ`ô|Õ»ƒÚW¡Õ$’´ì^2O8ø-ÿD'g*jäQ•£Nu>TyÚnÆrîäÍ”±ïx’æn‰Ø×’½âbÞþ1-n•:Œ–6^zVë‡î*º›ÊÃòØõXÖ¬%)3«Ãq ÉœbÆ[ú
åáß8Ú¼L(üþ)ØYatŸW§ŸhÅŽ
ýŒ*ÏfÝ=PŽN#3ùNf/1qøo÷ÓiÊ@‡ ¯WŽž¯†<ø{< ñŽžN˜¢”3ÕÉ£&G_>”â’=3‰¾/¬9ìó-‡‘’þ‡¬’´µ¾_Q“㜟Çå<£·+j9J…©²…Š8U¢Ë›ðiÔÄ…
[¨ˆ‹èµý¤cGÖv`øû:¡nê_ûmÅ÷0Õ¢# øPŽ™ƒïÛGx\ˆ€ËÈ(q%N%iç–`ôÊG |µ×
Y9øâ3”ü÷wII6@û3|ðYkQ Ag6!¡çN6CæDhût'Þ³%b14àstÆqç=Bþô\/]oÞIC»úQ–džNœ<¥;O¢)¡“ƒvÉã/ò¥'|!L…¤/XMêÄIŒ²×‹F~]$%‘çö¿Ð}ÉÍL¿±Oý§Øª?¤ëpË )!§¥¯
_Œf3ÝªÛ ]Bø½D×ÜûÈžñ.-ÇåÑZ¬[î¦+¡ˆä™ËI[ù;²;7P³ùï¸T.”Që£Ùt¬>v*õ<? 'Ölêb]€‘ ºÚíãðªòÑ}^~N]ì ÕÏèò(x]c²0è-ÄLŸ
èHÊž€ÝŸ…®¯Yõ]´hå±ÓíZ§[>Ô$b¢[sÇQŸ—8ZzÈÊ›‰A÷>þ ÿ²D+G©ñ1U¶GÓèÄ2øÇ1.¢×ö“Ž ‡h>aÈÿdÛ{ßbͲ¯
ž.?ˆÍÁWÝ=ÃôËÉPv³í¥>Î[s9Ù€¿Ÿ ٵ䶲§á»,Ÿ ] l ëÈ0Hƒ.Ö hÑ„Ú¨~ù7ÄL
Ò²§‹˜-`¨עÀ ?üxö>ÌÁCúð*sÅß é ¥^÷Éõ’$!áÄöÞƒ´ÙºL‘{Ës5é¤ø19–
Z?{G·b‹˜xñšøýåmÏûÔ¾¼‹ØI‹IÎ;Ÿ¬—ݹ‘šw_ÁyÊWzË(
HRm 3F ÉÀÓB`h³‚õ´ï©£hÞJ̶ᲣœŽíåtî[BÞ5·0µx7ŸÖªŒR¾¡Ê¦cõ±S¤ç1û¡Â±•|ŽÈw¥q¸Íˆ»EŒæójõsêbçXý¨‘GqÕàW
1%…)ù0íåZRgÌ#¶- z? ¶“>é<¦DÁ^£^KM£#ÏxçÃÓiO“ô<ç‰^_ ÖŸ¥“ŽÓhÅr´j õq¶Ÿdì4k€}#_ÓCÛÛàð
· ±d.ž…²ÿeìx•&¹‚Izèëæ¸M3F»–"êÿüc
:“!Ü¡idz÷ýÒ7_£Ù)£ÑH€1¼ Ÿ`\“›ÜS«¥gK%ÎÖjúü‘—â©ÁݱùÅF[C1à:3ihTâÅB\ª_w ÞA}NG¸ ÔebI–ðU½D[Í>ܶÜíµc/€CN<õïpxË}”½ö}©_'· =ò°õ€nŒ‹HTµ}¬ †eYZ|u;¬ƒŒ¿öUlÒ¹dd™F6]o%Ž ˆINSý")U¾¡Â¦ùØxè9J~rìÃK–ܬ“{9WÈMÀš„ltš±û|Dú‰V윤½”¾f<þ,3/%¶{3 U[ñ&® mrNõw #ó± ² Ä$ CƒU]+›ª‘GMŽ›:ªð’@|NÚÑójÓIÈž =ûñ÷.kÅÎ:ŒÈ^§>G©ñ±ñ´…ªXŽ$Uõ¹'Ž‹¨·}ì±³O|\7¢A»·ðɶ;¸î¢Ôa¾Mbú1Áä _ðñúõtõ¶Ð˜u>ê?ܧW¡|Ÿ—©óLàn öQÉÈ×:ñhIg2IsÌç’FÄ£«lÏ85´í,'éü›™yi.í+ðzHú$ôšjºjZ&%ÅMŸÍ ù+ɜы3‡^s(|Œ»”æÊËÉŸs Æ×±66Ð'¤¬ßLO¯ A+® HÈÿé¶Í¸z}HÆiá•ëa"®øýU8»¬e=úŒ{ YK–…ïFí¸«ŸÅ^Û:hÑ® ÷Ï`M¼™´ ¾Ošâ³ÿûñàÚþ \בSt%SfAGí-[Bmtl~Ýâkȸð>r´ý£tw=ÎbI1h¤,g}›tSxR…â=Œcï£4ÕŽa>´¯ŒÃ mE·p“W\!'îOa;Ô¢²ÀPÑv5ITvásúH*þ3‹!äiÂYó ûwoÃ}Âíºdúª_§§øN& "€lÆ2g ñÛ@ÖáØõ Mj·¨Sëªlªâ<ã¨ç¨ù! \ŸýŒCî#{ÖZòæh™ ó vG_d1Xõ(5±·0±ðVòÎ
ËtVcwø"ðyú‰v윬½”^¼m°k‹ GùNäìI8ížS”Çx÷®§-ùÛdœ{')Jo8Õ´ªÜ @͵TØ”ä1G§Mݸ>û95}ÿœ³¾Kž äž½´múý;èŒ{ÿ¥VÏ#é0"{CŽRåcãi 5íŠ G´…š¸ˆRÛO> n¨z?Î¥@ @pÆò1pÁÀ¼•?
}@ g4„cgíÎz@ Î8Ê€¹À1,ü\èE @ 8#9RËk}x ÈJ„~@ ‚3†§ßü3ÜÖ2bÁ@ @pfð1pÁà†Û þ›„çð@ ‚Ó—²þÚÑ
üv`eÿh@ @ œ~|Ü_³·«)ðŠü Ïç@ §O÷×êíÃ}© åÇr "x±¬@ @ ˆ6eÀw´ v8¤N¸X‡X€+@ Œ' ~‰Õsj–ÆpÀ
`0 È’„Þ@ ‚“Æ4û€ÏM@u$'øÿ
ZÀ;¿»ÇX IEND®B`‚ stem-1.6.0/docs/_static/prompt/run_events_pipe.png 0000664 0001750 0001750 00000052111 13124757507 023035 0 ustar atagar atagar 0000000 0000000 ‰PNG
IHDR Õ ª bX³V sRGB ®Î é bKGD ÿ ÿ ÿ ½§“ pHYs šœ tIMEá 1.“â IDATxÚìÝwX•åÿð÷Yì) "ÊroT”-”ÈUÎT _•œ©mµ2KûŠ+KK3‹¬Ì‘»Lsdr.P²\$2”!ÊÞç¼0eœƒø«ßçu]ïëªó<çyîû9püœ›û<·úë /€^ š p€B!„ÿ.) ¢ ° À
¶ ~¯îIŠj¶õà ÀÀd õå !„BˆÿgòðAI¡wQý9€) ²˜ËµB!„ ð€©5ÕV ~à'×K!„BˆJ… £ª¢ú¨ÔB!„BèUX÷,ý e¹
ŸKA-„ÿRÆÍ🅫0¯·#Tr5„¢.ø•ÔÏŠê¾(žCýX(Ì=Ð}À@x;È[¹\ÃÇE&¯G<]äÉkúxµ™‡«ÌÂÏÚVøsßßõ{ZU{*0iæÌÀóm,*Œ¦!„x$SJêè²÷ÖP É¥[›NÂÖÈ‹8 ù;~z½}Ù³ŽüÉ7>ƒŸÂ ³™´y
Û~\ƒ1îFrékI®aMˆÂœ …È+äÛM›bø‡pù®$ÁÜD\:ø F¸jÊ
8·—"‹·=ôÍ=aÀzÀaè*ÙN,:ˆgõ8Ž¢ íËo¯†·ie…QµƒBö(ŒC‰¼Ã/ÀE]z ôÜœ]xœ”ú¶YŸëS3eý!Ø —ÿøÚtÄ„oÁÜ>ÎД\cW/€Ùß#À²âsúìF.#0ÃMÿkú·1F‹ÿA³¬øòDø·ÿžVÝ !„ÿ³‹ÿ•+6ån™×eÎ{ðÜÛ ¿ ÀÉß‚Ñÿë8`: Ÿ~ÜßÐ4yÛÿ4ZdÝɵHÍÑ=XQ£óÁÖ7€ísFaƱ8h Z£G$¤=°ïy¼Ö=G2ï?Rx79 ptÚu°‚
JØ؀à xïé1ø1EhÓq#Sã0g¶Ÿú>‰î΄_/,-Iaßµ7š! žNËÆ«iOiIÕëC,í³£ºƒ{ž©W›
¹>UShêÁ‘¢æôÄØýÙ°töÄ9+°`_d6÷Á'׵Ƚ— ¨¡yàs¹Bm 5r‘–«Õó5ý;kê–9¦ 2öÏÀ©Â{á?=Bñÿ €.¥ÿ“€ÅQsHhÏLt¦Êv0fœç‹ øüŽDÆ~ù4Õeûéó \—ÊJeíxš–¥û5æ³ÿý‘—î’¤Ž©Q»ø~ÿÆ4*w,e=_¾²zO]MdFAéQîñĬVö«6Êúìûq(¯$å”<¿€‰ç¶rN€5†ž«†6›z¾Ë_nd’$scOpÓ×x-‹ÔÞ9ÃU_G}Ú£ï5ü ¦ÆëcÜž ÿ"Ó7÷¤Eéó¬ò(ɨכ÷MYŸ}W bTì=æ• !ãúA~8ÔƵl—…ßF&ß
¡ÙÛÔn|)’Ô…>ÏzU>_M·—"I å@ëšÎ¥¤ã~#Æq
” Gíñ
#©å±ÿ8QYú¸¢ îÍ%£Þ`S~ÇQ6Ç0m./þÇ‚Ëù„9X°çætêƒè¤Ô³Íz]Ÿš£ržÈ3$OÚSQò˜q»Œf6¿°$ Ú :Bö0<Ð'›Á¡Ôiq€ž¯©>ѸqÈk“ùLS‹û×¹bÒñÆ0›¬
z¯«³÷}ÚPaцAŸŸ`|~ñqn]¸ÈŒò¿ƒzüž>®6K$É¿0Á@ñJ‰6t[ÇÛúÐ¥ûJÞLÝÅqAÛ˜÷5{×Sv…)4kÅN›y‡w¸9°[·nÍÖ[³yC³âè¶ô_Gò·¾È~ýGqÎŽ›$ãø¹¿mÙ?ÎFßãU’W×¾ÆQžaϧz±÷ |¶¹™þíQ{ðÕ‹$¯~ÄQ½ý0`"— L&yƒ«ž²Ñÿ\z´ÙªÏ æñ.èçËá_Ä‘¼ÄÅ{ñ…MIdâv3Ó³=ú\Ãÿqj¼>úÕ¥}¿¾’AÏõfï/pñ‘t’œÕ¨vEc/N›Úƒöª·Y±ç·wȬƒœÑ΢ìuþ»ŠjhšóÍKdîÞ¬§(yÌêinN'¯¼[úÁMߢú 7
Ìo’òþrjjSTëu} ,ªjZ8wḵÑÔ¦læ ‡âsZ>½™EÇø|=PeÓ‚;5¥µRAûÀ,JßÌ^ú¾¦5GaÛ‹+Φ“Ô2.4„³¶¥úQþMØyy yo#ý {¯«³÷}Ú£räíwIíe®Ÿ9‚ýþ‡o|vŠYէ͉Dò¯ÌQ XøàK ×F$1ýÎ ÜöÎl~;žëúÚÕúD¦]WñoqUWÓ‡ÿ!v™Êp’—ßks„Ò¸ ç_!ùÛd6V•/äîxUù»©mlmikkK[+šª*)ªCÓ¦ô1ÓN\MêNN`#=Ï¥O›úìaž®¸x°ì½‹9º ´WÐòé ÌÒâG…Þí©éTøTw}ôܧÆ×¢º\ßÕn3AòìäÆTÕõèºMW¾þÃ
j™Å?v¯à´€&4WTV ?¨ø54¼¨®î8Fl5÷2™¶™O—Bæ¾!Lâuþ·±ÞÇ)-ª75»ø– <=;£›ÿL_u öŸÇæQ P”™„L&6Ô7 CU2®=¬Œ5Ðe܆S¸õTˆ”ˆX2Ñ®Ö ð¾ï÷¿ÃéË_ÃÏ¢ïW Æáù†©ØýÕd>Òdݼ'TÕ S'Ñ ‰8~< …uöKôOy Bˆ${5€&Uníû >ïŠÙ3}ññâ#Ü~ ¦†‡`î7?aÊo9uØÅC·R(jsœ\\Xü ü7˜ßÖD—‹¸¨ÜžCPG@¡„âqµ™Zh‹´Ðï«VµmO]]ŸÚ\Çû Õ*#µ}СH(”ŠÇÐw Ð"ãʬ~ý ¾üt~¼¸›Þß&ÓÃË}ñ/ ×#Ïá\ú£ž«úãDïÄÆ+ ðÒ¨ö0 ÏLj
½n ®ävœ2ÙgñÑOcâü×Ð%âq^ŸšeÞ¼„‹î€8°Ð0duJÀ·³‡ ñ¶•ˆMK@ºN;ï è“»Cçšaó¦à•¤FÑÝ›¸Wô8^w5lÛöCÐô—0cÂÓpO¿€í+¾ÃÕ<Ã?”v z N)»ðõ¹¬GkR¼'TÓ –ÀJEÝýžþcÞÇ„â I£àPÙ¥] |ðE Ž½ØÇí„ñïð{ü ‰µÂ؆ƀÿÌ2? ù0‡ƒ¥ú¡m9׎à C¯g<` ö{ñȯqôño üq× ªçtH¿|G.r \ÐÓÏ ¸z éù¬¡mÎ<4 V%ǵlOu×°n¯O-®áƒŠî!î.`Þ´5 Ô¿ ³èŸ÷“_póö\útp‡™" 9ÿë›&DcǷ⿯ŒÅ3ñ¼óe„l¾ŠüÚ_tÄn‹ï Æì^j(~ÿ§\ %Ô*@-t´Y‰H-°A÷)½‘½ãi\8§ÁÚ}˜Ò-Y )È«Ë×ÁÈ >£¦ãåS1¢³ ’Ã6`Õ¼òý9$×føÖ¢‚×Gòßà|–áïuuýžP]{r® Â% Ã3ϵ„éoç‘[¿§uÒf!„ø«âßþKCÐ÷Ôtxþty ȳq‡éuxXg :©À “äLJã÷Ü·0hÑ| D¢ÚÍÂòí ÈÛŠ·¿x‡ß߃
Eï`Ãï*xŽ_ˆyÍãñÅÓÛ¯} ½î2 ‹Þ°ÀÁ«…h6â¿XÜ&
;†î@¬žÅŸV6[Öq{ª½†ÿ´Ÿ*mŽl<~² _§ã£Cq(ªß
ü-?å0ìÃùèxí B/ÜDšÎÍ{¿Šù ‹s. £B!g÷¶íѾüßÒ‹Òð×åXdtW·šŽS€èík< .+„ÓÅØrÀ ã<ô±6ó7|¸â&/ëð¯OÍ,]Z E G˜Ú»£Û¨÷ðÑE8ùÒÜÒ(HÁõl7L÷‰Æ©W‘Ÿ§À¦¹xc–;®§ÔÝT
3O¼4$ê XŒc¿ÂÞ?Òð(o'–^0È!Û¾‰@v-Þëêú=ªºöhã¶aÎçsqøíƒØ£žƒÕGbg÷$œû Üêú÷ôßW…âßà¡ÉÖ¶þ_0&q;‡6P?fÖžoìý‘§/2rëD652tò¶ÝWódBÉÍÓ
“yæÓÞ´SÞ¿=ÝsÁ{y9½xsÚŸ?1ø9—
·ÊÓ÷‹ŠÐçî QŒº]X|ó§„S ™ÐŽ
ÏUC›ËÁ§üó,zma†®äËbz¶G¯kø?¿ûGÍ×gÀ’Ÿy=³ô ky¼sýW?ëXü%ÄʾÜdéÏm™äõÿ¶õmõ*o‹;‡/ÙÉði,*iMNün{·55}Ádþ^öµzÔ/*Vr µ§Ÿ)¾%ã©I~9³æãÜÿ¢¢Åý/ : áY$
ù¢¢^×G/ƒÖ ·´åšÃÛQ?sõ”®´-m‹Ê•Ó#HF³qÉ-á<—ðÉSc ëøN
*uu,+öÚp—LXEo³Ú½×Õí{‚ í1rfŸww0"©°ìVw©Ñǹªýû?k5üžÖýû˜D"‘ü«óÿ¨³•rÒ ‰DRS¬¸9Œÿ¸ Mÿ ï ÿ«öÈû˜D"‘è?¸$õBQ=›n“ÐÏ:[7Dý#¦[ýÓÚ#„¢Z!ª£°…Ϥ¾°ŠÝ‚—ò¤=B!*{FÉ !„B!DíÈHµB!„RT !„B!EµB!„ÿ¾¢Ú¸é$l¼ˆÓ‘¿ã§×Û—=ÞpäH¾ñülþž…gæ è>` ¼ TuvL£6óp•YøáYÛ
Ëé>Žs=J{*° ˆ£$¢^oü !„Bü#íëMï ÏrÆ7WIÞâênfÅÛ¦lЬ;næ ÞáæÀNlݺ5[·nÍæ
Íî Ç ˜°óò8òÞFú[•{\sYõÙÃ<þÁý|9ü‹8’—¸x`/¾°)‰L\Ãnfå–î½úGõögÀ€‰\r0™ä
®zʆ
}Û£räíwIíe®Ÿ9‚ýþ‡o|vŠYէ͉D"‘H$’*‹êû¦
ŸÝ˜À„m¯ñímðNzÏ… gcž7ïÎ/“É¢“3ØÄÈ€FÙ<Ç}ùä¥7›W!ÓyΦ]¹2L]ß³Ò‘îêÎeÕgótÇø|=в÷.æèN0Ð^A˧w0KwŠc ÷ ÔÐÁ´);g'.Š&u''°‘J¿ö¨=^fÉ‹3›Ý¿Î©Ö·¨®ë6K$‰D"‘HªšS}Ÿ}ßOðy¯PÌÞå‹×½`pû \ ° s½ÌôšW¢qö…¯pníNÜ(¨z?µc/ÌÞpÑwr ÕåáÞå¯`›=¶{þ™u‡ç¦b÷Wgù(Òé@( T ÔA%TŠ*îÛ‘{»N„¢?š™ê× S'Ñ ‰8~< …uÕù:j³B!„(Veͪ´ëƒ¾À±g⸩ Œo Áïñp$Ö
-ëwtê@ :m5_ºÓ4ÅŒ=¿`i¿Llzå9tëÔ
}‚>BxÁãì¶9:=§”]øú\Ö£ ŠZh‹´Ðé·3¨# P>p»¼jÚÃ’X©¨ö¸Z 2RCñ?k³B!„(¥®üacø/
AßSÓáùÓmä$ ÏÆ v¦×áaè$ý*ÞÂÛa¿Œ~a \7•
µš6Ç3 ”ˆþ`nŠB> \·ÆÍ\ Áƒå]~òaKõ£õÚ¢‚×Gòßà|5µ¾çÊ<4 VF%‡é¼ôôs® Ç_yúµ'çÚ!\Â0<ó\K˜þv ¹• ·è âîæM[ÃAý 2‹ðøÛ,„B!ª/ªmýWâËgÃ1Ãs7’´ ŽÍÃÒ„ï°ãÈ8 r>ž?ßѳ°`ÎÏò9NÿÒ K¿þ—ó ¶v†«æ$Ö~wyyÑøõ2Ð÷…yx%òSüz3Jû®h\ÉTƒüøpüžû-š àƒHT;£¹UB¾ý£òb³
–^0È!Û¾‰@U=©î\é2 ‹Þ°ÀÁ«…h6â¿XÜ&
;†î@l‘~íÑÆmÃœÏçâðÛ±G=«Ä ÏîI8Å @ @›„#Ï€Ÿ,ÀWÁéøèP Šê÷@C µð×£ÍB!„¢¢Ç;q[aJçÞåw¿Å0³ìÞtqüíÓ~t(¹ež‰ÇP~°ï“óJ¶ëry/î<7þǵøVoe1¢{àjžL(Ù±0™g>íM;¥!m²b¯
wÉ„Uô6«n¿ªÏUþKåŸcÑk 3ta ×@yÿKQŒº]|³À‚„S ™ÐŽ
ÛcäÌ>ïî`DRaÙîR£sUÿúT•íÓ˜–üÌëe9w®Ÿàêg ©B]·Y"‘H$‰D½ïþñoŒu 7§‘ñ w¡éãÎÐ Ôðxõ˜ý=,+>ÕªÏnä23Ü ]N\³–ã±9žH^ë ó7·Cp4ï·©$'í¡ ó X—úðv’`r|ÌJÎbÙ CN"> ‹ ¹ où9@uÿDp Œ gK‚ÌÇíóÛðvÏòûèÃãÌî w*ÛIeŽzfÀµ¥ýø]ŠWÍÖ!óæ½â[˜äFbAo_|i|¿AªúýðáÖ9p9°Ñù ”õ1èëcøòÙËøpBOìˆÿÙk°øÐO(hÝ˯ ТHm»‚1î½hd[wÀ°¹‹±è'\v ˆ îè{ÃýŽS'}׫_j¸M܉Ã˼pæà x è1k%>8´ i-ŸÁ—1²¹B!DmU±4v}ž!y"ОŠ’ÇŒÛ-`4³ù}€%ÐfÐjµ‡9Àºâsm‡R§=Ä6ú®BcBÏE—˜¹•s‡`H™²Ö—æîgÀY… ZO¿ãªpØÎ42n5ýl@Eý@†jÉ?ßnAMÉ~
ÛþÜ‘AÆìU媆Vý~b ÿâ¢Æ´ÚÎÃÇ©›¾ëÕ/“Ž\v“ÌÙ7‚Ž%K»+ò@.³Ô“&²’D"‘H$I ¯¨¨4.?ô ç.|eÜîìƺÈìâqجTäP# ²iΚÂZ©€ÚX
]V
²ô øÌCä;máä9Á{¢‘SÅ@°Â´>œLó‘eê'#(ª=¦Ö=ÞÇÊ!:l™6ÇÒX2 o +%q;¥ãè̈Âák€³w+X=tP,=žÆô7ž„Qô.ì‰Î¯åg—ªŽS7}ק_*Çnðw"¾;ëéG‘–†ÙáØrpõ÷†ƒÌB!„¨•ª‹j] Àws
tºBdƟƺ *¬qö§èJŠêdQ
¼—üŠ³çŽà]O3hLÔÐe$"Ck@KÈW¡ÑXÛ!'¡ ~ë~Ç{ù(ˆ
ÅÊÑ-`VYuvÃè%Ñ ræ ¸]ÉÃÚä0 ŠºÎ|
M €
–[ÀՀƚrWDÙ` Ž!#ú,òýïž°¬Z\䚎S}ק_;wØ!ñ·óaåîk wxXå"!!°sC=üB!„BÔVåÃØ&.¥7²wlÅ…sñƒö9Léf‰¬„äé{“ŒÚR(+ŸWmÒÃ6DΑož^Õ“ ‘–è$ _ñ.Úfü€Å;bQå4ð’>+Õ8ñ¸®ŽSUß«é—6) ‡cŽ#Ÿ„}É+¯tè €›‡Â‘¢…B!„¨uuÅ Xº´@‹Ž0µwG·Qïá£'Špò¥¸¥P‚ëÙn˜î…S¯"?OM;sñÆ,w\NA¡!5¢I4oV ƦÍQß0²o†¶í3‘q7Wⳡƒ¼^{ÏdžCDÌ=講¢ç„y˜T?뾊@vùN5èŽ j~$2 >̵EûfîhÙõŒ|qži…å}§`WRÉÌkµúÍžŠf±çqùv6Mðä ó1Á!_y¾Â¹ª¿ºú §nú®G¿ò¢ðÙ¢P¼ôùWضРž|g®B E(¦¬ù yòû „BQk•ck ¸ó–¶ÜüÜ ÞŽú™«§t¥²t®°+§GŒf;ãâÇL<—ðÉSc šç\]L;/g –¾¹gñô•#û,ÝÏßoç”lÉåó?páЦ4}`š‰ÅSxÉ ñ1«ä\¦ìº*Žd>ï\û;WLcÏFÜ&Ϩ Ç~„$å—œ+‹qgwpÁ`š2¥EÏãÔMßõè@¨ìØ}Ö6FÝ+>Ò½¨íœÝÃŽ*ù³D"‘H$I£(ù!„B!D-)å!„B!EµB!„RT !„B!EµB!„RT !„B!¤¨B!„BŠj!„B!þmEµ‘#¶Çåƒdq´éˆ ß‚¹}œ¡ ¨áñê0û{XV|ªUŸÝÈef¸©õk…y¬Kåýs•Or|Ì @…zÞS±æðUÜ-"ÈB¤DíÂüÞN•, ©€YËñØ O$¯õ…ùC½®ß™[q!UR‡Ô‹Û0«» Ê/ ®0kŽÀå¿àZfq;rbOâË) aeÐÇ=Û¬G{Ê÷Í¢Ãë8œIðÚ|´1.}ÜîCƒ±ãlrIù¸}~ÞîéP±_–í11ä$âó²É‘Ûñ–ŸƒçB!„ªb5@'ž!yñm?zzvaþ“¸âd©;ÃWšj(é4.ŒÌßË~VŸkýìÏ,ä)ŽqTè·
Ò’M¼|èëë[–'/äé2qý@:ª@µàÌ°^Þ̉ƒz³ßˆ7øíe ™˜cUeÇÒ8táØ¥ûx³díÁ”µ¾4¯p>5Ý& e 3y|Y â²ã™dÞNrS¢_Èm2ç7.ý;{õâøOÎ2Ÿ©ÜØÛVÿ•"õj³ í)“V3xð^>S3I¸ŒÄ˜ IDAT^›Ï6Æ÷ûÕxÄÇ ~‘Ãû=Ãþ#gqÝ¥"2{7Û—¼Êú ¼=Ì
ã²Ñ~ôî1„sö$‘Eá|½¹‘ç’H$‰D"‘<ê‹êöeE¤q»Œf6¿°$ Ú :Bö0XW|®ÍàPê´‡8À¦–R5à°idÜjúÙÜ/Ìj£
Ëi›w_˦q“ŸEÉc&ô\t‰‰‘[9wø†$TRT›tä²›dξt,Yn]Ù rɘ¥ž4Ó.ü$Lú‡f¥Ï3ëÆ/’Ș:ï£ï’•5µYŸö”Di÷ ×ü•Ésïûó¹
wk,túýÄ<þÅE Š—+WÔd¨–üóíÔ”¶Ï¶?wdñ {ÑôÎ%‘H$‰Dòÿ9UOfP”› Pù _·;»±.2 ÍJE50R*›èÜ©)¬•
¨ÕÐe¥ «¨6ç
X÷x +‡è°eÚ< K»¿Š:‹
-7sŲ± ,q ù%å!ò¶pò à=ÑÈ©dv•c7ø» ß‚õô£HË Ãl‡pl¹ ¸ú{ÃA —b‰úÃÐŶø™6é‰nöé8s,ù†ü †6ëÕ P;#ð«M1„!]Wý´K§1ý'a½ {¢‹Ï¥4±…•È¸QÖ&fDáð5ÀÙ»¬µ9—B!„¨º¨fqÙå»9:]!2ãOcÝÖ¿8 ûSt%Eu
²¨†‰ÆÞK~ÅÙsGð®§4&jè2‘¡E‹Ôn½d"D.¼wPU=gÒ|Ö~€[«^ÆÚë…åÚM°šÃkìÜa‡LÄß·•»¬-Üáa•‹„„ ÀÎ
õ4 ´±Ø4;Œ^Eè_ç°kÝvüvê ä/ „©ûR«=~u*k³^í.ÿù
«»îGÐÔˆ¯æʲÁ /*BFô/XäûÞ = aYÅÛ´Éa8tù›@,·€«% )4JÃÎ%„B!j*ª•Å_G¼ø– <=;£›ÿL_u öŸÇæQ P”™„L&6Ô7 CU2®=¬Œ5ÐeÜFz-
2ã6“1Ó; û®GùZù>,;¾† ÃCàu(³~EZªÜ œÝ®n0ãdöÛT0oÔ Ø¿f N¦è -2ƒ×¨IèçjT‹séÓæªÛ£t € zãØ«³q ¥úac]ÊnŒíôz
~+N5ÅüG1¯SÉW5ó"<|&öXÎÄØ\èX„Œ{ñf3 )™ZÃÎ%„B!î«bNµãCsª¡tâØ:2òeº«A•óDžÉ‰à›c×3îr0»ú.gtÌ— =糎 ½ÂÐù(¦ì²2LßÊÞÖ•mWÒÆg>ÃrÉß £‹Q5Ç2õâÇñÏ©V¹Nãy’'Ç8RY®_ãÃHž›ÂÆ*–=¹îùçÜ64.'SÏŸŸÅ“Ù»ž£Aýª¾Í5·GA‡‘ÇY¥Â0NvQU~nK?~B¦mò£E…mÚ87aS7'Ú·y“Q$ÏNw£p.‰D"‘H$™S]ÙHµQ¥Ûj• :Ú¬D¤Ø û”ÞÈÞ±ÎmÄÚç0¥›%²Rgè²IK Ø9G¾ExúÛÕFâÛ}óÐpËPøNÚŽØÃ?Ah“Âp8è8òIØ—ô^éÐ#: 7…#E ¨ëµF»Ü¸x«lþ´îîy ¼T3WWX«ô?_Mm®¹=ÄݽcЪM´)KŒß“įÁ ÎØv«Šy6%¯“Rý`ƒ ‘–è$ _ñ.Úfü€Å;bQ„G8—B!„ŒTW=R}a¶/[¶hÃŽ¾ÏrÚêÓÌe!OÌhR|÷So~š@’×ÜΘ€ ;~pƒ$ymA»²Q^}£v{‰$Ã‚Þ µ-‹9}Ö$’é»9ѧ۷o_–¶ 6T—Þͤ[´kÏö]Gñ»2}×xz·oÏVÌKŽ©¡û”£ÌcCã³ÏŽãâÐ 2ï('—ÞÂÎÄ“‹¯‘ŒùŽ¯ôë¶m½Ø÷åM¼AòJp{ú¥O›õhO%Ç}òÛîÈ¡vb¿9ïó•1ÙÛߟ}†N梽·HÞæWO—ÞPA³FíøDÏ ÿæ§ü9FG]àGîPRã¹$‰D"‘H$úßRoç-m¹¿ýçðvÔÏ\=¥+m•¥·¾såô’ÑÁlWRp™x.á
’§Æ8ê?ç’X<µ÷˜Ì ³‡·kšò¨*¦%„Ñ©¤M¦—3®’]Ò7÷¼?BeÇ1ê^ñ¶{QÛ9»‡]…ÂÒ¤É0.;p…é%ÏצþÉýËž§‡!…¥žmÖ§=5ºFM8þó#ü#)¿äYŒ;»ƒ {ÐDqzM×Uq$óyçÚoܹb{62®ñƒÕ‰D"‘H$5ÜF¹´²B!„BÔŽR.B!„RT !„B!EµB!„RT !„B!EµB!„BŠj!„B!¤¨B!„âßVT5Àö¸|,Ž6 1á[0·34 5<^½ f ËŠOµê³¹ŒÀ 7µžÍP¡ž÷T¬9|w‹²)Q»0¿·ÊŽ`ÞëRy¿=å“ ³òÇSÀ¬åxlŽ'’×úÂüÁÓ·CpôÃÇ9hE.£ ^ÇáL‚×æ£q¹-f͸ü\Ë,>GNìI|9¥#¬”ô ”õà;s+.¤ê@êzqfu·ƒê±öK!„Bè«ÚeÊ/¾íGOÏ.ìÑWœÌ"ugøJS
%Æ…‘ù{ÙϪâsŸý™…<Å1Ž
ýV¡1jÁ™a)¼¼3˜õf¿oðÛË:2ÿ0Ç:«Š÷QZ²‰—}}}Ëòäà…<]@&® HGUñ±4]8vé>Þ,YW0e/Í <ŸÙüì6yuI_v*[:¼-ÝUµZAÇ¤Õ ¼—ÏÔLV\yPaE¿ÛdÎo\6ú)vöêÅñŸœe>S¹±wÉÒáúô jºM>Ê‚! UÕ–Ü™UÈСõ ù*ížáš¿2yî}>·áå¼M»ð“2é š•¾ÝøEóAGšèÛw“Ž\v“ÌÙ7‚Ž%K›+ò@.³Ô³ì8uÙ/‰D"‘H$‰5a•ã׺ÂrsÔ°pî‚ÀWFÁíÎn¬‹Ì h³R‘C
ŒT€Ê¦:wj
k¥jc5tY)È*2`¸¼¨ Úr³R,»À7‘_ét ë ïcå ¶L›‡ci¥+ç!ò¶pò à=ÑÈ©bv…i}8™æ#ËÔ N6FµŸ¡vFàW›04b2.CºîíI¸KÔ†.¶Å—Ú´IOt³OÇ™c±È׳ï*Çnðw"¾;ëéG‘–†ÙáØrpõ÷†ƒªŽû%„B!êhú‡q#žáƒbøÍó¨)ÙÇì‰Ïx»ðÇ8ZÐçóD’±ü°“9Ƈ± n½LkWé›4ŸÄŸî‘|Š6ŠJöQ»sZ˜–Œ˜Éæš*ŽcêÅã+ ©6jö2ÅÞeVQq¯
cC¹rt š) i§š.AxïÖzöwP0ç“ß>0R
дådn'y/‚»Ömgdf6Ï,ò£Rÿ¾›tZÆ›ÌàVÿúôZ~“dC|0`g6yc1;˜Ôe¿$‰D"‘H$u7RÍâ±Ó‹oùÁÓ³3ºùÁôU·0lûyl Õj E™IÈÔªabÓA}óq0T…!ãÚÃÊX]Æm¤Zß+`Ùñ5ü ¯CA˜õ+Ò*m6n33½ó±oáz\/4üSDÁµ•xÚ¥ ,ÔjXºuÇ‹ 1cã1¬~ÚVïÑ]¥ã ¬øÐÇ^)º*öRÁ¼Q3xX$`ÿšu8™¢ƒ¶È ^£&¡Ÿ«Q-úžƒ³³;ÀÕfœÌ~,ýB!„u9RmäôÐœj(8ö„ŽŒ|™îjPå<‘gr"øæØõŒ» Ì®¾Ë ó%GϹÀ¬ã#hoЩ’6>ó–KÞøf]ŒªÚÏ”]V&é[ÙÛºšãU3RýPÌ}øE™¾¥-ôj«‚#³J…aœì¢",{rÝ òϹmh\ú)¦ž??‹'³w=G[…~}W¹Nãy’'Ç8RYîµ FòÜ6VÕU¿$‰D"‘H$u;RPU6> µJP mV"R lÐ}JodïØŠ ç6âís˜ÒÍY )È£þ•½ºÑH|»o n
ßIÛ[PÅŽ&-1l`Cä ùáéuô±B¡4p$—¸»w Zµiƒ6eé‚ñ{²€ø5Ô9Ûni¡®× ì
pãâ²ùÓº»çqðRÌ\]aÒ¯ïÚ¤0 Ž:Ž|ö%¯˜Ò¡Ft n
GŠ¶®ú%„B!j£êI—Lÿ°ti- ajïŽn£ÞÃGOáäKpK ׳Ý0Ý' §^E~ž›væâYî¸ œýgf˜£ë; a€b&}
ûÖía_Z„fÅâò_i(I¢nÐ .@ÔüHdTVGš4@ófõalÚ õ#ûfhÛ>w£q%>:XÀëµwðLæ9DÄ܃κ)zN˜‡Iõ“±î«dëÙbmÆM\þ£b ìïyɸ~%iE ’NâÀu#¼µr5^)ZñDã^¯aÅ3j\]x ·‹ôì{^>[Š—>ÿ
ÛšáÓ€ïÌUè£Å”5¿# ê¨_B!„¢vªœþ±ó–¶Üœ† ÞŽú™«§t¥mé—ìT®œ A2:˜íJ¾œg⹄7HžãxÚHMÑ4åQUL¥¢S¹/õY<µ÷˜Ì ³JeÚy9ã*9LúæžÅS TŽì³t?¿S²%—·ÎÿÀ…C›Òô‘¾ÐWùMš ã²W˜^r6mêŸÜ¿ìyzØw• »ÏÚƨ{Å›îEmçì v÷oÅ÷Øú%‘H$‰D"©)Š’ÿB!„BÔ’R.B!„RT !„B!EµB!„RT !„B!EµB!„BŠj!„B!¤¨B!„âßVT9b{\>HG›Ž˜ð-˜ÛÇ € ¯^ ³¿G€eŧZõÙ\F`†›Zï†(,ÛcbÈIÄçd’#·ã-?¨*i²e«x3d?"â2¡Í;i®%ç1ïu©¼ßæòIYɹ̚#pù/¸–Y¼-'ö$¾œÒVeWC…zÞS±æðUÜ-"ÈB¤DíÂüÞNP×ê2+`Ör<6ÇÉk}anð>z¶GY¾3·âBª¤©·aVw»r×°®û%„B!JU¹¢â’ßö£§göè?‰+Nf‘º3|¥©†€’NãÂÈü½ìgUñ¹ÖÏþÌBžâG…~«Ð(ësðö427ŒËFûÑ»ÇÎÙ“D…óõæF÷÷S˜±Í‹ß3>÷]û '?ÿ »{µ¢£qÉy”–lâåC__ß²<9x!O‰ëÒQBaE¿ÛdÎo\6ú)vöêÅñŸœe>S¹±·mñ*F-83,…—wsâ Þì7â
~{YGæ æXg•A«ëh ºpìÒ}¼Y²ÎaÊZ_šº^íQÓmòQæ1“Ç—qÀ€ .;žIæ á$7µÇ‘H$‰D"‘Ô"Ul0qá’'íË–7n·€ÑÌæ÷–@›AG¨Õ æ ëŠÏµ JöØ蹬cý@†jÉ?ßnAMéc¶ý¹#ƒŒÿØ‹¦ -}>ftÚIÎò´Ðo tUÛ™FƦŸMIámÚ…Ÿ$I_øЬt?³nü"‰Œù #MJϯ6º¿8@óîk™Â4nò³0àâšÐsÑ%&FnåÜá#’PYQÏ>z´Ç¤#—Ý$sö cÉÒæÊVÑaË´y8–V²{A.Åõ†¡‹mñM›ôD7ûtœ9‹Ò^³¨ ¬-€–]`‰›ˆHÈ7à yˆ|§-œk? ÀU/cíõB'׬‹}jhÆÎ vÈDüí|X¹{ÀÚ V¹HHÈìÜPOSÇýB!„zÕº ÀÅ·üàéÙÝü‡`úª[¶ý<6j5€¢Ì$djÕ0±éŒ ¾ù8ªÂqíae¬.ã6Òõ ©F^$‚‡ÏÄ Ë™8› ‹qc/Þl$% S (-œÑظ¾ó |÷ËiDž?ŽÍïMÂ’k–xîÅ'QOQñÆm&c¦w>ö-\Šõ¢
æšÁÃ"û׬ÃÉ ´Efð5 ý\ h˜– _Ãá!ð:„€Y¿"çË¥O{rpvv¸ºµÂŒ“Ùp !„Ba½çTCéı'tdäËtWƒ*ç‰<“Á7Ç®gÜå`võ]Îè˜/9zÎf A{…¡óQ4´qn¦nN´oó&£HžîF5@…ý 'yå½Ö4*û⢠‡ 'yáz¨Ë Ç”]V&é[ÙûùÞ°ìÉuwÈ?綡qé ˜zþü,žÌÞõ mËÚ¬¤Ï|†å’7¾F£GœkcêÅã+Ÿ/ß>Õ·Gå:çIž ãHe¹×k|ÉsSØXõ˜ú%‘H$‰D"©nNua¥Ûj• :Ú¬D¤Ø û”ÞÈÞ±ÎmÄÚç0¥›%²Rgðèg!Ò¢dƒá+ÞEÛŒ °xG,Š 0ëÂ〦½»Á±ô q&îxÂÈŽ¾‚Ôò£â&-1l`Cä ùáéÏ ®× ì
pãâ²ùÓº»çqðRÌ\]a]rlu£‘øvß<4Ü2¾“¶#¶àïýäSS{´Ia8 t ù$ìK^U¥CŒè Ü<Ží?³_B!„ÿî‘jãF^OqÜêß©e ?ö©xç
µÛKŒ Ôðþ¨mÙ¼'_#ó _é×…mÛz±ïË›xƒä•àö%m6§ÏšD2}7'út`ûöíËÒÖÆj>µ(L°E»ölßu¿K!Ów§wûölÕȼ¬m5ï£O{4tŸr”yÌ`èâq|öÙq\ šAæ åäÒ[êÕa¿$‰D"‘H$úÜROãÀ·´¼/‡·£~æê)]i«,½e+§GŒf;ãâÇL<—ðÉSc õ»í]Ét®«âHæóε߸sÅ4öldüð~ê xïþžª#IæÞ<ÂåÃ< *Þ-žÚÀ{LfˆY¥ç3i2ŒË\azIÏ´©rÿ²çéa\Ú÷¦|#Š• ¢“Rÿ lÚy9ã*9Lúæž´Ðw }Û£²c÷YÛu¯xÓ½¨íœÝÃîþ“:ì—D"‘H$‰¤Ü@jie-„B!„¨ ¥\!„B!¤¨B!„BŠj!„B!¤¨B!„BŠj!„B!„ÕB!„BHQ-„B!Ä¿¨Ö8`{\>HG›Ž˜ð-˜ÛÇ € ¯^ ³¿G€eŧZõÙ\F`†›Zÿ–·Cp4$'í¡xhg,:¼ŽÃ™¯ÍGãò=ªß™[q!UR‡Ô‹Û0«» TåŸmÙ CN"> ‹ ¹ où9¶y¬K}¸½$Áäø˜úR(`Ör<6ÇÉk}anð>*ÔóžŠ5‡¯ânA"%jæ÷v‚ÚÀë¬0kŽÀå¿àZfñ¶œØ“ørJGXÉG0!„Bˆ*U»LùÅ·ýèéÙ…=úO⊓Y¤î _iª! ¤Ó¸02/ûYU|®õ³?³§8ÆQ¡ÿJ4fOð³ÛäÕ%}Ù©lùì¶t·V=¼"b«ôõõ-Ë“ƒòt™¸~ Uú¯À£qè±K÷ñfÉâ†)k}inè>F-83,…—wsâ Þì7â
~{YGæ æXg•þ×YaE¿ÛdÎo\6ú)vöêÅñŸœe>S¹±·«dJ$‰D"‘È2å„‘Ï<h_VH·[Àhfóû K Í #Ôjs€uÅçÚ ¥N{ˆl hˆe wf2th½j÷SÚ=Ã5eòÜûþ|nÃÝŠEµIG.»IæìAÇ’%·•
y —ŒYêI€Šú Õ’¾Ý‚šÒe%mûsGÿ±MõÜ硶©pØÎ42n5ýl ø0z.ºÄÄÈœ;|C*+ªõÙT¨î/IмûZ¦0›ü,ô¿Î¦]øI™ô…ÍÊ
ñnü"‰Œù #MäF"‘H$‰äáU¿™ jX8wAà+£àvg7ÖEf ´Y©È¡F*@eÓ;5…µRµ±º¬d0ùÁ´>œLó‘eê'£J¦| P;#ð«M1„!]Wq³Ê±ü]€ˆïNÁzúQ¤e†a¶C8¶\ \ý½á ”&¶°R·3 - ªÏˆÂák€³w+X)ôÛçÁiÖ=ÞÇÊ!:l™6ÇÒ Yù=‘ï´…“çï‰Fk»À¢‚²öJX6v%n""!_ÿë\„K±Dý€aèb[üãaÚ¤'ºÙ§ã̱XäË_v„B! RuQ(ž=ì»9:]!2ãOcÝÖ¿8 ûSt%Eu
²¨†‰ÆÞK~ÅÙsGð®§4&jè2‘¡Õ¿!k;ä$ÀoÝï¸u/ ±¡X9ºÌʪ>5\þóVwÝ ©[_IÁ®±s‡ 2; Vî °¶p‡‡U.r ;7ÔÓ Úä0 ŠºÎ|
M €
–[ÀՀƥ~ûT,öÝ0zÉD4ˆ\„yî@gð ‚u±O9&Í'`íg¸µêe¬½^¨ÿuÖÆbCÐTì0z¡Ã®uÛñÛ©w¿t¦îK5¨
B!„RT³¸"¾ø– <=;£›ÿL_u öŸÇæQ P”™„L&6Ô7 CU2®=¬Œ5ÐeÜFº#Õ×Vâi—z°P«aéÖ / tČǰúi[( ( `ŇÞ8öêl H©©lÍÁÙÙ àêÖ
3NfWÜ”‰àá3±Çr&ÄæBÇ"dÜØ‹7›I ÈÔê¹O9Æm&c¦w>ö-\rõëßDËŽ¯áÇðx
BÀ¬_Q~à¼¦ë ¨`Þ¨<,°Í:œLÑA[d¯Q“ÐÏÕH~c„B!ª*Ÿ+‰ËCsª¡tâØ:2òeº«A•óDžÉ‰à›c×3îr0»ú.gtÌ— =糎 ½â榘ûð‹$2}K/Z@A‡‘ÇY¥Â0NvQQå:çIž ãHe¹6#yn
Wøò †6ÎMØÔ͉ömÞdɳÓݨ†¡û˜²ËÊ2}+{[?â| S/~ _ù|iýöQÒÆg>ÃrÉß £‹‘¡×„eO®»Cþ9·
KçÕóçgñdö®çh«9S‰D"‘H$¦ê{Þéò+ ØV« µÐÐf%"µÀݧôFöŽ§qáœ?h÷aJ· d%¤ ïQæ
(”åæûw÷ŽA«6æå†ÖÍÐeÉQ¬ë¸ƒú€_oi¡U‡áp,0}ä“°ÿn;’u€Ò¡Ft n® GJ…æB¤%D#Ý´^üñ]´ÍøÏïˆEÅÁu=ö1i‰a"çÈ·Oÿ{? ©Ä·ûæ¡á–¡xbÒ÷¸UdèuÔõZ£ƒ]n\¼U6Zw÷<^*‹®®°V÷Š „B!Ê×PUnQÿ©ßÒ¥Z´p„©½;ºz =Q„“/ À--€‚\ÏvÃtŸh,œzùy
lÚ™‹7f¹ãzp
ôŸ a¯×ÞÁ3™çs:ë¦è9a &ÕOƺ¯"
€7qùòÏ1‡ý½B /×¯Ä @Q>[Š—>ÿ
ÛšáÓ€ïÌUè£Å”5¿#¯¸Š„Y£¶hßÌ -»>ƒ‘/NÃ3¢°¼ïìJ*V¢Ï>%°Aw¸ Qó#‘QÛÏ&ÿ×Þ½GUYå} ÿž p¸ƒ¢H^P4TDÅhbH™fÀd° ±IDATjj9^ÖòRÚ›ÓkÚÔôª-IMfÔœ±Òš²¦‹×t¬¼4y™¼„¢"‘Sf$ ¹_äð}ÿ8}p毙ïgïZzÎsö~ööŸ}¶¿óì6èzwk¸¹wEk7À5ànô-Bᯩ8©Õ†®ñDÿßÿ£MŸaÖÛ©¸/5‹ââ üðó5T™çœcØ÷“+~·n=æWÁ ¢ýÏa̓Vüøê×ÈÖ‚ZDDD¤Qoc»´àŽËö:5¥ÌNÙÏõsúÓß\ó¹`ÎK"™ÇžÎÇÚÙÂVò"ÉãS?ÓØÈ‘¯íåw٥ξÊxùÌN¾:® Ý›,7ðäýï7x¤ @XZrðÂLÉw´”Ÿ²‹†´¬ó¨9wöÿS&É
^½ð
w¬™ËaíÜ´mäG¼†þ•ùü…#<îø¿ Üû®ff#U-Ÿ s”d¹Æ¥ ¤4Q sbƒÌÆçÙÖyã÷gó*{Þ÷Ü?ž!nú¯ EQEQ”ÆbrþADDDDDîžÑ¢ZDDDDD‹j-ªEDDDD´¨-ªEDDDD´¨ù[T»´À¶Ì
tÄ^€´›ñòȶp XòÛd°äSÄx×ÿ¨ÏÈÝ(cžéhmöíxß;/lÜ‹¤Ì"ØËObnpÃ6Lð¸g:>¹DüòN$<¾ëÑ“Vÿ Š ÷]šq oÏé
Ÿš‘zÁ¦<ÞWÝü² à†Nãâ°ýTÊHÈ>³/kK½ÛmÈç· 9¯d5ò¾ÝŠ…ƒ[Ö¿æ¶,h1à)¼yàGüZEב›² KGÕ?îò¶}lÇ'âRo ûÑIŽãÊ
͈ˆˆˆ4ÔøÉ0¶öL$ùí‹Q ëÇ!ÏâšcÅdu"çwq!`fд²â ÆúÔÿ¬ï¨ý¼Îãœh2~Ƀݟþ”—Ê.ó ï,æìñrpø½ t»Ñ†K«~œúÚ ¦;OúË}'’žõÚðaÔÆl²ôÆ?9”}à àô×O±‚yüp„¿ã„G³7;‡G022²6÷}•'+É+ Œa ¬l?q-7Æ=ÍÇc äÓrÓ¹*²d7ÇÔÜ• g b9‹x$~GžÁø#EdùAÎêh5>n×n|>!—?ìˆãÌGG0vâ¾ÿC5Yq€SÛZŒ÷e¨ ùF6ùãʇØ'4”¡¡¡
íÁN¾Îk Í¢(Š¢(ŠÒ M-ö™Hò褀ÚãÆÝz.c*KøiŒ7Ðïу´Ûp´oýÏú=ÌjûW ígô&LôŽXËÔkǸ0Ì«‰ãÍm [~ŽWÎnáËOäƬFÕîýøz™³!‚ µ‹ÈAÜC¦êM[£G¤·á„ ×ÈÌõŒòkúK€Oìç,çÏ\ÞËy\¹7ãÓÉÒ=è<¶ÝÜf÷•‘i¯…5ÞWSÇZZ]ë £z~‡¹¼Æ¢¼šÕ×mÛïî(¾ÎÃãZµ»è¶>ñLg!·D·føêt’9ÜÙ†1;JÈ‹+ØËvgßrl]gñó|òçuCégºó¾k ]ï~–_eüÊb縮g æº'»ÑÃÔüùQEQEQn·Smrl~û»(„…õÅ èÇ0ïO—1aÛ|òD;XTå Èn…ͯ/fY< +/x㑧ïG “Ñïx¶»!^YØûæ& ˆ½ÊáOÌBl°ëMW»uŸçT`Ï« à§ë7·V»Sû ÄcŸÆšã]°ôè!,éÓ𧑥8µ¨‚;Þ‹gŽ•ü ßmLðîý þvb#¿š˜…ÿÀÍÃFúºu;•Öax‡ð²ZáÝq0žþ2Ï|ø5Ö÷¿i×úvó#""""wªëÖTà ĩG«É³Ï²“´´ÉÄÒ$¾0õfþÇþ‘«™šö6Ÿ|)™ÅG&2Àd°¦8`"<¿ø>ºÖþè°% ?B2y>C¬wª½‡qÓUòû—»Óæ[C‹h¾q‰,ÙõýëÝ;ûË" ¶p„¯ûôŽâ»¹äµ¢èÐ<—gH ›Rg'Ý Äé $OÏaûfý ÏL¿ˆ¥L(#/¾7 \ë¿o¼¯[·Óh<#¸!‡,Øü ½ð/Ì¢(Š¢(Švª2Ãj1´£š€½ø
ò*ý0xΔlß‚äÓ b§ýÌäâ¬\”,ÁeñœÈºŒ„ÀšZd[' JRÏ#ÏàŽ·µÅ}èÕ²¿½\[?]ýë|y®
ÁÁð[çl»ÆÜ…ÒƒïãD‘›tŒÙlu4bÏIÀ ÷äûàœEs«!˜Ø HÿêríÆgÕÚn2Þß³wm ‡ÈYÛQYÿ}£}Ý®Æ7¶Í×U7w~DDDD´SÝHÜÚ1‘dò¢HÞÓ;{GŽâÜõ'YÆë<úLgG]µû þ9‹$b\O76ö^u‘$yaYÏÚÝâÛÇ•Ýžb5‹x`ÉXF„å´õßÑÎ4®¸ñä
“
»õ ehÿ'øq.Y°k:„†òÞvžŽ \[W\ ™ö1çÇöc á|èÙx‘äù¸Ðz÷cíø?L"™0ã®›k¶AŒ}éΟ2†#¢£9rÜl.ÿâ2Élþe¸óÑ|pa§9‡XÎB ^1£FMãŠÃ…dù!ÎnÎ#õàɈ7¯»93¢—ówŽôñ£Õp_FÚñbøs+øÒÌñ|hx4GŒ›Ã•{.“Ìá{1þõžºrËùQEQEQ >RÏ¥w\¶×ù‘b)³Sösýœþô¯ùÑŸ%˜ó’H¦Æ±§›óra+y‘äñ)M<¯‰XÛ0fñN~—WM’,K?ÈÕBê-„Ýû®f&oVðÉ°ÚÒ[ç ŒßwžÎ÷ìyßsoüx†¸ÕïÏkè_™Ï_¸1£‘Ò—ÎœþÖAþ3§ÂÙJ13Omç²±!´Õ-!±´äà…[™’ï¸*?e
iYï±v·K.HaãNÌ`Ù`_FÚ±räk{ù]v©ó2^>³“¯ŽëBwS3æGQEQE©_Î\³²‘;cÖˆˆˆˆˆhQ-""""¢EµˆˆˆˆˆÕ"""""ZT‹ˆˆˆˆˆÕ"""""ZT‹ˆˆˆˆü§-ª]Za[fH:b/@Ú‰Íxyd[¸ ¬ùm2Xò)b¼ëÔgän”1 Ït´¼
Z x
o ø¿Väuä¦ìÂÒA¸Ñ‚:‹ÃöSY(#AV ûÌV¼8¬, ËûÞ1xaã^$eÁ^~sƒo´dòÅÌÇp©œ «ðËÙmø]TÝvŒõeòèŠI«ÿŽ EŽ9*Í8†·çô†O3¿ªjÇÜ‘ÏoAr^5Èjä}» ·¬s?FæÐÈØEDDDäNÜò˜òo_ŒbXX?yx× +&«9¿‹ 3ƒ¦%_0Ö§þg}Gíçu ç”@“±Sh\»ñù„\þ°#Ž3 Á؉ øþÕdÅNmkq^geû‰k¹1îi> û ž¼›ÎU‘%»96 N?&vúS^*»Ì¼³˜³Ç?ÈÁá÷2ÐÍy¹5Çn»F–%0þÉ(ò_ú,‡¬:Áÿíêj¼/“£6f“¥ß0þÉ¡ìþ §¿~ŠÌã‡#üŸ&i¨ +;Î>ÄrñHü Ž =ƒñGŠÈòƒœUsL¹‘944vEQEQåÒÔB7ˆ‰$N
¨] ºõ\ÆT–ðÓo ߣi· àhßúŸõ{˜Õö¯8Ú¯G;Z]ë ïí9ø æò?Šòjò3>±Ÿ³œ?sy/7çk&zG¬eêµc\æÕèÂÖÔzÛÉï_ìF—š×ü æöBòÒÚpºí˽ _Ï"s6DУæ:AÜC¦êM›Ñ #íØz3>,Ý3‘ÎcËÍm&q_™öZXm_·›Ã; »¢(Š¢(Šrë4]¨`v©S3`…WÛ~˜4ÿ t¼º›Î– ìÅy(¥ \-€Å¯úöé_³ V7+ª‹sQ\ÕŒíòªJØë–o´ï o¤#)«¢Ñrïᘷà~¸¦îÂg©ÎkÌ»ô)„˜ü1í³,T²
EéÇñîÜpø:Gj¶ùÃÇ fÖöÇ ¸ ´ p/|LûªÌÁ¹ ¢uÌôów4îÞy ñë T ¸v,ƒÝHúø8|ç µ¢,ju›“àèhe16‡Í »ˆˆˆˆükå ®LdCi|o|»Ú]No0ûúqN ôbÄ[WHfð}<4=•™kî~g+}[×Yü<ŸüyÝPú™| h3…Gªœ·SžÀ%|nìH{Esk™¿oÓŸa}†pòÊc,e!wŽ¤Ù¹ë»ê"ÉïVqD{M°Ð»c WþHòÔl¶³ì û=³¹íÉü$îÚ´g‹J˜¸<Š-ÍÍïíÚ±õ‰g: ¹%º5ÃW§“ÌáÆÈ6ŒÙQB^\Á^6ƒsØŒ±+Š¢(Š¢(ÿŽò[{&’L~a({õêÃŒåÜuÇYÌ_¸ý‰v´tí¾„?–ŸäÌnCùvz:÷ Êâϯb·9§Y~nïviî͘èÝû9îÏ'¯l›ÎÎn\cña§Ð öèS\}ð*yý4—öñt.‚§ò’‰³ÚÝ(ƒp½‹$«L`€ÉчO¿Ü^]çËB%I²â‹‡ék°/À€áñ<}í÷,ŸÏ…ñ[x:ŸdÚGüM§æÔ'ß¾‹j/ÂêÇÁ-è
ï&Õ·šÃfŒ]QEQEùwÔTÞTS
s§ &Ï>ËNVÐÒv&K“øÂÔ˜ùC ûG®fjÚÛ|ò¥d ™è\Ä™~K™PF^|o;¸øŒwßÍ%¯}E/€¦€‰ôìG¼Hò|\¨ñ±jÇ…æ b9 yxÅ4Ž5+’å‡8»æ‘zFæÐÈØEQEQ”ææ Ä5Uþ±ã²½Ním)³Sösýœþô¯ù!ž%˜ó’H¦Æ±§³v׶’I ŸhüYÍ.]¸ …;1ƒAf®9ýƒügN…óbfžÚÎecCh«[jamØÅ;ù]ž£n¸,ý WO©³Èugÿ?e’¬àÕ ßpÇš¹ ÖÎÁØõeë<ñûγÀy•=ï{î Ï·fþ0ÓH;–– ¼p+Sò ×ä§lã¢!-o,†Ì¡‘±+Š¢(Š¢(ÍMœ @? 'µk/""""rGú›$8¬¹i¶Ã kY¥ùi¶U P󌊟 ×¼ˆˆˆˆˆ²ÀZ hx0õ! Qš ‘[: `XÍ_Ì
Þ ÕW‹ˆˆˆˆÜnA=¦î
Õ…Î÷Í•ˆˆˆˆÈM68×Ë…u_lêÜ¿ÏáxÌ^[ 5w""""ò_î0€¹pÖP7d2Ð@?8¶·#tƒã"""""ÿɲœp Àßàx u“þ !·pÕáñ IEND®B`‚ stem-1.6.0/docs/_static/prompt/tor_commands.png 0000664 0001750 0001750 00000120340 13115423200 022271 0 ustar atagar atagar 0000000 0000000 ‰PNG
IHDR Å á áçÑ sRGB ®Î é bKGD ÿ ÿ ÿ ½§“ pHYs šœ tIMEÞ óU¡ IDATxÚìwx”UÖÀïôôž é!!ô^ņè6l¸«®ºk[ý,XÐ]ËZÖºvEÅ.6PQ)Jï„ÞûdúÌýþH’Ì ®«÷÷<ï£Ì¼¹÷ÜsÎ=ï=·¼£=€iÀ8` Ä P(
…B¡P(
Ňj ج¾ JdÿX“¼o
p-p®Ò·B¡P(
…B¡P(~å|
¼ ,9Þ¤¸ðw• +
…B¡P(
…â49¾Øu,Iñ\àyÀ ô¨P(
…B¡P(ŠÿQ<ÀuÀËí}©ïà tJ
…B¡P(
…B¡ø FœMó‚ï÷2IñƒÀÝJo
…B¡P(
…B¡ø
1¾½ÄøȤx.Í+Ä
E×bÎâÒîgºq#+s›J#
…B¡P(
…â¿“— [?h»=ºÍgˆŠƒ˜úÍc¯°òñYQm kDM|ž}. JLA–¾\ùæ‚~¡ îÉo¿.…B¡P(
…B¡èRžoÉJŠÿίú¥ZA=§óàG›(s „4®å?·Œ"B` í†Í!ŽºêžJ(qÎwøÚù^ð,å¬ #½þ¶³{vqg¶©YiÝæ°Z ß]IÊA…rêÂz|k® » y¼ßžMDk«‚2ùÃc_³§¾ù»º=_ñØ ²úUd…f²g^J–õk^^Y×fuWGHê 2ŒAôêß ó ¬K ÈÕ/¢È!ÂCÅæ÷¹cB\;ûþu„õ9—¿½ô›
ñ:Ör]ê!w–*Ç<€ù¹GÛkå¬X4@w.ïìkÄÛòySÑ&?qC#Úv#9»ƒ†%ý æ-ZG±] „‹ê}ßóïëG¥kÖGúŒù|°¾»á¤tã"î<50™åä9¾{Zû—.þ|Þ/t úÎ[Ï5ïr÷ÔDŒm{rp/f=ñ
û›ï³¬âå?!\˜M[õÜûr *^KÈ>å_‡z¢Gý‰¾ÛKG „›ÊmŸpß”î‡Cþ#Ýv¿~(ë?þÚÞÚ¼$®\áEÁÖ[³“EVftÑŒ½õ=¶TûÂGõÖEÜ6.¦ƒRh„º™ïbß}ô3 þ]ç>/[Ž?ßë;~mr2oTwð¼¨x‰“‚eõ#çcrzö§CÿýT:¶Èú˜B¡P(ÿ›Zòß؈_óeîu½ø®Iß¾Eâî‹&‹q§œ)fÿåqñÜý…DÚ
›…Ä_Æ ºú$… ]Xšè7p 8p°8íîmBˆí➉ƒ›ïë—*ÂtÍu™b3Eÿ#ï%bMš „®Û ±Z!DXxV¬Ð€PqêÂzá[s…è®ë\ž~iaÍ£‹g¿]!„s£xîš3ÄÉãÏ׿¼MxD¥x眸–rÿ‹—yxx¿õ‹¦ŠÈ#¿Ó‡‹¬ÃDjˆ&WVĹâ{!Ķ›{
£l]ºx1ýý:!ì«ÅcO£N>_üßâr!ú
?ósáûÅÃ̇>÷#³\¿èš{ÚÕÏ€E®h Mk¾/h„xºXˆòŸ$‚&öcÄ¿Ë…8ðè– .ÿ6‹üðQ¶ù=q÷ fŠ—ŠåííéP3˜„¾Í=!ã^•¢N¼3!TÚdÚ.ç‡2¶m»Y x0G¸¶Ý.úº[ìö‰§Gf/ËñX¾¶/gŠ]kü›%¾¶ qà‘Á-öjù<ætñÂþF±áþ‰âì5‡'³ø|§åHù†»KÇ„Ãúm7qá‡uB>'&DjéÇŸI•#¥Ã@žƒõ‹cë_êR—ºÔ¥.uý^Ÿ´nŸîœ{ØZrF 'ψá´Ç{ó;0÷¡úfëÛkÝU÷È ‹›ÈŸ&™Ù÷ì?XZéû•¬¸;ØöÔ¼| O_Õóðí†r"zä¹ `ï.)ÆÓú±§/ßÞ
ýÏeTŒ¤¦t¡dOœH×®=g*SÏ»Šç
FqË scË–ofô£_òìL/ ¯ÂØQ£9ùŒ9ÜõâW쵶÷Ú+ ý.MjÝç¼²¦þà§Þò÷¹ O?ú
<‡÷v >鯯൹±,»kgwÿ\eíÄîí×¥³D®ƒ†Ò¼-Ÿ‰†m|·Gõ!\tñœyߟÈТ˜³¸—ðИÿ¯]7œÖ]ÍRå ZP<݃œXƒºÓ=Ò$u®Ù¹w.s“9ë²Ì²þ<‰?M¶àÏzÂ2&qý-ã1å~Ââ\ç¡ÍÇ ó/‚f 4q³nºˆ´ªÏxcsSóç®rvâ'_Ȉ–=³A=OeLl=ë–àDΦà`ó]ýé>x&óçbÇ®Cáq ô ЖœBùl*vä?þÚ p9Ä ©¶[úpÉ%Élû÷ûìÞù ¯îèΗhÿ ȬOÃÄØôŸŸˆ¸þ{êWs{ÜÞÝ©G׺ßÖȬWßaƦk8÷ÁÕÔûŽÑçý”#çþí ¸-4"N¾ŸïãÝëæ±¼N¤ >&SNàqƒãˆ-ö/…B¡P(þg9衦 ùg_¯^œÏ÷Ÿ7a5˜Éº4™Ë¿Â½_d0ezÁú®»GS÷¤hvvü\€ËïÝø¤®íYªå\}b4è«ùžûï]Ç€»ïeB¤&)ÏnÎ4b2âÁ]Bn§ö©Î-ÆE<1 ñ.úž/aɧ¯qÏ•w±™ÁÌ<%¡åœ˜‰˜äH¨ÙÎK—ñÓÚ5¬\ú¯¾ø yí)5h sf&Q³øUÖ6´¯žüÝ;Ù¹k/%¶Æµ©3¹ç‚(¶ýíl®zü=¾øtÿ¼óÖu$wuy+Vóíyë_™œlACOXr6©a€1£îÏŒ1fê~þG®œÌˆa§rÍBÁ¬ç–ñÆù èdËŒ1ØŠ]Lxc;%µN\?𯋳 î,YVò¶–B·~t7ÉØ L=äýY×íVx<4ä~ÃÃcwrÿÅ÷±Úzè{y™;–çøî9º]X‰Ï禱h-o\¥çkoã«ÖA¼·€Wü‰Lá‡ýøä÷ùù§»p>r ú²ºù,¹„M›u/¤ÞbîO‡‡å‘½®â•ç'Sò̼’ã–÷C‰¶RŽ_[H´ÝÒ÷fõØÆ«Ÿâq à³ÿì¡ûŒK$o/cL:14RTê$<=ƒˆÐt2ÂíÛ &h#€”K_幑_qÅŸÞ£ÈÓN —òyÿåHû† »f ÀÆÅÿ¸šn› fÞ×U´¦¤rúñïc2å7dú©ß~!Ù¿
…B¡ø
0Í Œ;êc¯—Ê•|µ¢’¯o5“qN<“ïJ c@4 Ñ‘÷M{]u„˜Â‹ï¨Ç³…¡lâÇK™4ð&Ö LÐ6q넹üÐZ®·žœú¥?Þ¾—ïú‡ç<ÙÁ;oä¯ã®`Yck&m£¸À
˜N¨e=Õ{ȳÁ€ áè/u|{Ë|¸äE¾(=Ÿ
½Í‚7^á/wRïmgì9hô¨æ³W×Ñ`ÝAãÉ¢Œ7Wá–¸¿Ãº ›™ÿ‡[éýÁc|]p[ˇÍ%º¾,¦Ñ ºÐD’C!çÃóŸoŠð›·Ï%ëü Ü{íx¢?|Ÿ*‰r \ûþŤ”zBSG3ëžWxéíå„UôæÊoj;i€Ý_³?Ë 8}•ŸqÙÐѤe áìçsßÊïÑFç¾MR2 yºÇÿÚzÇ.ûº‘ ˜T†žw¾¿‘°‹‡2ë?ExÐ’”EFh1_=ÿ«Œ'‘ì føEs9óåŸXç’³i £u:lµaØ¿ðÁ²'ô팽íGꄼ Jµ=€rälÑiJLŸÙÐmë£|Ñ’]æ}ú.û ºš™}og퇔̇°±þöA¤>£,ßÍ)7·I®ÎáÉÇG±üÚ>|ÝÑ
¦„ÏË”ˆotj÷€læ~×pë('_^ø9íš¡cýHù˜L9Ä
™~*×/
…B¡ø]0®yôÕÁ kSr˜~Kº¸~ÝpñhAóõȲd‘ Ôõ÷tvéº]*Vú„Ø}W a:øyñ¯b!*^'ÿ7Î׊§„
0ˆ”«—‹¦¢7ÅÝ‹9S¬ —¬Bl7 öšֿ[).í&yÞÔ!þ²õˆó½aÅ¢F!r èعbLñbØŒ›ÅS oµBÛÚGĤXýe†ˆ±ÿ.¢âqrhGçbSÅõ›šëŒ:â»°‰‹D£(/Œ –xÑ–D]EdbO‘™Ö]Äöû›Ø&„X}š0€ÐbgŠBˆ=÷ö=äZŒøÃ
!Ä–›D†A®œvë
9Iü»\ˆúwO¡ œÁD‹3–ºÚ¼ÄÈ¿ êº_.~Bì¼#»ý—Žut…M¯U
Q÷Î*)óûL1ºîⲕ>!6ß(Ò
ÂNoT ±ëî~ýR=Q<_$DÓ'g‹(-P›".ž*’<óØ®u"ò¤ûÄj»y¯_(RLû¡TÛ¥ü0À3¡ µÝÜ_<#Ú%çÂ,)³>õ:±Q±ê’„C/þÓu—¯Blø£HÖk"nö
Ñ!îÕâš½„ÏË•°oøí;21¡åYSÿž˜r„MüëGÎÇdÊ‘‹Çv¦¸ÓØHÿR—ºÔ¥.u©ëóÚ¨RŽL•õÉ1ÌøxóWeó‡›bHMðQñ]9Ÿ\²{'Rhïº{¤Vzª–³`µì?ÿ•ñQº_ÙÄ‚‡‚÷îæmí"n?-<€3>jÖ~Êv0ëôÄC?ÍaHfÚ%aÇbÖTŸ€óÓ®
6|ø™>„Ä·±kÄí<37óð3Ñ¡C¹bz< ¿ÎÆŽVò…“F–@ØÛàmû¾e œ~voÿ¿a,SnêŠsÉ-äOÞCÿ†ùûx aÝÇšBÈœ2†„V9,éŒN…¦Ü=T{äÊiXçמ¦ž³¹õ4#û}È>§ìÊå¼³VÐçÆ[8%: ^|t†NÎ HÈüˢà ×ÊnˆîË y[KhU—¯f#KwxNM%B ¨M¤ ’fóæ—óèñî ÆÎ}ŸWà~(Óöc/'pLigsaz!ÏŸ;„~ýúµ\ùxQ
=/˜FšQNfoùj¾+€!³ÇÛzF?îdf‚üo×PéÔ|q }ÖÑ~ýFpùb+½ÀyÃf±¨Ä+áórå ³otØw$laéÍ…çöÀ¶ìMÖ ±Úê_?r>&SÎ1Ç®Š-
…B¡PüvI1 1G~êµùˆ`„ª&6½UÁªÿÔPP!NÈ=rygoß0Ÿk×ÝË—Ë-Üû…¬)60¼Ox;7‡“Þ ÛîÃõÔ±wVÉ Ó›I¯ ¡Ä§†)ý20®‰’=9T¹Ú‘¿ñg r×<6( f¹sÞäî…ã“g>âIß]¼»[Ï 9ÿà鑵¼7ýõ¶é +áŒ{à ¦×.ãÛ
¹T9ƒH ?†D¼ì+k¢j†_Åyqe,z} n¤óÕ±ã§B¸ù6’Ë#I³üÄK vá(\Äÿ½x7ßݹ”ņÿã¹epÄŒ'82oì¼.à¤þ ÌJ§÷ÈÓ™}íuœž´'Îø#Ÿ”·HìØÎËÏlàæGŸâ»k¸ç‹²®xŽ›’óyfÖJêeË!”ὋÓ7°é@-¾ˆLN½j sã+xãÕfÙZ‡¡‘ÙÃ9ÆI÷AÓ¸þ[}àY&=¾‡´? àÍ?Ïgîš{X²:Šùü‡Ÿ
ÝDö ÅøÄåÌ»÷ªtÝ9óö?‘U°‘Ý¥V´ÈžŒ¿ò>®Š+ãµ—7¶èÊ¿Ì]OÇý«uŽ+,%›ìì‚bÓsѽüs´‡U7|M‰<å«ø:ÇÄ ÿzŽ›´œRà‘±)h–nôÊŠÇ Ô‹x3˜b³è?°‘†š\ö5á3Èè0„‘wý“s´ÅÌ}9—ؾ‰muqk»÷×á‘ò ÿm'€rüÑyÛô˜|!½›~æ†ï7³³ñPªø`ž?\ȤÄÇÆ—Neönãù‡à†_eÑCÁ<¾
ÆÞú Sµ øã Û›}¾!ŸÝ;ÛJBl äì9@@ÂçeÊ‘ñ
)»ËÛÂÐm “S`Û}›i8Ò ýÈø˜L92qÃ'ñ ”Š-ýK
…BñÛ!Ú[BÖt"ª¯YXô,3wÕ=Ò—ND¸F¼°lŸ¨oÝQW“+V½:Gd˜ÚnkçâŒpÙíÓFÑëo;Û)d—¸3ÛÔÎöé–- qç‹OBˆ ~’ Zp¶¸è©oENcs-9ߊ§.ÊÁZ º‘Ù>§Ï_,¶–;¶ÈQ¶U,þûy"µío€.N[P#Dñ3bTpçõêã&‰ùߧBx«ÄÆçϱºÖmÚ‰bê= ˆMåî–Ú\¢:w…xfZ|›Ÿ&ñWWùL¡Â)ªöý,>|ò:qj’¹öw“ïýXl¯ö !„°ç/O\˜ÑfÛ¸D9ú1õ‘¯ÄöR[‹¼vQ²ñcñÐŒL¤µÚø\ñŸ «ðµÜa+Þ,?y• ¥;†í‹:1äJñ¯¥»Eµ§ECå›ÅÇóω¦žâò—‰åΖڬ¢pýâÁé¢ÉËÜõÛ§;î_ºøóŇ%Þ6_ØDé¶%â¹?ŽQº6?¿ÕóBñØ×{öcoõ.ñÕcˆ s 6E
{B¶#NýÂS›·€ÊèИ)nÙÖÁ–݃}Ù¿ÿȵ]ÆŸåü§Ó¶ëº‹K—{…X}¥è¡;ògàn;„W¬¸¬»0HÚ }ŒwÛ"±¶ù®Úmï‹ÛOŽ9ì'†8âHÄø7kŽþ}a>/[Ž?ß±»llzÊQ+*ÄK'wp”Ä~¤|LVÏþt(ñ ”ÒDÿR—ºÔ¥.u©ë7ti-ÿ£P´Ì“LfaþRN~c$YY‡ý·R—B¡P(
…B¡P´ƒN©@Ñ–È1s93¢÷l;áIê/Y—B¡P(
…B¡P¨¤XÑ9Z'Í=ƒð‚wy{‡ã·S—B¡P(
…B¡Pt”š ¶O+
…B¡P(
…âwŠZ)V(
…B¡P(
…JŠ
…B¡P(
…B¡PI±âØÐw#fÄ z$E )m(
…B¡P(
…JŠÿТΧÿÜWÉL iû)úÄËpÕkô ž&§$}"±ƒ'e°.…B¡P(
…B¡Pü·0t”+âO%qÄDuï†Aóâ©ÝLÅê×)-ª;ôf.}2‰üîá‡ÿµuÙµìÎmlÉC p©ƒGdOÍZÊV½Ny™õWð†/–Œ±XÜ[),³ ž‡&cÖ™ðEEvÑÊouSˆ }=²²0é}xª×Söóë”—6 ¡
}äPâL$:¹Á–
ÝO…Õ+_Ž?{Y†‘qîµD‡[ ð5åÓ° %W`sµ–¢ÇÔïAž”rt‹ÿɦ/7ám‘W6„n#Ï#.5£Þ‹§a/µÛÞ¥hW.^aÀœ>¤Á㉈B‡wÕ*Ö¼AYI 2KÉs|÷xs f˲ø‚FÐsúõD…´taÇUµ…Ê
ïPVX{HfC7¢‡_Nbïþ˜à³î£fó›î>€W`ÓV=FžLÚ™×^ô [—ïÅ×ƧüëP²/ûó Ù¶ûõCYÿñ×öÖ[¢‰=ëiÒºiØ×ÜÊÎe‡d‘•9 ¥¡‹™JÖÙfÿˆ |„ÝÛæ»N}^¶ ¾!ÙwüÙÂMúE÷ÓÞ<žã{v/|«GF?’>&¥g:”觲ú‘õ1…B¡P(¿Ó¤X—@ì˜ kZFÑ·{pë’ˆ >› S‚p¾ûª›Z†
šƒ [ cNë Ó‡ÏÚt(ʾ‰ìQé4m}™œ2 xIgÞˆ÷ýG¨lôþw[¯ïAtVÞÂ7±ºÚ•|¸ö>Îöšnøjà=QuiáDžr7i)¥”-ˆZk(ხ iÚˆ÷ ¤¼ÞÓòÇ&‚ú^GÖèLœ9ßQùóWØÕ8í¾ÀÊñc/M †9Ü‚}Ãcä—
L±Ãˆ z
}SRØóé;4:Ûêè …Ÿ½Dƒ»ÍGºÒ"N#óü+·¯§ô§Ï°Útcú¤oyß¹@h<…Ÿ·¾Ÿ)…è!3IœbľðIê BÒÇää9ž{„³ éB0…°¯{ˆ¼B'ºT¢_BâÔx|ïÝOyƒ"lÌÝddVQ¶b>5õ:‚3g“:î´Æ[È+j’³) Y2ˆ 8ƒÄAƒ0ž£œJB‡2}Y¤Ú.íÏþã·í®?š„øzJô„÷‡eÇ“K9{£t‘“ÈKîÚÕ¸ÔU¸ š}=Ýû$Q½6ÿ°Yy}ò- šä%çí§ ,káDŒ¾ž¤´t,¡Áh€·a;Uk_¥(¯òÐXÉ”Nü˜9tËÈÄd „ wÍJò¾xçÑk>ºÈ±Ä„Ù¨_‘sh0 2Þ]ÍÁ
Î¥O±éóõG'ÆÆ$bG]Iì^˜t^Ü5%è WŠn¯.,ýHH ƱþEŠsJ@S›àÙ·’Ð7™ÊŸóð¡¡O˜Iæˆ*>½•²êv~ÓWª {µàßµ´J·R[PFï /&mÀr¶¯/h3.µã¬-ÀÞ^ƒµH¢Oº„pÏ*r>yñP‚[°–ªCµàÚ¿€üýÿÞ†ÕÕ‡è©É„„è©sxä|LFž.¾ÇÛX„ºª÷Ód!rÆ™„†›“,Cw¢R"ñä|€ö-BzÎ#"1]Q“œM14à$%Qñݳ˜Æü™¨£%ñ¯C™¾,á?B¦í²~èWÏ2mo_–¬‰Xê¿fÿj=ÏŸH\ôgTºäíHŒ2 yêL Û ã@Ød&êóåHù†„Ýel! 8+÷á<”Õ5q2!öoÙóÓFÜB2†Ëø˜L9è°Sÿ‘‰-²>¦P(
…â÷› à´ ÔBbÑS…ÍÖ&[5D`Ô{ðê#1š ¸]‡ÏµkA™„‡‚mÝ>ô}ï¢ÿ¥Ÿ=Km5D$öÄ åã’ÙCY°ôèGo)–lÆ¥EÞÿºMú îEó(«÷ &BGÝFJFe+ ¡®Îæ,a^œnÑîÀÛ’5“kU•‡¶3 ûZrß߇^Eô¤;èÞ®<Drii
T¯}–šz–¤‰$FwÔ€öëÒôÁè5ðÚì‡tí*¤¡ ¢âÑ“‡O 'bØi˜©$fÊ3$†˜Ö\j¶¼Eá®<¼B² {µ‡¨_IYÉ,zö ‰eSÁ[<;ÀÒŸ¸$#Ž
‹©wÈX‡>¬/ñ{£5|O}ƒGÚÇþ{è›W ûŸ„Ù±ÂjgëŒv«À8ŠsN.¼¡M¥U-“þm
nlëî`Ë:†t’G ‡ýôeÿñH´]Úý"Ùv}"1™1Ø·ÁQ«§ªv YÉUæ¶SO2ËÆ(]ѧ\GTÕ«ìÜ”ƒyü1ú¼¿r¤|ÿݷ…†¾Û RÒ5K>¤±%0KëÇŸÉ”pÜà8bK ýK¡P(
Åï3)n;¬ˆ˜@Ú¸þ¸v̧²¾Í‰?S(¾&aþÁ
„u•ë^£(§´y»©%¬v7úØxôF#f£ [“ bã0èÀÈÞä¦ÔlÅ 4Ö˜Ÿ5‡èî”×W#0` gE;±Ú½@. ®-Rˆí'ÿGšÚ®6øl¸êl sâî ÿÒBGÓ==ûšy°ÌYÆ IDAT h9ÃX_j'²ï_ÛWhu {.
Ðmà„@C“}hwÌFÀmBÓ CQñF¼åk)Ûº »Ó€%cicïÂ`¿…œ¼z¹r„{µgu $$bÔÑ&)îC朷ÛÜW@á{÷PÞàE’Œ ¶Š*ÿçƃÆÒûâk Õ o.%Ÿ„µÍ¼‹¼Ì Ës|÷ì!÷©u ú$ô´~Z뿪¨úvá¡A¼¨¦úÇ× ?óJ²gõ¡î@9¦ôÁø¶G ÕóyÿåÈûFçvÌ€.–˜‘§b¬~—’¢Æ6ó‘Çðö|L¦ O qC¢Ÿúï×¢‹›Ã€ó&cl7,¶9sP(
…â·žkèc¦Òó¬‹ *~‰Ýkv ¶XÔ/aïÂ%€]h&ÑC¯&íÔ{ÐÙoã@qÛ3Ÿ.šÖÞÉÖí:ÜVaÚ<.¥ÿyS0µ¹»×å-ƒ Û2v¿÷Öv26á(ÅéàÖSy6V¿EíW’uÉply«¨ÞûU…Åí¬®€.úd¢‚ÔíÙ ð™a]xo,ÔQUV#•¶tX—7ŸÒïþƒeÒlz]4õÃæöÖ4ËmˆÂdGÞ2jŠ›ë³Õ¼‚%íº÷í!o
™r²— GœéNÜ/ˆ>„lJçØHÞGó0…§ÙïBzœ}|ú %UÎ eîDž@ïùüUÞcÃyÄMûÚùä9Ð̱„¤M#iÒ|ôßßÍþœ:t! ˜µÔï\ŽU׋ha"$óT"vÑ#gÓ@LáG‡~û²¤ÿøm{ åÈÙ¢3ŒXzŽÄXý9uMÍçÌÿLj DG.¤©Ê-%³LŒ"h(É£3i\y
`Êø¼L9øFgvÈ EFB¼›úoWàhw†¬ýH>/ü–HÜè§rý¢c|µŸ±÷£å‡M
ŠÝ
8¼(
…B¡øí'Åú„éôšv>†Ügصb
®—}ø¬{©úéeBRæJAñN„£LAfðÕã²Z$¦8+ñøÀW»˜½ þˆè»Í!{Œ‚Ï4Ïèûqzèà‡£ÄQ£'_Ý2rß[OpêXb2O¦Ç”3H¬üœœ¯ÑpØHÏLpöHŒŽõTU9:äv:\´öKGÑY]oå—ä,\‚>$ƒÎ…×0Žì f!
Š›WBEó¶DCp›Wòøê±ÛA³D¢×Ç'QŽŒ½Ú•ß‚9&lŸ+¨ã3}>{)nLÅF¡•v®JaÇY“‹³&—Æâô³î"a@eßï:Bîöe–;£à=ÕyØ:;Sl-n>£ÊšJsðÆ>CúÀ˜ö/Á©ïMòiÓÐm½ƒœME–P¶y©3î$uÌÏÔ-Ý„Wʦôb¿:ô×—åý§Ó¶ä‡2¶è}‘i±há—3ðªË\©Ý(ª*”’Ùå7FizL%Ê ŸcØĶ5O¿Ë‘ÿÞýTúõyÉr<øF§vÄ&‚³Çavm"¿¸áˆÉGÿ1\æy!õ,$nHôSùØÒž: µ
O‚5€P(
…â7Ÿk!'‘>õ|Œ¹O³kź#¢ŽþHwĘ$‡+ÄgöÆ» ,ÙDÅ€k{nó¿=u8jêšÇ¹!6„Ï‹³¦ »û[äkÀ–÷¶¼¯)Ž:“ÞÌ&¥÷ìØÜfeL#6- ÏåØ:¬Ç× #šÏ扶cÔ ØExJtå: `IÕåÅÛT×ЃøÓ§äZOn^ËBwMVHHʸ©¸ùüž!ŽÐPðU• ‘ôodd Ƽ©§„Ìþc”@¾ÀöÌmt`"xÄ]¤Ç®$çë/h´ù >/ðÊ”£ «otÔw$l¡ïATj¾’‡ %‘á>&UÎ1Ç.Š-G ‹»LmŸV(
…â÷› r‘läÀîr ‘)‡ntWáh´!°2à\ÂÝyØ›¦Â³Ï'.¨ª=-olõR¹y ãæÒs¸‰òr 8‡v‘¿«¨‹2ˆÐaåÚICU9 ¯ S·LŒøpÚ ëc'i©£vO' °a/¯†ÓèÑ·:{&ý^ªö•à³®¦h×¹d¾ƒLÝ"*J*æÞ9z¹óº4t!IEÄ7€è¾“)¤ü«W©³·”ä-¢rG £.!}ˆ•âB+æ^—“ZEù²½‡~Ø_9öj ¬ë#Ò Ið`Œ Lüð3 iü†½[ äíå«¢jէĞw ½Î
¡dËOX›¼Â{¼›’
Ûñh‘D œˆÅz »ÝfJ 4û|b-uTínÕ•„u9A˜£Rj;!špÖU ´>´;–ˆt–8B3§“ïÅúÓÜ„}/
ºt9 ¾¯h°
L‰gœ¤Ç±iOK² cS@ %"Mß £ 4K7‚¢ xå8šœ “Ñ¡L_–ñ ÿm'€rüÒiÛ=“FbñäPP’ßfM×ÈExÈ—Tú$d–‰Q®* ®Ãã£ÁåoÎúJ¼> Ÿ—*GÂ7¤ì.o -¸á¡`ßôvg©.ác2åÈÄ
á¿Ÿú¤b‹ÿþ¥¶O+
…Bñ{OŠu‘„t‹ ÓPÒÎzøw•/±åÓå¸1cJ%zàƒM€wÕJ¿]HéÁ³ž^œ»Ÿfñ
R‡ü‘ÌÁà]KÑ—¯QÕÎoûj–R°JȽáø¨üÒˆN‹ |Ð\‚šçö…½úÍOSÛöìoÁÙC1Ø~¢ª¦³½wnì›_¦4f.ÝNº‰XaŶëjrJð ?ÝǾ¦ËHì7‡ÌzÀ‹§a5õŽÃ¬Îë24è6úô ÇÓp€Æo²gë4¶}K Û g¯á
’ûßDïa>ëNÊ¿{‚¢r‡|9š{ o#Î'ÑÃn§Ï0ðÙ
hÈy…]¤) U¯òCö|TI⨳ˆ?ù/ôÐ@Ø ¨ßÛ2È4a Í&®ÿÙX‚ €WÕVJ¿iã?šŒu5i$ŸóðŽ¹™} §ÞׄË&ˆy/ýG¸p×î¡jåï®hö1o>%_=c/¤ÇÔHp–P¿õ_ljýI+›‚.ê,zM?ãÐyûÔkè“
Þ܇ٲl'> Êôeáß„LÛ¥üYŽNÛþ} a©Pû
vÏá~çÞŠƒYDw £²HFæÀbÔqù¼T’ñ
»` -´'f¨©o¯OIèGÊÇdô ˆ;é§ ýHô/O-öêZ5JP(
…âw€ôPí7ƒ©?³ï tï½lÿyÿ Zmü/Ô¥P(
…B¡P(Š€ÑýÞ¬O8•S5µû
Ox’úKÖ¥P(
…B¡P(
•û!„ÐìAè«©®uÿ†êR(
…B¡P(
űðûÛ>P(
…B¡P(
E :¥…B¡P(
…B¡P¨¤X¡P(
…B¡P(
•+
…Bñ;Cߘsè‘ö¿Ú-˜¾‘2(½ë î¿ý(
…BцßVs4ô‰sè;u<Þ-°{ýÿÚ[Ÿµ ô¾èjBZ?(}ŠMŸ¯Ç{BkÕcLžNꨉDD…¡ ;®êí”ÿð<å'ðe_ZÔùô»`Ž%7’SФz•âWˆ…Q÷Ñ»¿ŽŠ/æQXfW*Q >‰ <ƒã+J‹þW ¡„ö9“xç^Š·ä)ý(
…Bñ»MŠC“1ëLø¢"s6[Cy2ig^CxÑl]¾7 [Ø×±ÿƒýèôQÄœvÝŽUŠˆiô¹p6Ú†;ع©¨ùhºî$œû(ɼÇöÏ>ÇÑši$}òy„”ÊÕÛp †PÜï l»KÆX,î–ÙNˆMuáÃè>j:±)©uàkÚOÝö7Éß–‹Wè1õ{'¥ õ—Þ܇ٲlg×NŒè“I¼àït?ücë²kÙÛØ¢’nD¿œÄÞý1ÁgÝGÍæ7)Ü} o—¾Ö®+ÛîOÏ€!¨asHì=‹ ¼õ[©\ÿ%ûËðê«Z4±g=MZ7
ûš[Ù¹µì¿ñψ)*M§#(ÄØ»X‡z,ƒþNÿ‘=Žø¼„âEÿGi½GÚ¦RåøñC]Ì,úŸŸßH^©ãàÄ@ØiÏ ¿” ï¿Ýû †fC6éÝCŒ¹ï ß³{á«X=]×/ºÊ ùÅÿdÓ—›ä&9µp¢N{€ôŒØƒ«·ÞÆ}Ôí\DÑö]¸}Çc¦’uöÅ„Ù?bÇ fÏ_mŒ:Îvù%‚˜sž#=äsv.z›´è è?ã<¼+ob×®jÉ8¤Ã*‰#Î ª{7 šOíf*V¿NiQÝ¡2´PB\Aêà‘™ÁS³–²U¯S^f=¢ ÙgîqêGF ™g\WéçkW ò O ìºdlÑ%ö’ñCÉvuIl1`NŸNÒàñDÄF¡Ãƒ»jkÞ ¬¤ñûÎqö‹.•¹ |Þ˜Bìè+è‘•…IïÃS½ž²Ÿ_§¼4@ýtyŒ:Ñ2ŸXßø%Å>\{ g{M7|µŽyUV³d=p‰ƒaŽi¬ækÂYÛ:®ãì‰úoÈßz}_DôžÇ©¶©çe$Æ–SöÉRÚ滺ÐL,újÖJu¹ë—i»¾ÑY x ßÄêêú´F‹˜DÖùs³¡øÇ…460Åô%'â°êPøÙK4´YÎò®ß) ™1À±å1öçÔ¶t@ >kë
yacî&#³Š²ó©©×œ9›Ôqw 5ÞB^щXI?þ¶ûÕ³FäÉóè™QCŪÇ8P¯#8s&ÉçaòÞÎþüÆ€|U MB|=
%zÂûŒÃ²ãƒœ¤5RûÝíìŠÔpTÕŸ zqîù';
-R¯%{8ùuv'îÆ@&YŽ_?ü•áͧä«û©Ô šªÔ‚‘4ñ\L…›qv©í»Ê ûîŠ ž/ á±èjÞgïòxu¡X’Î yÔ]ÿ]
ŽSºÈIdž5“ cÒϯ7F _»d’Œ,A@è(¢#?ÄV-°dŒÁ ¸"#ÐLŠu ÄŽ¹€°¦e}»·.‰èá³é1%ç»ÿ ºÉ×Ø•uÉØ¢‹ž~ýPª]][B³à)ü„¼õøL)D™Iâ#ö…ORç]7V—í]$s—ø¼Nä)w“–RJÙò‡¨µ†>è
’¦ÝŠxÿAÊ[&~ýë§ëcÔ‰—ùÄúFÇI±¹ 畘IPXz €
ëšûسµDêÁ¡‹9ÌÉg fÁgÝK]‰ƒŒ˜=û©Xþ$…ù- XCä9$öJYà©ÝHÅÚ·(-hó€ò#’Û•µàQ¤ŸuQÁh€¯)‡šÍoP¸«uËHЀ?’”TDÅwÏbóg¢NÔZ 'bô
$÷ì‰%ÈxqW§bíÊŠ[gÞ\4myª^w4¤u,$Ž €gç|J+]í®ÂÄóq‹0koeÇ–:Â&?O¯·Øòé¸ÛÏ<’ìK®ÁóõŸÉ-öÜv]äXbÂlÔ¯Èiw¨O¾…A“¼ä¼ýÔáƒJ}
‰>L|E›ÕÓ0²çüÃê›Ù¹¡E=ö"Â<«ÈùôÅCA¥t35GÕdÇY[€½½¹€ ±d_|-æ ÷°ýç¼–X0“Ÿ%+î;v¾÷ŽHI_Õ,L^Ü•¹Øj¬íô¨îD¥DâÉyš’œ}ø [í[„ôœGDb º¢¦æUU¿~˜Ò‰ 3‡n™˜ €pá®YIÞ¯ÓàRm×BÆÒó‚k -|š ߯Ã-@ Aú…7ºÿ ì\µ þõ¬…'13 ëÊ{)Ü]… ¬åEó)#ÆSRøŸ„¯¶„ KÖD,õ_³µžçO$.ú3
ÚÞ£‹&bÈe$õ FEáÀU—Cíšç(,lŒzœ¾cŽh±‹Ú/¯#·¸euÔr½/½ŽP¿«|øì#ÑQŽÝ¡aŒq ®šìvqdPôë¤Êñç‡+†ôÛ4)ªÏþBþÁI4Aà ¥ßÀ2rÿóµîdÿýT¦¿ ÎÊ}8ÍÂ5q2!öoÙóÓÆC1INXÿ‹I0Š`ÂQ@ݶäoÙ…GHÆY “ˆ u%=²{aÒyq×” \Ò±ÅB¸L\-iuÍ2l•yx€¦òøž¥gÖh,› °y]áƒ.!©ï0‚ƒ
€wm5kž§°°¡MÙHž:ÃöÇ8v#™ í˜7ö|²g_Op¨Ñ´ª
¯Q¸§°Ù~’1ʯ~¤ž_ô¯NÚ%Ç„DÿÒ…c1VRWn&*3‘’: Ѭ•E„Ëï.ó•R¶øÊ}ž–vn¥ÑÖƒˆ³Gn¢ºÉúdâ‡ôA>KîÚÕ¸ÔU¸ š}=Ýû$Q½6 _ ã
»ûYuô/OWÄIýü’í
D -‚Èñ÷Ñ3K£æÛû8p ÕÝÎdîʺdlÑö’ñC™vÉƉ‰M×þäïoý÷6¬®>DOM&$DOÃÓucuÙ~Ñ%2w‘Ï[ú‘Œcý‹ç”"€¦Z7Á³o%¡o2•?çÉÅ–®ŽQ¿„Ì'Ø7:LŠµà~Äõ {Þ!Mn—Í Ž®¶Jz;Ü“°°J¿~[ÚŸéÙÛNÙÒ‡qdü™´“Ï£¦øu¬žÂOšGf /5kŸ£¨V#¸×L§ÌÃøåä7ÉÉc_KîûûÐ뢈žtÝ;¸:ó¨^ÿoªšêðjá„d_LÊØ[ñUßLA¹ pc[w[Ö 0¤“<ú®žh,=ú`q}Åþ 6ãÑÇÞï$ž9ãçwQPÚ² Ù¹“âŸ7uêU¤†XˆÖ~&gÞCƒzO EŸÞNyìtz6€†eÿ ´Æ
|¶*ž†FˆŽÅ 7á˜Cô¸jæ 4bµ{ O€m7bɃɵ‰ªÊ°uÚÒ¸D#Ž
‹©w Ç*´cÕ•–<Óš< ¾æaD¼ oÉ&œ^Y_ õ ¼úHŒ&î#·xë±[†ÄQ„˜sht
tá}µØh*:\ýû¡‰ÐQ·‘’QFÙÊG¨«³9K˜§[^¢é'|—Mß3®#£üÿØ»ËEôø?íø‚Ýkv4$ƒüéYÃ7”
)(ª=Ôÿ}5Ôï+„“†bþ‡]ø÷U }"1™1Ø·ÁQ«§ªv YÉUæ œ°3¬¾uë_¤¨¢ B†rÊÂ#ƒÐ
x°oyˆí{ÍYc&=¦Ì%ʽœÊ*硺œÙÿþßÐk€CÌäÛù(Ãñ#ëä"· ?”˜Õö”ÀêHDF"ºò–É"]Qñˆ²E4:Å z£†¾Û RÒ5K>¤ñà ¡#î%»¿›ª5ÏPTiÃÐc©#þF¦ó6öìªìº-öZQ§ÜCZZÕkŸ¥¦Þ€%i"‰ÑHËÅÕöÿÖçõÖªàfŸïÕ×BÃÖ7É)ªÀgHÊiÓ´ 6´$uQDŸr QU¯²sSæñ µÏIÓöW(©÷bɸ€¤ñ÷`pÞFîz¹%£ Ùç—Ô²[çí’Šc2ýËŽÑh§n×.‚‡žDpž‡(ýJËRIMD§!¿Åó`rÐâÓ!±è©Âfs·ì„È$<lëö¡ï{ýG˜(ýìYj«!"±'- — oÈÚ½3——’§+b‹œ~~ñvÉÈ '"9M£ù¿G&ª22wU]2¶è{Iú¡¿vIŽ\“G Ö—ø½Ñ¾§¾Á˜Ì]å?]"sù¼>½^›ý=\…4ÔCT|"zòðIè§KcÔ/$ó‰ö
?Û§]Øs¿§¦Øq £Fl{iyøz‡a+ßE½g)™)˜M–Ñ$ö‰Æ±áò¶4ŸC¬/.D‹þ;=†¢´dY‡ìD Ÿ
W
tNÜÅoõû+þ³©"2o!¬[4Zyë¹Æ{ºñ(l{¨/Úh(>€˜1Ÿî#FR¶ø‡–¶ûpç½CéÇHJ…¦Uï ‘¼¸p×—à5Yxð4”`¯u 6u×ÖAï :
cÚM ˜Dá»÷PÔ
5Øî]
í†b{FãÉÿ‘&W׫EœŒ ¶
™‰˜>dÎy»Í¿÷ûÖƒÔ:QOÃÞ\7†È°Ï)«÷¢…ö#<Ø5¯ / —ðU«G ™Bñ5y›ði ¬»¨\÷E9¥Í_TSýãë„Ÿy%Ù³úPw Sú`|[ #¿Ð€ 0„ƒ³ˆÆ¢Xí^ k mGà)z‡œ™ô=éVÒ£D&WPüñ‡X[’kÿzÖc‹ _9ÎÃö¹zñ4Ô è†Ù¢»GÂWA5–èBÊ
j>¨Ë)%©ßX‚ÖæÒä-d$‰}cpn¾‹ý›ZfiMf\§Li°ÂQÃÑ2Û~ÊL¢Œ»)\üÎá«è«®¸¥bw'±¡3 vQ H¬óS–??”š,ÚIe©—Œ´ÑXÖæ5Ÿ¯Œ CL„‹úµ;ŽZ™íºŽ KÌÈS1V¿KIQc›ÕÀÑ$
ˆ¡áÇ›Éß×2ùR^ÝŸ¥gß¡˜ö,Áéë:[tOÁ¾f Zγחډìû×v ŠGúF…ïÝCyƒ'€¸zø 68å ’’¸vmÀá-dI}cqn¹‡œµ-&.1
c›~hÊœKjÜö¸—Ï„¹£V~AѶ–REùûICFb*ø—ÏŒ
H?~Ÿ_þú—L»üÇ1™þå6Ecмx+~¤Nû3‰Ã}è
Ÿ§Éq1š)
ƒîcð{]ÄÒÆõǵc>•õ[ã0àÀjw£Go4b6º°5¹ 6ƒ\^™g®¼Ý5C:}ËD‹ð!Üv|‚€ä‘-Õ%£Ÿ€ü¹ÓµY=û“§u‘a?%ËàMÒhضÿˆx¸ÌÇ^—œ-ºäYp ãÞvÛ%;þ‘%h,½/¾–P
ðæRòùGXÝÇ.sWùϱËÜ5>/ì¹44B·g^ü
M^ô¡Ý1· MkU袶 ¿ž»Jæí¿Ü™â惉-ÿëE´,Aè"úD ÕEm¶áyË©/®£Gf ̆e¸ºðÅÉZP_F]H\r*f‹†×nG§—áWr¼ÚSB]Q Ý3ûa6üp°íZø0¢#Aø 8kæÝKšW<%ƒ·±±fS8Ƭ À@tb$5® E> ŠÑ'l¥nÏþÃVuq—Òÿ¼)˜Ú|Öëò–‘m»ß{
«Tu¾vÜÚHðȇè¾= . é`’s€ÂÏ_¥±ÕW„
§ëPòæÎÿ–Ʊ$&5Žò†añí£¤¼IÚWDýö.\èÐ…f=ôjÒN½ý675 ’€ÙXKýÎåXu½ˆ&B2O%b÷>ª=’~h£aõ[Ôžq%Y— Ç–·Šê½?PUXÜÎJFgmpbÛô/
’ %¥wŽ
wP^í
@Ï ;ŸÜ©¯±ô ‰±úsêšš½Æ™ÿ3ŽˆŽ\HS•-¢?A4PS óP×cξ–Œ,¨^ú uÇ,üé° rÁ.ŒuþýP¦vnÅ7y41Q b«eŒÙ¹Žüù´Hõ÷6“ZÔi$Ä»©ÿvÅa1L‹èOfD?á†M82ñêÞ¼X] Ê Þ uT•ÕH<:8+œ¸Í¾P\ívƒçÞp°Ûö¾Ê¾59ø ]d‚¨§:¿¸cŸJòèLWÞFC ;g|Õ4–ÖAV6fý7¸|þcT`úñÿüê´I·«ó8&Ó¿<¦(tšŸû ÕùЧ¿žŠõùx½` G§ƒÀ2
}ÌTzžu1AÅ/±{ÍîvŽ¹hZ{'[·ëp[=„
41Õ™ÐqO‘ÕzˆÌJÕâ›8Pæ H ¹Ø"[W'ú9VîdÇ¿žeìåÅ]²„¢’ãíƒÇY—¤-ºäY@Wù¼ÜøGÇFò>š‡)<È~Òãì»àÓ)©rž€v g?•‘¹«|Þ›OéwÿÁ2i6½.švЗ DaÍ1¼,±‹ÚþKÊ|‚|ãÌ}Ÿ¯ÃNÖuÉwg#¡â§ÜIRø6J~ú'õµMÜŸäÓgµ™ÿ• i‡¬ÄŽ›ApÍ"v®Ð“~ÞLR²Ö³oOµô€E4æà} Š DPL!e[õÄõJpi4XW6ÖòP Î ‰Ñ±žªªÃWî}µ‹Ùûáh€¾Û ²Çø(ø|Aó,Ž¯§Ð „ M§ëÐú>[1nLXâ¢ÑŠZϱkÍ3Ô&ÓgÇY‡ÍÕÑ,Õf*
]ôì=ËŽo±ôLET¼Fc»©3_=tϺ—ªŸ^&$e ÑÙ©ïÄgìMòiÓÐm½ƒœME–P¶y©3î$uÌÏÔ-Ý„WÒ}uËÈ}o=Á©c‰É<™ SÎ ±òsr¾^DÃa3"·½y®‘Q:`É Oðö…_Œæ_Ï^<
‹ÂlÖ·™6Õ£F£gë[´üùª>È´X´ðËxÕå‡Ë˜Ú¢ªB4Í€†!18Õ"§1¶?îíó)ȯ?ŽF )¸ IDATùLÿ:ìªEWÇÕöü°u2G;¢:M§ãÐêž’%Ô:ï :;•âz=ñ½bpí[ŠÕu( úí§2ýý &‚³Çavm"¿¸áˆ§¡Ñ@õwRvÄOÈ ¯—'к:×hGé§Cßèà¶
±s 8« âC:-°¾¬O˜N¯içcÈ}†]+Öàj³„£LAfðÕã²Z$¦8+ñøäê× Ûæ²g_˳Q¸pÕ¸ŽCžžq-ƒèÎêò¯ŸÀìÞéØFº]Û«kmq¼ub‹@îé‚„¸³vÉŒ[^ÄY“‹³&—Æâô³î"a@eßïê²vuM?•‘y7º.òyx+¿$gáô!1t.¼†qd_0 QP,›.oû/ ó‰ö_,)öÿ‹M¯¶Î%µéÆõ;±3Š°¤x´Š¢ƒçˆÄH¨ÛÀ §7^/`ŒhÞ¿ÞöyièNxŒ†sËBJs
›ëjÂåáÄ%Å‹ÏÇÁ®ßÙ] aÝ#¡~OËY5 I3IìÞDåâ¥Ø*5
vO"{ôEDä?{Ôí:vþ"l®Âûœ‰±ösì4Ú{ñæhÜÅÅÏÒü?{w GY?pü3»›Ín6ÙÍ4G“6iÓû¾8¥å*”‚-E9- þEDðBðQ9”CÎRA -=è•ÞmÒ¤¹ïÍÞ÷>¿?’¶i›4“4ÅV¾ï×k^}5;;óœ³ÏwŽgŠÉ,¶^ÁáÉí$ØÑÙ6Ùü¨xŒPG
žëÅ}DB`päc2l%Ö[+í¤½YQ4îR¶?yØäR®Í Y8¬üfÌ9àý°¼×[åúj«½ÿF º†–˜Õ%ÔÑãÙÛP5.gŒ¬äLŒˆ
¤ ÆÝø«ÞÂ_õ6õi2fÉ ó ¶mjÔ &Œ`ØyבÜþ Û> SøÙë)9e;ÛVlêºE¶ßrVD[×àrÒóÓhížh C:©£
Áù<¾ÒÕVµäi¤§´Ó²ìç´ xþÃŒuÚ·9r
‰k y+ 3ƒäÜT´Ö–¾ói, wîØܯ²cÝN>É7
jX3äǺ¾Û!¡6¢X°fØÑ‚Ýõ•JRjâ¡?vá]4ïj#cÌ…¤w˜I·ÔP¿½ÇûÝõôS=ýý@å‘V”F¼áƒ# ¹ˆwn%Àl’³Œ„ööñŽùìë¨u± ³±ÏÃÐ<ø÷Ùë:®î´"Úk{3îÞA™¤äe¢µô6‘¥"Vû[¶¾”Ø#ì3“4ó.Fd~HÅÛoàñ÷‘ cnWsn#ÍÖÿ1*2Øò9â÷KÇ@Io¾ú9Žéé_ZB
-F<®Pá&ümÝE)y@A±f;•ó“Pù;>XwÄ«µT ·²KÇ`ª\Óu¬µ”‘–á•: OH½+b»ñtö5† dz4Cïé:ʾú/ŸchσÌWõÕ£Ãw9î-ïâîñh™Þ4 û¾RƒXg°?3ýäK×ø'>ȼï?
“¿¾÷5°~q,i º6ßc´JÌ×BÌ”Göy‹°†?¦²Jÿ¼OCsŒâMóзÿRPÜg¥xWS·ãʦßÎÈø‹´;
XG_Fž£ƒÖ7× üwå'ÐÜ7ÎMgÀ†Ù¸›¶=
Ä£Íx:ÁQ¶˜œöex¼!4KI×̾‡´{‡Í8Œ#h–\¬éAb¡f‚¾^šW>‚ín(›Ï°Ñ^Ü‘d̆=´U4 hd- `’Wg KÉ¥¤ùq¾»¶ë œ±ì9§`lú-]Wd½ÿŽwôõNü'îu:,±f<.™EÙt¾»™°×@KëRFæk¸?n9¸
y7fžEª¥ç®A(• wÅ^8å2Šgh®oGYËH ÇÅ’x;í«^!kÑ"F-L ~ÓGø|l©½Mbo%1m8ÖÈ¡e êl?ðœS¼åmšó(8ëZ`'{ë\L´ÛÄK°Gªð{|(sö²ÅdYÝ´íê~ö5°·ÛDî©×’ ·Waο€Â#Á»º~DtµC+ÉÓ¯"-¼ w[3јsn) Ä ùCÈ{)3o%/y={_\FÀU+¦0aÞ—^ý-öîsë*gåþ€úÊ…”žöu
yŽNI£.§0ËGÇ»+ºnƒí·Öb*˜…%ZAMþ ŒF¤j jälì¶7iñ¬¢©nųn£H½‚Óc$1o.IôœØHâ˜/’— óƒÍ(ûðîWĉû{öYþÛO¿K–$ ¦dK×Ï]úp¬‘Îf¢q¥ûX×ßvôµÃ-´5F)šñòƒ/ÑéÖH ±„¼´(žz>/ !°ý
|—R|:Äk ¥Ã X? È *i4öd¬ßwÄI å[CÝÖ…”Mº‹1–—iÞ·H<³#“hÕ2:½úëTw]Lù¥†hihE%Žx¾ô Wuü6ì½”Ò™·3Bý—Äüy$k ˜±[…Û r"!S817!Wk×`sÿ˜À6†Ô cöqKÈu´ÓúáÚ®6¦ã5 ò9Úï—žþ¥'_ô ë¿i$˜-hqß‘yˆGÁ`ÅhÐt¶€DlS¯$•
TïlÆ”:üà`*ÒFÐãGÅjiÝ´ƒœÓo¤d†™æfHž´;Ø·£N÷o®®z×ÕVõ¤GDZE åó‰æKGzŒŠG’7ﲬ™XIù{N©+ÍC³/}u1Tõ¥gì§#_zÆ?zònHÅ1él,Þj š9‡ä²ÅdZ:iÛY=àñêQ÷¥·ŸEš‡ªÍ£a°`udaÍšHú¸s°Ûji~ëtö|ËBå3DǨO4ÍCÝ6N´ |xVÝGEð:
&ÿ ¥fˆun¢ñ§hÔó›ž 1ãFrO½•LåÅ¿ã·tT47Ò²ìL§-!wî]»¯,ûªét ¼Øv£]pð¹µ¢›[±Ê ¯%Ñ-Œoý hN»žì3o#[yºÒSÙ#(VV’'ÞHV’åßCëŠG¨vu]y¾„\G'm+V d(ïGÔïYBÙ„%8¶þ g@éuhlÇ6šë= 4\åëˆåáîð0ïV’ʦaò¯¢ãè÷›Æ;–Q³RõòÚ¡íP‘t…ãn¢trW]DÝ»ép oû»^qR0kÃ枎P¡¼Õ»;KYLáÅ ¶óMìùËOqíOb¼‘¶ukvÞ,¨|W`€Ãz-“µˆôIç“Ÿd"DÚ6Ó¸ü9÷·ÕØ>ÞzN»Œ¼ù? Ô€«üWÔl¬éú1ÔÓµ šûäɱ&tŸÕ«Åµéj*ί¯¼ÿ oÚbFŒ·ÒñîŸpvŸ…ŒT=MmÃO)>ýRZÿ„'¬£œ•›Î÷±7p-ùs¾EvÄÝÛhyÿê«ÝúÚê¶?bYÎw9tR^E¬½œ —“ž›BËžvÚÞ{ ã©×2lÎ-dj1"ΦîÛôö×…û¨Qh@ê÷ÚckþoeÇŽöm:ÚO?g¢Ëngü¬¼É¿ðGäÓ@ý ߥÑÕy¬Ó± =í0ÞFÛ¿ Âxê•äœy'¹Pjœë ¢f÷¡ge•g%õ—2zT€–õ»{BO?ÕÓß»«-¹„DÜt¸z;¶ûñ¬¾—ž+(˜p #F[€8Qךê—ÃaatßûÒS~<«¾Ï ßÈ ¿”ÒIFº&ŽÛE‡k Kê<®ö¿ 7+~Huèzòfü 醑öúŸxPA‚»•žËˆùóÙÿš¤ú·ž¡©Á¯ÿ5òéó÷k¨ú—†1GÏq¬¿þeÄh†xçaï¸TE"&“Î ØŠ-×æi_<íÐÏZ gó«+ˆ¨¡°+á:Š¦~‰Ò)s®¥îÍ'iëñîÓ¡ o ý
M¿éÑslÑuÇ€žòùó5ôÄZpÕ¶’9JÃU;ˆï‡j_zêb¨êKO;Ô“/]Ç=ål&!¹Œ¬ ±XM@ˆp[9ï š/Ý}ç¨ûÒ×O‡*ÍC#ëä;;ÞNÔ]§úiv•ÿ/:°:å“£&2RN²2×R/Vã¿ø Ui–öw2Õ›ý5þƧÕèɃߎ±@å}þ5íœ 'W“åÓ¹˜§«²ŸQã'f+M~¿d‘EYd‘å¸.'È”ËâdbÌ™‹ÃÜNÛžÚ!žÄá81çvÝ
œXJö©—’Põ«Ãf_' IcÎÆ®'¢%æ“:i ÖÈfšò>l#æ‘—‘coÂëô`Ì>Ÿ {ïúº“£Ý
!„BˆO„Åb€l$—MÆèýíÎÈI‘bCúJÎŬ<ø+žf×Ê
Cxë–ú
³a v:ù# 1èz}KÓJö½ñ7œ„³&LöaØ'œGŽÕ ‘V<å¿¢jo'RýB!„b?½³J!„B!„ÿs RB!„B!$(B!„B!$(>IiIØÆ_CÑ”é q4Æ\2f.%¯ÀÑã%òâ¤:Ö»’á“åX'}Yú²Bñé ŠMÙ$MÇfé%ÙZ2ÉcÎ'« ã hó¯eâŸd܌⾠òhi>™tùÒY_ŸŠt>™SÎ%--ñdOÎ:=Ö¾£%“<öB² û>Öi¶³{ã3ÌØ¿\4ãÿÎY“ªÞõ×Å òõ?Ó—…Bˆÿòð쓤“yÑ#çjÖ|“íåMƒšÝËv%çÍÄùÊ|Áÿö+u4ŒÉ…$ÌÄÓRû œ~2i6b ÿC&:üÈêÆÆ77â= k¾ 9×3éâit¼ò
jZ÷ߌíÔŸ1¶d;Ÿû#Þ(`Ê!múRòË&bIÔ æ"дšÆ¥ÃËtF^òÒí â¾}¸÷¾CÆð‡Õ€ëë˜YÏ`ìÕ_"©á ¶¼õ Âq )ó ¥Ìþ—®ÜŸŒSÛ%Neäâ[IOî>dĽ›ÖÒ¼îyZ[|'t ü䎦ý´ÕOð˜ ëØûÒ^ Æ42æÝAîqËt2©ó ¥4ã?ìxþOø¢=j'm1ã—\BxùÍì®òcÊžKþÌ H–‹I‹un¢eõS4ÖuÏ~Bõe½ùòa]œ`íY!„ xˆ‡®ö9äd»p7±= ˶—ÄNö¢‹ÞýS¶väwVsbd§šÚ× ÇÝóMI‘NÞ¢6“4ý;”Lçº_SÓØŽ²æ“’k'Üm¢SH´[¬˜}
sæt²§ÝĸáÃÙõê³xBê¿R_ZÞ•l`oçãHaH&1ÙDpãÃTíócHNÚÔ«)Z˜/ü˜VOìSÞûo«ŸlÑø9}`ðŽ Ï ùñí†Â1$'ñ¹cã
òηúÛƒ´ûâ'X_Ö™¯!‹ñ7E!„ø´ÅædŸ²”Ü‘¥˜M€
éøª7žÂ RÚ…eÔÙX\o³wµ‰’Åg“•þÚÁ«ƒÆáä_ö Ù-°ù½íÄÌÓ)[z¦Õß`û–”©ŒWÞMF÷ bÙŸ}’ìýȪټ|ëÁÄ°˜xý×1!îÞJËš'¨¯n?xeÚAêԥ䟆5Qun eíŸi¬é±Nâhrf, -¿kŠ£¡kä]ó}v•7€í,Æ\y¶ýë7þ’¯|è FOš§QvÕWHÜv7[?ªêÊ;I8Î}ŒQYÿbûóÏâ ÐÈ(@ÈYC ‹OZÒlF\ôEÒ Ih@ÜWAǦ?Q»£š˜ÒYï©‹cÄ $çgAã¯Ø·i-]ãÉ=xª\5æÚ‹·Ñå8kšsÙUO\ÁÖkôÕ—Žz×ÝêU„@Sˆ´S/ÆÖðì!W™ôÖ…!ã³”ž{ö qïn:‚ØFN"1º—–¿ vŸ³+=;)®¢`âllI&T°†Î-aßæ D÷'8¡€ÌÙדW6³!F¤£0˜k”1O
¾V'°o‡‰ä˯!3ßAÛΔž¾¬Ùq̹™‚âX’»ò so¥mí ©«jíÊ“Žu4=uªg_ †t S¿@Á¸éX-¨ áÎ
œk~MmgèڪŸd.¦ìŠ›IJN@ùöжþIjwÕ2 \OûéçÄD´q5~®&-'…fwg÷ßmØFƒóEÜ8Äiúç-4Ç£Ýå^ŽÇŸ‡cá, v3í¾à Ö—uæk õu´“hzó5„}Y!„ýÅf’gßÁð‘M4}ø:;ý˜%%Fh ÷~óÉ(Í °e
A§‘6ç¥äŒ*¤®µRÿà-ZEݫߢ9s£çMÄýÞƒ4vt]U¡ÖCÞ
4¬YK0šBÊ„kvî„Ÿ¿w °a?õ^JÇÆèXûkêœI£?Oþù÷’ðæì«÷urÆ“5n:ìz–}kꈄch‰v ζ®ÁT`-•/îÁhH#ýœï0l°iî ½Š 'a^SE0˜†áÈ6kØHhˆ/¨Pí ÿž6_'1ÍŽì*†ŸöMâíß ¦9¬¯ÞRÇ*î%Ðá…óHO/§¥#¨/Ÿ®ij¸œ’’YX6ÖÐS_zê]·ÆwúÍ ó.;·º\ZR )) 4¾ýüÅ_¥dL€¦e ùUŠÏø, õOáZHžye"´y”ºV?¦¼Íü6¥¡;ص£¥9HûÌÝ»i_û .–‚³ÉO ‚öõŒ¦<ªY°äÇ_Fõ;›kiØ'\Mî9_'ò½4¹¢ºÖQzêTϾH"å”{5N£óãßQ×âÛT†æ|ì©V´Z¾º×ÓVuöþûéþü…ðmý
®–‘K(8ónL¡;¨¬vé¬ íGO;ðm¦Ãy
y%%˜ö¬ï:!`.&='`ù&\(?hm™iÃïœ}Yo¾t××Ñö¥«= ¿¾,„BHPÜÇŸM¶$Õá©ÛŽ7*ñb†´ÓH·ÕÒTÓŠCgE#ãOú¶²×+h½ q53{QD‰º8ûlx6оw1ÀãL"õòkÈf§ÅíDKžCþØt‚ë¿CÕæ:યEKÿ1y3fÓØð ] ¨|ŸŽú^·q?áN?BD¢Çfå½»N?…Ô”×irÅÐ’ÇcOŠàªD€9–Ò¥Ïôø
µÏßMóþ[ÿb-¸ö¶ øÔ׎ÒÛIÉMGknBéª÷ÔE¿R¹ZvÀ"àYõ0µ _eø¥¿&{ßû´l[F[}K?'T‚„Ú;!'Ÿ"zêKG½èÄvÖïeÂŒE¤ì~úÈx?uÑݘñ·ìƪˆIÁß¼WtÃK‡“˜ áKœCÁÄ Üÿùûöt_9n®ƒaQ2næ]ï¶ÍaØ5÷RÝý,¿«1@ê¸ÛŽáÙ
ƒu8i3“¬öR[ë ø ¾í8kÊ»úi‡ûåKI æ ÙÕ㎣ @ e;Øf‘?.ƒÐ¦»Ø»q_÷ÕíDŸ9€å£§êì;ýöÓnoP·¥ûjbÝ>È|˜‚©³0×¼‹ž;¶5[ÿí'¤çÌe¼ÎÊF
&Í!ɼ w i³±››iÙ×ÒkÛ08΢øô „·ÝO«+vböe½ùÒ[_GÝWÿùÒ’G_B!ÄQ‚b?îÕÆyÁõŒºzþª•´ïþ7mµõºoë’€¥d í¯Óéëø„ö}DpæY¤§>‡¯-r\3§‚„¢`±ÙÐpbpŒÃJ'íu=4͸ê;É+ K¢é=‘O²øcDö-ÇsÚ—È(Ê¢¹¼…„œéXâ{hh ÌäE‡=S¬BDzLð£YÇ‘3û2²
‹H´hÄ ›LC\ïzyqþçg4vD4GëäÛ‘×s\[Ió»·Óæ˜@ÆØsÉžÿsò[_¥bÙßñã'p׊Þó mSî"ôÛÔ >Àí·.z6dÝÓî(CuÏK«9&`Õ0žõ(ÓÏ:¼ Ãd€¨} :ikê`(ªÐvæ£Ì8sÝì ñíÇhqE‡¤Ÿ&٬ǴÎ`ö¥9&`ÅMGM#ÇÜš†¨¨m hníx;aT‰FA±Žö£+(&J¨j%ÁóIÏ°ànŒc-™‚ɽçmCØ1Ÿ’‹®ÂZÿ8;×ì<ŸÕ—¯AÕ×`N0q_B!D¿A1Ä;ߣòùI*:ŒÒ3È;ÿò[_§âípë àsH-ÎD³_ˤ/^{èШ(—º¶Z
¥@3ŽÃl›±®mk‡Ê†.ê ‚M6ÑR¦dÌ)X¶-ÇRR„jyOp0?Ê3ņ ²Ï¿“ûVý —ÓI(<ïr†ºÞ0èŒ8÷áo;8û´ˆô`Æ\å´¬.§uÛY”.¹‘Ó7°eee U`!1#üõDâC[_Ë^M÷2aÚ|lí¯‹žùWñ#Ë^Ó44Ü´ÿë!šœ‡–›Šy GA#h‡õÁ |ü {«X&|’‘^ü =o/ l_V:ê¦uÔ :êY†&4â¨!kÚ}·U]»pÛèíŠÎà[GûÑ]ªîµ´»–SZˆ¡%JzQ¡Ý Œ ç,bô‚Ř* eÇktïÿݾÜo¾Žµ¾Ôž‡¶/ !„BGPÜõìÆ_õþª·©O»1K®`ø˜ÿ°mS£®1‰–<ô”vZ–ýœVwô@àcömFŽœBâÆZ‚q ‘ ù˜ [‰ m'“ypo¦Œ»¶`6)Ùh-]·OcÌÁ‘Ÿ
;
ø‚W„X Hp`ÔèýjjiV \›?$²p Yù͘sÀûaùп¶Ç4 {†Fhós4VÔvåÝm% åÈÁ›žz?ƺô Õ»W'82²1PÙëU&Í~
¹yFB›× ö\¶Žúâ“2áÊiŸ~'¹yFp¢.€Xý¯ØøÇî1ø!'0¶`6ÉYFB{«{
º4×6ÌÆ><Csõ1_
û 8V?FSÞ}Í™Šçýõ]“2
¤/™c«Ó¸·’03HÎMEkmÒXëð¶×ÓwØ60æv ÇœÛ=Ž©ñ8`²a8¬|ô´ ýÙ‚swùÎÀ¶'@šÖÊCo Öl§2bþb* aÇë
rûú
ùo÷åþò5ú:J]èÉW|ˆû²B!ú
Š$O¿Š´ðvÜmÍDcf̹¥$'äéÜ´‘„‚YX¢Ô4ìãà@HÕ>ÔÈÙØmoô¸pWì…S.£xF€æúv”µŒŽy™X·ï€Øè-'JBú²g\ˆÍó.»ËkM‹Žúú˜mÍ[êÉš=|€u¡£ùùÖP·u!e“îbŒåeš÷í#OÄìÈ$ZµŒNoì`›Ÿò J
/ÐÒЊJ ÓkÿX¾öÒ¸ò2/XJÞ¶mÔ4»ž‘×Ù—‡.ò<¶:UžU4Õ-¢xÖm©WpzŒ$æÍ%‰Îè;€¶zÔ¾3¶aCja€ˆ1û¸%ä:Úiýpí¡Ç1å#Øù íÅ IÆlØC[Eq íg B{ß'0ãR
gGIèx…wÏè<ÛÔ+IeÕ;›1¥?øãi#èñŸ }¹Ÿ|
¤¾ŽVzòu¼ú²B!úŠµ šûäɱvïVZ\› ¡¦RçóLZ
)#‹Àù.C®À*bí幜ôÜZ<„¶?BEÒ
Ž»‰ÒÉ ¢îÝt¸ ÀC›©]± Óœs(>ÿˆ»ñíü í{ôb><«î£"x “ÿR3Ä:7ÑøÎS4ÔæÞMOИq#¹§ÞJ¦òâßñ[:*ˆ+ i>ðÚÍFÚÖeØy³ òM\ã0ĉ7Ò²ìL§-!wî]»Ò óUÓé¼Þõäë˜!fÃ>é‹ä¦ìÝÉ^\ ?DÍþתÄ<„Ü!Ò§‹±Ó!î¯Á]ñvlø¾#^ ¦£¾†\Œàî—éœ~+©© ]üxVßËNÏL¸„£-@œ¨k MõËX×:«¾Ï ßÈ ¿”ÒIF FÔ½‹×±L&¦ˆ5¼LCëé ?å,š_{›P<¦¿/ÝY‡¾ëTW¿h§í½0žz-ÃæÜB¦#âlêºý[
q[ÕÓwô´
$ظ‹P鹌˜? ˆiû˜ú·ž¡©áðwç†ñÿÍiד}æmd+OWùT6WzÚÏ Z„÷cZÛ®bx¶ÂûÁºCo6¤bËu€yÅO;ô‹³ùÕDNо|Ô|
¨/ .ôäëxõe!„BhÈIæ£"R/fÜ¥sq½úmêÚä“Bü×ú¢ýÆ}þr"Ëofw•W
D!„✼Éá¿Éœ‹-Õ
‰¥dŸz) U¿¢¹]b!>9’Æœ-\O0DKÌ'uÒ¬‘Í44ù¥x„B!$(Ç“!}% çbV üO³k冡Ÿ`Kq”NhzÌ
IDATÃ:ìtòGb2 ÊO¨i%ûÞø΀Le$„Bñi ·O !„B!„øÔ2H!„B!„ X!„B!„ øˆ1—Œ™KÉ+pt½båDÛ—–„mü5M!g'„B!„B‚â¡TóÉœr.ii‰ü¢†1ÿZ&~ñIÆÍ(ÖWH}íË”MrÑtl–^¶¢%“<æ|²
2ŽÐ.„B!„âÇwöiëLJÝLš{7*@¸m3럥©ÖyÏð¥aL.$Ñ`&ž–zL«!íJΛ‰ó•-ø‚ÇëuKLÙsÉŸyiÃr1i1¢ÎM´¬~ŠÆºÎƒå¬%“<ñ:Š¦Ìšюµ4|Šæ&¯Ì¶&„B!„ xÈCKƒ
³ÍD`ݨª
a°‘6åjòçgþ>šÝ±´Xâ„wÿ” ¹ÄÕÄNôZ4äyÊR|ïQ·|Cé3® ï|+¡¿=H»/1—ÝJÙìøÊŸ ¢ ’'}‚ ¿FìÅŸÐê‰IoB!„BHP ìçþ†Ñ¶?³ùÕ úÞÜÄY”]}Ñ·¿Je}P÷Nbž:üí hß‹Ï›Aꥒœ’p (Ö’f3â¢/’æHBâ¾
:6ý‰Ú ÕÄ Ùq̹™‚âX’»Ö‰¹·Ò¶öÔUµ ¼Ê™P@æìëÉ+Ù#ÒÑ€ _{;ç0æÊ°íÿ¬ñ—l|ýã#ã£î 0•1âÊ»Éè¾›:û³O’½?ä®zÍË· Üæ°˜xý×1!îÞJËš'¨¯n×õ6ÞHÓ?o¡9 íþN9 Ž…³pØÍ´û‚`,${êXTícT®]MDAgKë73llík÷!oeB!„BHPLŒ¨Û陘 ÁN¢ÍHÄíD%f`ƒ7 Ä®Œ]WŠ'œJbp=µí¡Ÿ¨Pí ÿž6_'1ÍŽì*†ŸöMâíß ¦9 šKÞx¬ñeT¿³‰°–†}ÂÕäžóu"/ÜK“+
šƒ´ÏÜMq±›öµÑá2a)8›üôåKÖRùâ Œ†4ÒÏùÃzËJ¿û¢UÔ½ú-š31zÞDÜï=HcG¤;¿‡ÙÞ
4¬YK0šBÊ„kvî„Ÿ¿–\I?hm™iÃïïÚ§f-Åž þu{0Ž»‹ 3Í4¾öÎvpä—`Òö–{¨…B!„G‰8;aL&ƒFBñL<ËJíßî¦Õš‹‰Ýj›<ï·Ì˜·ÿm´-W°GkÁµ·åÀ} à(½”Üt´æ¦ƒÁžo;Κrb€§ÃŒýò¥¤sÐìj‡ä9 a#°æ^ªË»¾ãj :î¶îLêÌWÜO¸Ó†‘>bß}„‰¸ˆ™½(¢DÝ
œ}40óTVã°¦OÆšQKS¹‘¬ÑÓHjLï¾¢óÖw=SL5¾Æ
b™2bÒLÌ{ß!DÙçßI}
«~†Ë郤 žwyïWG{¹‡F¤q@ë=x L¾Žíö¿¯Á‹¡· í$èt÷‘¡8Jõˆs1zÁbL•²ãƒ5„ã=ƒíV¢X0[!î"ì´TÌ63„Z‰ÊÅB!„B Š÷PuøÃìc/$Áù:ÕÛH ³€ìÄt"õõ]“_
š†¦i@w@—0 {†Fhós4VÔvÅ¢n+á(ýŇ…©®m˜}x †æê^'X¾"Äb@‚£Æ!ŸéÙ×Á•ƒÄIÄd Ü+¡
Y_Ðuû´f;•ó“Pù;>XGä°D©@n/d—ŽÁT¹†¨,e¤e@xke×ÿ…B!„B‚b ÖŒÇe"³(›Îw7öhi]ÊÈ|
÷Ç-ž¥Ø˜< ‹ÃÁ’Eré"
²cxWmîš:ÚŒ§ e‹Éi_†ÇB³”` àË¢”w5u;.¡lÊw(5¼@KC+*q ô¸è;|)?æv˜¸€¼qn:6ÌÆÝ´íi ®g_ûcboèBÒf^J¦q Cs»ëu•£¾Û§±M½’T6P½³Sêðƒi#èñ£bµ´nÚAÎé7R2ÃLs3$OZŠƒ ìÛQ'3O !„B!$(îahlÇ6šë= 4\åëˆåáîðëTã>Â~EÚ¬{˜0 LĹ‹¶@ýΖ® 2ÞH˲G0¶„ܹwQ`ˆóUÓé +~<«¾Ï ßÈ ¿”ÒIFºfœÞE‡+8ˆ|Elz‚ÆŒÉ=õV2•ÿŽßÒQÑ@\éØ×~¡ÍÔ®XŽiÎ9ŸÄÝøvþŽö=ú‚b¢NíΣ¯cHÅ–ë ó4Š/žvèg³ùÕDTŒÐÎGØ•p ES¿Déˆ9×R÷æ“´É;Š…B!„ŸR 7Î
!„B!„øT2H!„B!„ X!„B!„ X!„B!„ X!„B!„ X!„B!„ X!„B!„ X!„B!„ X!„B!„ X!„B!„ X!„B!„ X!„B!„ X!„B!„ X!„B!„ X!„B!„8ñƒb# yçS0k>v«QJK!„B!ÄÿÓÑ? IÞ¼kȲBfb%å ì!.e&„B!„âÄѯÇZpÕ¶¢T[׿R^B!„B!þ‡h ±®B!„BˆO'™hK!„B!„ÅB!„B!„ÅB!„B!„ÅB!„B!„ÅB!„B!„ÅB!„B!„ÅB!„B!Äÿ S_±²){.ù3/ mX.&-FÔ¹‰–ÕOÑX×yðÅÆÆBò—ü˜aöC¿í}ï+ì¬ôtýGK&yâuM™…5¢ kiZùÍMÞ½ Ù”CÚô¥ä™„Å 1W9 ÿ™†½MÄL£(ºâ^R+ïa˪½]KœHÑâo“øÛ_@T*\!„B!DA±!‡ÌS–â{ºå»ˆ
HŸqyç[ ýíAÚ}ñî€7“ ‚› fo…³;È÷úöG͘Ën¥lö|åOPÑÉ“¾@Á…_#öâOhõÄô¥RK!õŒ{)ÙAËʇ©vH*ý<…gß‹9ö-öîó ù c.ÙgßFVÂÇT½ö–ÄB!„B!tÅñFšþy Íñhw [ŽÇŸ‡cá, v3í¾`w°jÁdŽiÄßáí%0-${êXTícT®]MDAgKë73llík÷×ÛÏ$¿4ï‡÷P»³
x›ë ãç Ÿy&
µo<ä RO»“áy4¾ö{Ú}1©i!„B!„Gèû™â1€†Ñ–‰‘6üþHÚA‚1JܘJ‚ùÈøZ³–bOÅ Œãîbêµ÷‘kÀÙæüLšž$j˜²¦a¥–Ž:çÁ4Å;pí©…´éØ{lHKÁ>ëNJËb´.{ˆ†–€Ô²B!„Bˆ^™tEÎŽ³(>}ám÷Óê:xÕU3'÷EI9ëA&k ¼;h]÷$uÄÍ’…‰ Þ@cf6Æ„Âø}aÈÌÂd€p¿q˜R o&ê¹rŒ¨»E.‰#tÇê £n¡4Á„çƒ;¨©q
ì¹e!„B!„ ¤a̘OÉEWaœkvÒ3,U®wØýÜ;€Cr)éÓn xîÝwP]ïë±fßÚ;)ßj â’2ñøe(Þ±Ÿc6)3¯!³ù1Za©e!„B!„½2 5 ÎYÄèK®"±úQv¼·‚PŸWuãĽ»i[õ;ieE l%Š³5â~Â^/J³`¶™!ÔJTÏÅĈzÜ`H#1ÑØãïFŒöt4Ü„‚k{“Š— ¢90•¢‹¿FVªYjY!„B!ÄÀ‚bÍv*#æ/&¡òv~°†°®±Ýœ
TàöBR阃Ï[ÊHË€p}%Q]÷6+¢ë PHz~ž 6¤“:ªœð…Ô!ë«@9µ¯?Lkx
E.Åa•×1 !„B!„8R ·O'b›z%©l zg3¦ÔáWŒ´ôøQX°M¼{¤
¿Ç‡2ç`/[L–ÕMÛ®îY¥cµ´nÚAÎé7R2ÃLs3$OZŠƒ ìÛQ§kæi åþ€úÊ…”žöu
yŽNI£.§0ËGÇ»+Æ{ ïƒåÔ¾ý I‹¯`ä[ÙúîGDäc!„B!„ýņTl¹0O£øâi‡~Öú8›_]A„DLÖ"Ò'O~’ˆiÛLãòçh<ðý¦ùduR¹Õ &gøú:`&sdÖ-ßãÜëßÆeÎ lþmüü§ï3Ý>™÷–ý§¹«>
ÕE?xUmëPJ©¸jßòŠºoA¡2ïÿÜ.øÅrµ¥Æ©‚ª‹»b™úé¥Å*qÿ:¶3ÔŸÚU¯¼/£Rº×3¤Ÿ¦nýõ+jÕî&åï_é>¼cìÁýõ—že[¤nÞ¨”ú÷"•zDÞ ÔM +¥>øœÊкÿ¦eª%Úû€šœ¨_ý¦YgÞû_ú¯wSáÕêÕN¥Zÿz©fìú›1÷Rõ|»Rµ¿;G¥PÆüÔºž‰è|ô¤yË°¿úÒ•fP¨
çGýùÃJÕïZ5æ®RïÞ5YY@r¯RÿŽ*Uû‹Êzà;uÁË>¥j®¦[†®.tçÝ\ |ÿeUÞÛŸ`U»e™úÙü,eàú·,²È"‹,²È"‹,Ç{ée@>&_}§f†z¨f†zhïDuãrÔ¸2ã!»¡ZGÏbȽF}Wj÷½ã €qPÜÿ¾ *窔R›Ô-ŦCö?â–MJ©Õ5¹†î Ø©ž]´H=Õ Tk¾V¢ŽSP¬«|´4uöok•RUêùo_®.\p¥úîKû”Rµêwg§)
¦‘êëåJ©Š_©ëž¯Î¿äzõã÷\J©êŽ2s÷v¬*wÔX5íòçT›jSÏ]>M7N7NÎK:P·æq÷¨ÝJ©Ý¸M]yñyjîgæ©ó?ûyuÑè$ýélPLªZðÏ€RÕ?QS,ú÷Õšõå}h1ƒÊ8ï÷ªVÔ¿o)S‰¦Bõ…×Ý*¾û!uJŠÖ].U4fœ7ñ\õ£]}”ž4aö[_zÒŒI\õÕ¡”j}ÿ1õÍk/Už7_}öê/©¥³Ó¤ù†ÕJ©w©±æîïYg«Ç”ê|vÞž Еw-UÍýM×ß^¾ûjµàœsÕ‚¥¨
¥Ô–o”¨ù¡‘EYd‘EYd9¹‚bŒF•uF–ºà7cÕ=ûƒÚšêûoŒTç/²©$㮣#‘–©«}ʯ^>/EÇàöp+Ô’týA±eZû2«qwïR*ü¦ºÐ~ègö ßP!µ[Ý;Þ| (þËgRUñ—>Pþ–§Õ¹©)}Ň۬¾Qš »ûO3Ê8üËjRjç=ã^õMœ¨¾¿K)õÑMªÐØ#(Š¿ª6*¥>¾©P{lÏ:ëQÕ Ô£³¬½î¯+Àô©œ›2øô "(6XsÔäÏ=¢¶Ä”ª{ìeÀ¾úK³Þ¼ëÄúi«šMMÿþfS{Ô_ _üÑMêîÉIGnïhå£'ÍCX†zÓsÔul§«'Z”Š®üª*1÷]†E_^£”Ú¢¾9ª«¯˜Ç|WíPAõ梌Cƒôc ŠõäÝXxƒZWªòGS”eÿ:ŽKÔûË"‹,²È"‹,²œðKïS0Åb´~ÐÊ[ÿ·ƒ ŽÙÂï¿ÕÌ^$MLçìŸ £À:„ëèºÁ;F¼+€ïÁ´ŸìÀSñ³“zþ}#ß5Ón;}2“'w//åéšÈ¦9iÔ<ÆÑÄ{˪íÿc¨’·–7Á¸¹Œê£.¢í»¨òƒ#ÏÎPÎ[<Øôôéôçi‹+bþ&6=¿”ÈŸobþ·Wã; û2ý´UåcýK¸mõ®¸q65?¼š‡7û_rN2LÈ?Ó²`ý þNU¸ï~U÷ÚoX›ÀÒKŠIÀHöiS]Å_V9‡°ÿêË»uÔ9LÐZXþÆîøv!„BÑ›£N´e.LaÒç2™}yEÝ3³ªºØЯs4á¦mÔ«$ÆÎ,À¼l]ãd
£ÕN²ÝzX°æ¢bÓzÖ»W áæ4’Ęiy$,ÛE¤—Áx{U+$äQ’nwô@Q¦—äc¦…½íÑC¿âû˜Ÿý`-7|ÿ6fnìm¯nª¶–S~ÜÒ¼Ÿ†vø_´~#n¢qÐ G~÷Ø
&=}ØümÎZú~'ûêq†ÕñÛ×é¿&œÅ‚ FT Ê®º–鿸ƒ•îÃò¦zæò|’ex´4«®S`ñØÑCÛXÓ›üê-?/Ýx£ û-ã/ŸJ|õ—YÑv“nè5HìXû*[™Èåçå <«`*dÁÕ“`Û?YÓ ?"®yþ{<£]É·æÙ‡<¸ì?Íàßó ÛÉaÞy#¾'±„ùgçÂö÷ÙØ>UÈKY)ƒ›À|@é‰GD€¤4’úª~O5[Ë·°}OÝÁ܉–wÝaXò ¾÷òo9sÓmL™ôe–çßÎK¿¼€Là ÂRrH1 Cš‡ª õÔ×QÒ i\Íš6˜vý%% µáóÎCÏÐ<úKÜ|ι|áøðñ·iŒ
m=èÉ{°f-ûÆ§å‘ ¿+B!„'•^GÈ1œ´‰ ÐæcãŸ[Xù×jZÔqYG—h
ÏÜr?_Ywo®°pσϱ¦ÞÄŒ±ö^V¶3bÂ$&õ|ŸQ´“½;kðê¹€æé¯ÞÏkîæÕiÜÿ“¿²ª6BjÉlÎÌ_Á½÷¼K[ÅÓ|ï¹oóÊ£ÿàñ»øÛN#“—>È#³œ<¿è)*z»TëùˆŸþb7=ð}®»M¦|FÛWóøÓÛÑcÆô¤ç@ðÓÉÎ-pÃ×¹óºv–¹3ž°Š?þu§®[U´¯O ïºÚªrpæ/qÏðW¹|ü£”7Àµ7\ÈŽ¿þ™_½:Ž«_m9øŠ¯x'ÛVÕÂ7îྯ´òrs*Å–U<þ— Êç„«¯£¥Ù»š ~÷ .{üw¬}w?yò]¶519ò)JXÉ zlÇ»æürëMüøϿøbY3ƒ»N|”ºÐ‘wUù,-»‡§ z™ßÄ~È+Õ ”̽‘i@üÎ!„Bœðz™mÕ ÒÆ%*ËÑ&ªut/•6ó&õÛ÷ö(W÷´D‘ŽJµòKÕHóÑ&/RJ…ÞPØu¾’©ûsÇÔëÕ¯–íTíÑ®M„›7©—ï_¨òM]ëhIeêÊ_.Wž®Ï=ËÕ/¯,SIÚþ¡÷O´•|ðî¬ÅêU¯Rj¨_ɤ3͘ ÕÂûßP;» °sÇëêþ…ÃÎXÝËD[¤œ^ð(Uñƒ 'êžplÄå¿V+ë»_ÞiQë ;_e0iUéé9“yÞÅê—+UT)¥¢jýoæ«LC_3'n_z'Úê/ï z¢ýmUS)§üBU«õü¢œƒœ™†«ëß *Uÿ[u¦];t2¨¬sÔýÿªQ!¥”Šµ©
¿¹ «|ô¤yË°ßúÒ›fͪF.¼[ýõ£jå9ð©ZõÑcª,áí>óâ•K)Õù·ù*UªIÏ;nèÈ»!mŽúú³TKL)¥ÂªaË6åUJm¾uäÁW·É"‹,²È"‹,²ÈrÂ- Á !NZæ±ßecù¼9g w¬œ0é2•ÜƆŠ‡hY’˹o—B!Ä Ê$E „8Ù죘1Ö!}6_ùÕ}dÿý2~ºé¿'3õƯ0ǽ]^ ãYøÍ 2ÑûŸ_Ù)±B!„ÅB1t’&ßÁ‹+ndx¼
Ï|•³o~•æØ1A¦tÆæ~pÙD2Í@ÜEåÏò•¹ß楦˜T˜B!Ä LnŸB!„Bñ©e"B!„B!A±B!„B!A±B!„Bñé mõY2Ù$碚7â ÆË.4ÛYŒ¹òlûÿÐøK6¾þ1±OAÞ…B!„âŠ
˜²ç’?óÒ†åbÒbD›hYýu=^/b,$Éf?ôÛÞ÷¾ÂÎJOwä—LòÄë(š2 k"D;ÖÒ´ò)š›¼œáKÃ2•ÜYŸ%«h$ ÆQ÷nœ[þFÝŽJbC<]˜!íJΛ‰ó•-ø‚áãRø*°Ž½/íÅ`L#cÞ äöšm;ió~Àˆ‘™.ëÇ<{èÜþu[w91ëä=a8™s®#oÔ(ÌÆ8Ñöiúè)š=ë]OÛÐÓÆö·Ô3(¾ð&ìu? |Ån$œB!„B .(6äyÊR|ïQ·|Cé3® ï|+¡¿=H»¯;ÜÐ1™ ¸ùaöV8»™8q¯oDƒ¹ìVÊfÀWþM<é \ø5b/þ„Vþk¢šc ¥‹¯Ã ø˜ÆU¯áõHÈOŠÕxòΟ ÷rúÀà' í»ŠLöL /²{E91C2–‚ (œ}I ßeÇúš/øÓì¤~æ{o¤iÅpz“±O¾Ž‚ßD½øCš]Qým£ß6še$é“.%òdÌ@TúµB!„☂âx#Mÿ¼…æx´;)ÇãÏñp»™v_p4‚É #ÒZ‰¿Ã{ävŒ…dO ‹ª}ŒÊµ«‰(èl‰`½âf†- }í>}–Jú©Wc®¤â•ßÑ쎂kÖÒvH0ŸAêԥ䟆5Qun eíŸi¬iïʇfÇ1çf
ŠG`INBbî´ý#uU]ë˜ÊqåÝd$vm2û³O’½¿Xª dóò]·7'Ž&gÆÒòK±¦80 üx×|Ÿ]å
]Ûê/=nK§]Ú IDATÂßZEð5WÏyŒ’Qs°lªÁ Ó¹¯þÒ¬7ïý±Œ'§8‰àÇ¿£¾¢øœ’®ø&9ã
iý¨Š¸Þ¶Ñ_#ëÄ/QPPGË¿ Ã|ÊWI“~-„B!„8¦ à@@ a´eb¤
¿?ÒãÛŒQbÆTÌA"‡]îÔ¬¥Ø“Á¿nÆqw1a¦™Æ× ÃÙŽüLÚ>Âz¢C˲
®ÿ'®`__°a?õ^JÇÆèXûkêœI£?Oþù÷’ðæì«÷fÁ’7 k|Õïl"¬¥aŸp5¹ç|È ÷ÒäŠB´ŠºW¿Esæ"FÏ›ˆû½iìèʳ
µ
µ¤ñd›»žeßš:"áZ¢ ƒ³»Üt¤gÐbÄcqÐ úó®'Í:óÞï9 cF
bþÀÁ6®Åí‚´ì|ŒT¡ô¶~ÚDð¯û›×)0 pŽtj!„B!ÄPÅ=þ¿½;
«ºó<þ½·vUI¥½¬ÝF²eÉ–Á6f³ÙlC @È$@“ÉBÒÉ4 t†žÐ Ù¦!'y !éŒÓ!Ét<1¦Íb,;Ë’-K–-k/I%Õ^uëÞ;/$[²-É%°Ãâÿçyêá‘êÖ¹çœ{å‡_sÏñ®föE I¾ûþ‘ñh¤Ø=‘™« æ\Ìp3þOÓÙÚƒ(Î¬Ä Ç4,ù…Xl6 ¶$ÑHò °ª<:KÖêBµŒ…<ÓÀÔbc‰Ju—a'I´`ÊVų’’š\â»î£½¡é:‚’û}Š— §{ ÇžŽ4è؃„†ìd}v¹E^úF1I¢t£ÛؤH»‰¦z®6I¬íU†ºâï>ïeÚ·ÕKFùu”–ÙH6ï"®Ïô\S×™4Ú®l îú+±MV·ø«ìÛøáXÁÌZ´ž¬®ßŒèXFº†)®ªÁaÝr,€OdÆ{H¤ Ãí: ›V}´8ë λûž± ¢D[žâ@}+`9Ý皆x–?¼†¢Lò¦ $®æaz^ù?8¯¸™y·\sôÍÑþ>2t¢hÓßéßcB!„BqZC±‚Åwó®¹kÛc4¿^OrÊ€
Œp ÛžÄ]þ ¹Õtt5aÆý¤pbw9À!”lìn;$ü¤Œñ`Ýýö °£ ˜I’Cã#”F¬
;®ü ”Ξi±ò ºÀ<ƒÊé+jð7ìßÚ@*!
æ™;×tRÃÄÁ)ºÒÀ4GûT÷¿LëÆMXÜyXÕ$ºõ"ªoú,fG×èoÚ÷Æô÷˜¬0-„B!„8#¡Xq¯bκ±µ=Jóë;ÓÛúçØ3®c)ÖJ0 …Uó±¶Õ“2g59yllýy,˜êÃ-„†§(7ÞÌߤ|ÁÕd6?M0qrŠ5Fšˆ±‚ÌÒB”þÑ)ÄX|xK²a¸™Dj†¹ÑˆcàÀjWßSǦUŸcÍ×1 ÀêFU˜|{)ÍOlðȤ++Ïè\ï³íjÁm§ž>}ì|:z¤ ÝZLáU7àJþ•¶ö±)ðißÓßcB!„BqB±÷â[ÈæmíëÚ]>~ 6@<Åĉ»î“diíDCL»¬ê)pØ?¶r°~ÿîf|ÝMå2;}}àY´/Í nîL”Ï`àÍçÉ¿þzæ}ÒMwÃ6 kV%žŒ}tïj$ÞNgó'©^úß9ÇxŽÁ€ŠkÞ§)öá¹~ô™Ú„b#ÜJ,u-9Ë?E¾e/ššƒÓÞŠ¿¥+z›éÔçØÁâƒA¨^GѼ0A̓]=À@k÷é?×ûm{:Ó§QPÝ¥¸¼¸
êȽ‚,÷úþý)†cc•IëÞHã °xqz½(–"lPœ³påÆÑ}Ä# ù+B!„BÌ0«Ù¸gyÁ¾„Ù×-9þ=ÿ4<ÿ¬®
r¥$Ãhh
ôlÞHϱg=uû e¿í*žªó@ì ó姘Á Å`bøÏþ?ø)Yñ
/þ;Š0c Œìk
hf„ж¤5~¥ç~‘*;èûéÙô ÝïåÙÓDG^ÛŒuåÌ^» Œ ‘}¿`ð@FZ!s&õIÙõ/ôåÜIá%_£Ð mþ9CmÝi~qð7l{*@l0pŠl¸Î½—šY¤‚‡ z–ý{þƒPdâu÷†’Î=jÎ'˜wÃzìGQñ_©© ½í{4l‘)ÖB!„Bˆ©)ÈÒ½B!„B!ÎRò€¦B!„B ÅB!„B!„„b!„B!„BB±B!„B!¡X!„B!„P,„B!„B|œX€ïœ]MV°”ÜÎÂÿôò-
vO¾'•µOÙ|l‰>´Ô™ÙµJq¯¦æö‡˜½ôFŠ—ÞHqq}-Ý“Ô'Í:d9q¯xˆEë®ÂÚóÁpêÌœæopM…B!„ -ÖÉb-\CÉòõäͪ褻éßþ =™¥Œ’›¾OQÖñŸoùûÚBcy΃§î*Î; —RC;è}óúzÃ3vì ¾Ë¢Uå'½£·}†-M3 Åž2 ª #'eŠ£ÔœõT^µœÀ ÷‰'O("‹œËþ'sÎÉ?6Ô®‡0Üô[:›ÑÒ¬ŒÛÉÁß DµäwÙ½ÌzŸuþè²aÏñ¡¨*.· ˆ‘³L{MgøÅŠêÛœ»ÆÆáßÆ 6>àr„B!„§7«>ò/¸‰ÌÈ:7ïGSKÉ]v3Åk]$~ó0ƒ‘±ÿyW Xoø[c!×ÀGÆÃlõW©^1‡Èž'iíÏ¢Û(½ú+èÏý HŸauqä…'j‚e¢™E ƒdËi š…8„þ »Íš•:ô -¯íAW=8K×S¶â[dØþæ] éÕɈD@’Lé:˜…¼ò
š³â# ê?{ɬƒ$¢¤4ɤ‚5w!®Ä>B‘Ô߸ !„B!Ä™ ÅF½º‡>#5t÷Šã½ö|¼Yv#ñ±PìÄj×ÑümD‡Â'—c)£pq
æ‘ÇiÛ± Í„á~
×Í_¢¨¦”Á ‡ghc$ Ä&äSÜRyÓð y”w_݉f‚âZÎœOÏÁ‡iz³=c5óo¹ ÷Ñõ<Â;/þõøifÎ-çý±ðú§)<Ú-íÓ°¹qüød/Q;) ÒwÃ÷8•sWâÜÝATÔ<²o dÁ\“Tàmúwü’žŽÁ´GÉwu>´ÊÖS²x
Ù¾B, šŸ`Ã?ÓúN†ëBªoýŽw ñö±~ÏÀ{åãÌ-x…¦ûõhÓᘇoÙ5ä”TáÊôbQ¢„ë¿Ãþ=cÓ¿Õ,2ÞJiÝ
ÜVÌxÃ{Åá†fŽÍ\v®bþþ"ž‰ewý„w^~g¼}é”sª¶ÏäšNû×RŽïÒ{ñ¹ƒ„wcêV
Ö=Æ\_ÉƉý
(^²/ù•s†6‡C‡&Ì°˜I9B!„Bˆ Ä
w>ˆF' ÓZ½Ø,)tK66{ í„áNÅUE–¢;`©ý —Ûéyáqƒà-©Äª &yš í4#Û8ôJ5µë¿È9}ÿ@Ks’ÜK>Onü%öÕ¿; b;h{î 5‡Ü+î£h²‚Rít>ÿ
úòo`Þeu·„dÅËVÐÓ½%½/Ò©³µŠâ –aé{–Æ—ÿBb²TeŽliƒ‹. ;óEzGtϲ24Âí è€Z°ºë¯Ä6Ù9⯲oãSŒ¯•$Öö*C]ñ“C³{%¥uy·~ÃƦÕ÷uBÑãTÖ.Á¾Óh Í8Éá®±›L;©}i•£¦Ñö÷rM§ú’"Gu…¹mtí4(ZržCï4NÐÝ[~…^ªÜ{𤠛v9B!„Bˆ2+XòÖQù‰[qu=Á¾ú}Ǫ™#›hÙ¸ PQ=Uä.¹‹Ùk @ÝË¡ãFB“DvÜÏžF-œ"³îÄó8ð\ôÕsN3ð§¯r¨7qÂq‡8òâS„ŽV›QÇe›Ñw~JGé)Ÿï#¾ë>ú“g®÷fÝÃywß3öC”hËS ¨oÅ ,ÞZ\ 3ØÙ?>B¨÷1Ò5LqU
ë’Úé©†âž‹Ç ÑúS„B íðfB~ž¼Šúöôcó-Åi »oôZhùÃk(“䥉§9¤ªxâRlXV?ÆÒÕ'¼-ª2M=gVN2¶ŸFöÙäU•’lü'úu”ªo“[9›¾¾¦Fœu´îMtv¿ßr„B!„ P(V°øn`Þ57bm{Œæ×ëIN: Œp ÛžÄ]þ ¹Õtt5aÆý¤pbw9À!”lìn;$ü¤ŒñÐ Ýýö °®¬l&IMfc$Û‰&§ ˆ5dç¨`‚³ê27>qHötíÆ3øöom •Š ÐOÚ>ëD›Ó¿i˜Ó7ÌŒí¦ÿH’Êùà|w3ÎÊ
Ìþ§ ÅÇ>—& NñaãTÅ·ZQP2øÊé
ŸüM=|ŠEÅfZNzm?m’Ítüþ˨Ä1 …žçï¡G‹Íü–:]å!„B!ÎL(VÜ«˜³îFlmÒüúÎô¶:ö<íÑÖJ0 …Uó±¶Õ>×ë¬&'’mJ2ч[
¿ÏÖØæPtÕ xÿ•wßHRvýT^ÐÄ»¯íæømi5t °y±( O–DŒ8¬vuêói~bƒG˜,ã#MÄXAfi!Jÿèôi,>¼%Ù0ÜL"u\ÂÃ0 «uªúLSg3ÚJ$yÕKq´m™zÄÔ 1ÒðÚµ—QPÒ‡Ýá7öptv¹ZpÛ ¦OOÍn$Æ
<½çgdÓ*'ݶ§{MÓªX|¬.&¦6ÕöQlÅWà+Uîý Á˜þ ËB!„BœIà;'ÿÚgÅßSšÛÄ‘í;Ñí^l®±—UCOj€wݧÈÏucqdãȯ£`ùíøò’ mŽ@H3DBŸ¯îr@çÖ—‰¤½Ê–Š¥ð2|eV" Ž õqZ11L2È\ù-æ5ÑþâFB¡CCø–Å9ð‘‰S±
”œ‹)˜S…%>™óÈÊO
©3
'Y .&;׆U°åÌ'»0El0„©¸pÏ_O¶±ƒÞ–®ÉÃZ²ŸDÆ…ÌZ´—ÂtT³ìnJfÅño}–¡‰ûJa ¬!¿¼ 52ŒâGVžv\}¦³1L,YIÁ‚uäeiÁ’Q€+¿†¬¼ÚíC™s EsàTеíbcA×Lvl‹}¯â?ñµ¿Xlt$SqÕPX[MêÀKB“¤dŸ„c¾º«ðfŠ[V9™åçb¶Ÿìº+n<5kñ¦Þ¢÷@ïh}Ó)g&mŸîšžö¯›ª(»ö+øJáµï¡¿cHF…B!„øÈ„b5Ÿœå×áõ‘]}9…µ^¾ üûc(n2*.Ç·p ¾ÚÕ䳇ÖLÿ¶Çéê8ºg±‰>ø!ˆÜEŸÄW½ Wêmº_ùþ¡Ä ªy4Wà=±>ó‹7¾E*ÿ3Ì»¸’‘-?¢Ç LŒ‘R³®¦hž›Ðþ†c‹zAj ¥`…µkÈ›3[¬‰¡Î { ë~"!îs.£°æòæÌÅk"ÐÙ‡A¡dç¢J%yu×R8onZèÛú'îÅ«£
ô`ñ¤pÁõ™¶Î&úÀN†4 Å+)Xp9ùs/$·|6ÖD ÎÞñrÌ0ñH)Õ³1Ûÿ7 úÆÚ'F‹NòŠOí=e(F#Ùµ`"‡ÌÊËñÕ\J^Õùx2!~¸žpÌH/§UÎ Ú>í5=ÍL %ç|rrc ï~™áá¸ük#„B!ć2€uÖ]ôìë¨ýÔFžÿ&ÉG¥,¥ßô0³g°o°B!„B¼OV邳„}îl8ª(\õ)lí?=³+sŸ:c?çÓø²z BX
×âËÒïê”}z…B!„ŠÅé¥æ^Cåµk°›!¢Ï²ÿÍ·-°õAÝzÖ¬"²^…ÏeÍOhÏOi?8,S„B!„32}Z!„B!ÄYK•.B!„B!¡X!„B!„P,ÄÄ2‹¼å(.õ¢Ho!„B!$Ÿ%¬…x*–âvNu9,%·S÷_ž¦vÙìÎE;e»N Å%äŸw%99ŽG}„B!„ ÿ86UV¶®¡dùzrŠfaUtRÝôo†žÎ «[Ê(¹éûe ÿéð–/°¯-4–ç