def __init__(self, rate): super(ConnectionTracker, self).__init__(rate) self._connections = [] self._start_times = {} # connection => (unix_timestamp, is_legacy) self._custom_resolver = None self._is_first_run = True # Number of times in a row we've either failed with our current resolver or # concluded that our rate is too low. self._failure_count = 0 self._rate_too_low_count = 0 # If 'DisableDebuggerAttachment 0' is set we can do normal connection # resolution. Otherwise connection resolution by inference is the only game # in town. self._resolvers = [] if tor_controller().get_conf('DisableDebuggerAttachment', None) == '0': self._resolvers = connection.system_resolvers() if stem.util.proc.is_available(): self._resolvers = [CustomResolver.INFERENCE] + self._resolvers stem.util.log.info('Operating System: %s, Connection Resolvers: %s' % (os.uname()[0], ', '.join(self._resolvers)))
def __init__(self, rate): super(ConnectionTracker, self).__init__(rate) self._connections = [] self._start_times = {} # connection => (unix_timestamp, is_legacy) self._custom_resolver = None self._is_first_run = True # Number of times in a row we've either failed with our current resolver or # concluded that our rate is too low. self._failure_count = 0 self._rate_too_low_count = 0 # If 'DisableDebuggerAttachment 0' is set we can do normal connection # resolution. Otherwise connection resolution by inference is the only game # in town. self._resolvers = [CustomResolver.INFERENCE ] if stem.util.proc.is_available() else [] if tor_controller().get_conf('DisableDebuggerAttachment', None) == '0': self._resolvers = self._resolvers + connection.system_resolvers() elif not self._resolvers: stem.util.log.notice( "Tor connection information is unavailable. This is fine, but if you would like to have it please see https://nyx.torproject.org/#no_connections" ) stem.util.log.info('Operating System: %s, Connection Resolvers: %s' % (os.uname()[0], ', '.join(self._resolvers)))
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 __init__(self, rate): super(ConnectionTracker, self).__init__(rate) self._connections = [] self._start_times = {} # connection => (unix_timestamp, is_legacy) self._resolvers = connection.system_resolvers() self._custom_resolver = None self._is_first_run = True # Number of times in a row we've either failed with our current resolver or # concluded that our rate is too low. self._failure_count = 0 self._rate_too_low_count = 0
def get_entry_ip(): resolvers = system_resolvers() # check avaiable resolvers tor_pids = pid_by_name('tor', multiple=True) # gets tor's PID if len(resolvers) > 0 and len(tor_pids) > 0: picked_resolver = resolvers[0] # getting the first one try: process_pid = tor_pids[0] # getting the first, if we are running tor only as a service it must have just one PID cons = get_connections(picked_resolver, process_pid, process_name='tor') return cons except ValueError, IOError: print "Error getting connections to entry point"
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 self.fail('Unable to find localhost connection with %s:\n%s' % (resolver, '\n'.join(connections)))
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 self.fail('Unable to find localhost connection with %s:\n%s' % (resolver, '\n'.join(connections)))
def __init__(self, rate): super(ConnectionTracker, self).__init__(rate) self._connections = [] self._start_times = {} # connection => (unix_timestamp, is_legacy) self._custom_resolver = None self._is_first_run = True # Number of times in a row we've either failed with our current resolver or # concluded that our rate is too low. self._failure_count = 0 self._rate_too_low_count = 0 # If 'DisableDebuggerAttachment 0' is set we can do normal connection # resolution. Otherwise connection resolution by inference is the only game # in town. if tor_controller().get_conf('DisableDebuggerAttachment', None) == '0': self._resolvers = connection.system_resolvers() else: self._resolvers = [CustomResolver.INFERENCE] log.info('tracker.available_resolvers', os = os.uname()[0], resolvers = ', '.join(self._resolvers))
import sys from stem.util.connection import get_connections, system_resolvers from stem.util.system import pid_by_name resolvers = system_resolvers() if not resolvers: print("Stem doesn't support any connection resolvers on our platform.") sys.exit(1) picked_resolver = resolvers[0] # lets just opt for the first print("Our platform supports connection resolution via: %s (picked %s)" % (', '.join(resolvers), picked_resolver)) tor_pids = pid_by_name('tor', multiple = True) if not tor_pids: print("Unable to get tor's pid. Is it running?") sys.exit(1) elif len(tor_pids) > 1: print("You're running %i instances of tor, picking the one with pid %i" % (len(tor_pids), tor_pids[0])) else: print("Tor is running with pid %i" % tor_pids[0]) print("\nConnections:\n") for conn in get_connections(picked_resolver, process_pid = tor_pids[0], process_name = 'tor'): print(" %s:%s => %s:%s" % (conn.local_address, conn.local_port, conn.remote_address, conn.remote_port))
import sys from stem.util.connection import get_connections, system_resolvers from stem.util.system import pid_by_name resolvers = system_resolvers() if not resolvers: print("Stem doesn't support any connection resolvers on our platform.") sys.exit(1) picked_resolver = resolvers[0] # lets just opt for the first print('Our platform supports connection resolution via: %s (picked %s)' % (', '.join(resolvers), picked_resolver)) tor_pids = pid_by_name('tor', multiple=True) if not tor_pids: print("Unable to get tor's pid. Is it running?") sys.exit(1) elif len(tor_pids) > 1: print("You're running %i instances of tor, picking the one with pid %i" % (len(tor_pids), tor_pids[0])) else: print('Tor is running with pid %i' % tor_pids[0]) print('\nConnections:\n') for conn in get_connections(picked_resolver, process_pid=tor_pids[0], process_name='tor'):