September 2013 - tor-commits - lists.torproject.org

[torbutton/master] Bump version and changelog for startpage search fix.
by mikeperry＠torproject.org 23 Sep '13

23 Sep '13

commit 67aee468746e6e79865b200ca81591bfd1956285 Author: Mike Perry <mikeperry-git(a)torproject.org> Date: Mon Sep 23 13:02:20 2013 -0700 Bump version and changelog for startpage search fix. --- src/CHANGELOG | 4 ++++ src/install.rdf | 2 +- 2 files changed, 5 insertions(+), 1 deletion(-) diff --git a/src/CHANGELOG b/src/CHANGELOG index 20557d6..a9eeff6 100644 --- a/src/CHANGELOG +++ b/src/CHANGELOG @@ -1,3 +1,7 @@ +1.6.2.1: + 23 Sep 2013: + * Bug 8839: Switch about:tor … [View More]

1 0

[translation/whisperback_completed] Update translations for whisperback_completed
by translation＠torproject.org 23 Sep '13

23 Sep '13

commit 095398c2981a94dcb2fd25436be69e742ccde034 Author: Translation commit bot <translation(a)torproject.org> Date: Mon Sep 23 17:15:50 2013 +0000 Update translations for whisperback_completed --- pt_BR/pt_BR.po | 13 +++++++------ 1 file changed, 7 insertions(+), 6 deletions(-) diff --git a/pt_BR/pt_BR.po b/pt_BR/pt_BR.po index f8ee596..b79887e 100644 --- a/pt_BR/pt_BR.po +++ b/pt_BR/pt_BR.po @@ -6,14 +6,15 @@ # Augustine <evandro(a)geocities.com>, 2013 # bruuh <… [View More]

1 0

[translation/whisperback] Update translations for whisperback
by translation＠torproject.org 23 Sep '13

23 Sep '13

commit 8abbaca291cd9d18dc538c9d114160cb75d7092c Author: Translation commit bot <translation(a)torproject.org> Date: Mon Sep 23 17:15:47 2013 +0000 Update translations for whisperback --- pt_BR/pt_BR.po | 13 +++++++------ 1 file changed, 7 insertions(+), 6 deletions(-) diff --git a/pt_BR/pt_BR.po b/pt_BR/pt_BR.po index f8ee596..b79887e 100644 --- a/pt_BR/pt_BR.po +++ b/pt_BR/pt_BR.po @@ -6,14 +6,15 @@ # Augustine <evandro(a)geocities.com>, 2013 # bruuh <bruuh(a)… [View More]

1 0

[translation/torbirdy_completed] Update translations for torbirdy_completed
by translation＠torproject.org 23 Sep '13

23 Sep '13

commit 1d2e4083394d2e729057099c657560d63090f761 Author: Translation commit bot <translation(a)torproject.org> Date: Mon Sep 23 14:16:09 2013 +0000 Update translations for torbirdy_completed --- lv/torbirdy.dtd | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/lv/torbirdy.dtd b/lv/torbirdy.dtd index 7aa0eb3..1779d58 100644 --- a/lv/torbirdy.dtd +++ b/lv/torbirdy.dtd @@ -35,7 +35,7 @@ <!ENTITY torbirdy.prefs.global "Globāls"> <!ENTITY torbirdy.prefs.… [View More]

1 0

[translation/torbirdy] Update translations for torbirdy
by translation＠torproject.org 23 Sep '13

23 Sep '13

commit 9e1bbfcf6de6e433f0496e39477591be7f61ac22 Author: Translation commit bot <translation(a)torproject.org> Date: Mon Sep 23 14:16:03 2013 +0000 Update translations for torbirdy --- lv/torbirdy.dtd | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/lv/torbirdy.dtd b/lv/torbirdy.dtd index 886b638..1779d58 100644 --- a/lv/torbirdy.dtd +++ b/lv/torbirdy.dtd @@ -35,7 +35,7 @@ <!ENTITY torbirdy.prefs.global "Globāls"> <!ENTITY torbirdy.prefs.imap.label "… [View More]

1 0

[metrics-db/master] Warn if we cannot recognize a bridge descriptor line.
by karsten＠torproject.org 23 Sep '13

23 Sep '13

commit 58d76ef7f21fe67a9d60cabbf641054b7d481495 Author: Karsten Loesing <karsten.loesing(a)gmx.net> Date: Mon Sep 23 11:35:17 2013 +0200 Warn if we cannot recognize a bridge descriptor line. --- .../torproject/ernie/db/bridgedescs/SanitizedBridgesWriter.java | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/src/org/torproject/ernie/db/bridgedescs/SanitizedBridgesWriter.java b/src/org/torproject/ernie/db/bridgedescs/SanitizedBridgesWriter.java index … [View More]

1 0

[arm/master] Using stem's connection resolution
by atagar＠torproject.org 23 Sep '13

23 Sep '13

commit 7a5131d401a3981e16dc5c6056afbb0067ef36bb Author: Damian Johnson <atagar(a)torproject.org> Date: Mon Sep 23 00:10:07 2013 -0700 Using stem's connection resolution Dropping use of our connection resolvers in favor of stem's. Unfortunately there's still quite a bit more work needed to get rid of this module... --- arm/logPanel.py | 4 +- arm/util/connections.py | 205 +++-------------------------------------------- 2 files changed, 10 insertions(+), … [View More]199 deletions(-) diff --git a/arm/logPanel.py b/arm/logPanel.py index 101a7e8..b5ee962 100644 --- a/arm/logPanel.py +++ b/arm/logPanel.py @@ -566,9 +566,7 @@ class LogPanel(panel.Panel, threading.Thread, logging.Handler): stem_logger.addHandler(self) def emit(self, record): - if record.levelname == "ERROR": - record.levelname = "ERR" - elif record.levelname == "WARNING": + if record.levelname == "WARNING": record.levelname = "WARN" eventColor = RUNLEVEL_EVENT_COLOR[record.levelname] diff --git a/arm/util/connections.py b/arm/util/connections.py index bdb3c3f..d43a85d 100644 --- a/arm/util/connections.py +++ b/arm/util/connections.py @@ -22,55 +22,13 @@ import os import time import threading -from stem.util import conf, enum, log, proc, system - -# enums for connection resolution utilities -Resolver = enum.Enum(("PROC", "proc"), - ("NETSTAT", "netstat"), - ("SS", "ss"), - ("LSOF", "lsof"), - ("SOCKSTAT", "sockstat"), - ("BSD_SOCKSTAT", "sockstat (bsd)"), - ("BSD_PROCSTAT", "procstat (bsd)")) +from stem.util import conf, connection, enum, log, proc, system # If true this provides new instantiations for resolvers if the old one has # been stopped. This can make it difficult ensure all threads are terminated # when accessed concurrently. RECREATE_HALTED_RESOLVERS = False -# formatted strings for the commands to be executed with the various resolvers -# options are: -# n = prevents dns lookups, p = include process -# output: -# tcp 0 0 127.0.0.1:9051 127.0.0.1:53308 ESTABLISHED 9912/tor -# *note: bsd uses a different variant ('-t' => '-p tcp', but worse an -# equivilant -p doesn't exist so this can't function) -RUN_NETSTAT = "netstat -np" - -# n = numeric ports, p = include process, t = tcp sockets, u = udp sockets -# output: -# ESTAB 0 0 127.0.0.1:9051 127.0.0.1:53308 users:(("tor",9912,20)) -# *note: under freebsd this command belongs to a spreadsheet program -RUN_SS = "ss -nptu" - -# n = prevent dns lookups, P = show port numbers (not names), i = ip only, -# -w = no warnings -# output: -# tor 3873 atagar 45u IPv4 40994 0t0 TCP 10.243.55.20:45724->194.154.227.109:9001 (ESTABLISHED) -# -# oddly, using the -p flag via: -# lsof lsof -nPi -p <pid> | grep "^<process>.*(ESTABLISHED)" -# is much slower (11-28% in tests I ran) -RUN_LSOF = "lsof -wnPi" - -# output: -# atagar tor 3475 tcp4 127.0.0.1:9051 127.0.0.1:38942 ESTABLISHED -# *note: this isn't available by default under ubuntu -RUN_SOCKSTAT = "sockstat" - -RUN_BSD_SOCKSTAT = "sockstat -4c" -RUN_BSD_PROCSTAT = "procstat -f %s" - RESOLVERS = [] # connection resolvers available via the singleton constructor RESOLVER_FAILURE_TOLERANCE = 3 # number of subsequent failures before moving on to another resolver RESOLVER_SERIAL_FAILURE_MSG = "Unable to query connections with %s, trying %s" @@ -118,130 +76,6 @@ def getPortUsage(port): return PORT_USAGE.get(port) -def getResolverCommand(resolutionCmd, processName, processPid = ""): - """ - Provides the command and line filter that would be processed for the given - resolver type. This raises a ValueError if either the resolutionCmd isn't - recognized or a pid was requited but not provided. - - Arguments: - resolutionCmd - command to use in resolving the address - processName - name of the process for which connections are fetched - processPid - process ID (this helps improve accuracy) - """ - - if not processPid: - # the pid is required for procstat resolution - if resolutionCmd == Resolver.BSD_PROCSTAT: - raise ValueError("procstat resolution requires a pid") - - # if the pid was undefined then match any in that field - processPid = "[0-9]*" - - no_op_filter = lambda line: True - - if resolutionCmd == Resolver.PROC: return ("", no_op_filter) - elif resolutionCmd == Resolver.NETSTAT: - return ( - RUN_NETSTAT, - lambda line: "ESTABLISHED %s/%s" % (processPid, processName) in line - ) - elif resolutionCmd == Resolver.SS: - return ( - RUN_SS, - lambda line: ("ESTAB" in line) and ("\"%s\",%s" % (processName, processPid) in line) - ) - elif resolutionCmd == Resolver.LSOF: - return ( - RUN_LSOF, - lambda line: re.match("^%s *%s.*((UDP.*)|($ESTABLISHED$))" % (processName, processPid)) - ) - elif resolutionCmd == Resolver.SOCKSTAT: - return ( - RUN_SOCKSTAT, - lambda line: re.match("%s *%s.*ESTABLISHED" % (processName, processPid)) - ) - elif resolutionCmd == Resolver.BSD_SOCKSTAT: - return ( - RUN_BSD_SOCKSTAT, - lambda line: re.match("%s *%s" % (processName, processPid)) - ) - elif resolutionCmd == Resolver.BSD_PROCSTAT: - return ( - RUN_BSD_PROCSTAT % processPid, - lambda line: "TCP" in line and "0.0.0.0:0" not in line - ) - else: raise ValueError("Unrecognized resolution type: %s" % resolutionCmd) - -def getConnections(resolutionCmd, processName, processPid = ""): - """ - Retrieves a list of the current connections for a given process, providing a - tuple list of the form: - [(local_ipAddr1, local_port1, foreign_ipAddr1, foreign_port1), ...] - this raises an IOError if no connections are available or resolution fails - (in most cases these appear identical). Common issues include: - - insufficient permissions - - resolution command is unavailable - - usage of the command is non-standard (particularly an issue for BSD) - - Arguments: - resolutionCmd - command to use in resolving the address - processName - name of the process for which connections are fetched - processPid - process ID (this helps improve accuracy) - """ - - if resolutionCmd == Resolver.PROC: - # Attempts resolution via checking the proc contents. - if not processPid: - raise ValueError("proc resolution requires a pid") - - try: - return proc.get_connections(processPid) - except Exception, exc: - raise IOError(str(exc)) - else: - # Queries a resolution utility (netstat, lsof, etc). This raises an - # IOError if the command fails or isn't available. - cmd, cmd_filter = getResolverCommand(resolutionCmd, processName, processPid) - results = system.call(cmd) - results = filter(cmd_filter, results) - - if not results: raise IOError("No results found using: %s" % cmd) - - # parses results for the resolution command - conn = [] - for line in results: - if resolutionCmd == Resolver.LSOF: - # Different versions of lsof have different numbers of columns, so - # stripping off the optional 'established' entry so we can just use - # the last one. - comp = line.replace("(ESTABLISHED)", "").strip().split() - else: comp = line.split() - - if resolutionCmd == Resolver.NETSTAT: - localIp, localPort = comp[3].split(":") - foreignIp, foreignPort = comp[4].split(":") - elif resolutionCmd == Resolver.SS: - localIp, localPort = comp[4].split(":") - foreignIp, foreignPort = comp[5].split(":") - elif resolutionCmd == Resolver.LSOF: - local, foreign = comp[-1].split("->") - localIp, localPort = local.split(":") - foreignIp, foreignPort = foreign.split(":") - elif resolutionCmd == Resolver.SOCKSTAT: - localIp, localPort = comp[4].split(":") - foreignIp, foreignPort = comp[5].split(":") - elif resolutionCmd == Resolver.BSD_SOCKSTAT: - localIp, localPort = comp[5].split(":") - foreignIp, foreignPort = comp[6].split(":") - elif resolutionCmd == Resolver.BSD_PROCSTAT: - localIp, localPort = comp[9].split(":") - foreignIp, foreignPort = comp[10].split(":") - - conn.append((localIp, localPort, foreignIp, foreignPort)) - - return conn - def isResolverAlive(processName, processPid = ""): """ This provides true if a singleton resolver instance exists for the given @@ -289,30 +123,6 @@ def getResolver(processName, processPid = "", alias=None): else: RESOLVERS[haltedIndex] = r return r -def getSystemResolvers(osType = None): - """ - Provides the types of connection resolvers available on this operating - system. - - Arguments: - osType - operating system type, fetched from the os module if undefined - """ - - if osType == None: osType = os.uname()[0] - - if osType == "FreeBSD": - resolvers = [Resolver.BSD_SOCKSTAT, Resolver.BSD_PROCSTAT, Resolver.LSOF] - elif osType in ("OpenBSD", "Darwin"): - resolvers = [Resolver.LSOF] - else: - resolvers = [Resolver.NETSTAT, Resolver.SOCKSTAT, Resolver.LSOF, Resolver.SS] - - # proc resolution, by far, outperforms the others so defaults to this is able - if proc.is_available(): - resolvers = [Resolver.PROC] + resolvers - - return resolvers - class ConnectionResolver(threading.Thread): """ Service that periodically queries for a process' current connections. This @@ -379,11 +189,11 @@ class ConnectionResolver(threading.Thread): self.defaultRate = CONFIG["queries.connections.minRate"] self.lastLookup = -1 self.overwriteResolver = None - self.defaultResolver = Resolver.PROC + self.defaultResolver = connection.Resolver.PROC - osType = os.uname()[0] - self.resolverOptions = getSystemResolvers(osType) + self.resolverOptions = connection.get_system_resolvers() + osType = os.uname()[0] log.info("Operating System: %s, Connection Resolvers: %s" % (osType, ", ".join(self.resolverOptions))) # sets the default resolver to be the first found in the system's PATH @@ -393,7 +203,7 @@ class ConnectionResolver(threading.Thread): # resolvers. resolverCmd = resolver.replace(" (bsd)", "") - if resolver == Resolver.PROC or system.is_available(resolverCmd): + if resolver == connection.Resolver.PROC or system.is_available(resolverCmd): self.defaultResolver = resolver break @@ -452,7 +262,10 @@ class ConnectionResolver(threading.Thread): try: resolveStart = time.time() - connResults = getConnections(resolver, self.processName, self.processPid) + time.sleep(2) + from stem.util import log + connResults = [(conn.local_address, conn.local_port, conn.remote_address, conn.remote_port) for conn in connection.get_connections(resolver, process_pid = self.processPid, process_name = self.processName)] + lookupTime = time.time() - resolveStart self._connections = connResults [View Less]

1 0

[stem/master] Proc unit tests didn't reflect protocol addition
by atagar＠torproject.org 23 Sep '13

23 Sep '13

commit 7c0002d40db176d02c6a57e400ec53b5fb7a63a4 Author: Damian Johnson <atagar(a)torproject.org> Date: Mon Sep 23 00:28:01 2013 -0700 Proc unit tests didn't reflect protocol addition Oops, our unit tests didn't account for proc now providing the protocol. Caught by our jenkins tests. --- test/unit/util/proc.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/test/unit/util/proc.py b/test/unit/util/proc.py index 4ee598b..caf9d7a 100644 --- a/… [View More]

1 0

[stem/master] Adding function for getting the system's resolvers
by atagar＠torproject.org 23 Sep '13

23 Sep '13

commit 87b0d512e2b83a2dcced709e33128eaed10cc439 Author: Damian Johnson <atagar(a)torproject.org> Date: Sun Sep 22 12:25:00 2013 -0700 Adding function for getting the system's resolvers Adding a get_system_resolvers() function that provides the connection resolvers that are likely to work on a given platform. --- stem/util/connection.py | 47 +++++++++++++++++++++++++++++++++++++++++- test/unit/util/connection.py | 27 ++++++++++++++++++++++++ 2 files changed, … [View More]73 insertions(+), 1 deletion(-) diff --git a/stem/util/connection.py b/stem/util/connection.py index 0e4c190..e0b08df 100644 --- a/stem/util/connection.py +++ b/stem/util/connection.py @@ -21,13 +21,58 @@ but for now just moving the parts we need. import hashlib import hmac import os +import platform import re -CRYPTOVARIABLE_EQUALITY_COMPARISON_NONCE = os.urandom(32) +import stem.util.proc + +from stem.util import enum + +Resolver = enum.Enum( + ('PROC', 'proc'), + ('NETSTAT', 'netstat'), + ('SS', 'ss'), + ('LSOF', 'lsof'), + ('SOCKSTAT', 'sockstat'), + ('BSD_SOCKSTAT', 'sockstat (bsd)'), + ('BSD_PROCSTAT', 'procstat (bsd)') +) FULL_IPv4_MASK = "255.255.255.255" FULL_IPv6_MASK = "FFFF:FFFF:FFFF:FFFF:FFFF:FFFF:FFFF:FFFF" +CRYPTOVARIABLE_EQUALITY_COMPARISON_NONCE = os.urandom(32) + + +def get_system_resolvers(system = None): + """ + Provides the types of connection resolvers likely to be available on this platform. + + :param str system: system to get resolvers for, this is determined by + platform.system() if not provided + + :returns: **list** of Resolvers likely to be available on this platform + """ + + if system is None: + system = platform.system() + + if system == 'Windows': + resolvers = [] + elif system in ('Darwin', 'OpenBSD'): + resolvers = [Resolver.LSOF] + elif system == 'FreeBSD': + resolvers = [Resolver.BSD_SOCKSTAT, Resolver.BSD_PROCSTAT, Resolver.LSOF] + else: + resolvers = [Resolver.NETSTAT, Resolver.SOCKSTAT, Resolver.LSOF, Resolver.SS] + + # proc resolution, by far, outperforms the others so defaults to this is able + + if stem.util.proc.is_available(): + resolvers = [Resolver.PROC] + resolvers + + return resolvers + def is_valid_ipv4_address(address): """ diff --git a/test/unit/util/connection.py b/test/unit/util/connection.py index 5d48f28..40a2e02 100644 --- a/test/unit/util/connection.py +++ b/test/unit/util/connection.py @@ -2,12 +2,39 @@ Unit tests for the stem.util.connection functions. """ +import platform import unittest +from mock import patch + import stem.util.connection +from stem.util.connection import Resolver class TestConnection(unittest.TestCase): + @patch('stem.util.proc.is_available') + def test_get_system_resolvers(self, proc_mock): + """ + Checks the get_system_resolvers function. + """ + + proc_mock.return_value = False + + self.assertEqual([], stem.util.connection.get_system_resolvers('Windows')) + self.assertEqual([Resolver.LSOF], stem.util.connection.get_system_resolvers('Darwin')) + self.assertEqual([Resolver.LSOF], stem.util.connection.get_system_resolvers('OpenBSD')) + self.assertEqual([Resolver.BSD_SOCKSTAT, Resolver.BSD_PROCSTAT, Resolver.LSOF], stem.util.connection.get_system_resolvers('FreeBSD')) + self.assertEqual([Resolver.NETSTAT, Resolver.SOCKSTAT, Resolver.LSOF, Resolver.SS], stem.util.connection.get_system_resolvers('Linux')) + + proc_mock.return_value = True + + self.assertEqual([Resolver.PROC, Resolver.NETSTAT, Resolver.SOCKSTAT, Resolver.LSOF, Resolver.SS], stem.util.connection.get_system_resolvers('Linux')) + + # check that calling without an argument is equivilant to calling for this + # platform + + self.assertEqual(stem.util.connection.get_system_resolvers(platform.system()), stem.util.connection.get_system_resolvers()) + def test_is_valid_ipv4_address(self): """ Checks the is_valid_ipv4_address function. [View Less]

1 0

[stem/master] Connection resolution support
by atagar＠torproject.org 23 Sep '13

23 Sep '13

commit 1082349b59eb6ecd89eca1a1f2aa2ab1df007315 Author: Damian Johnson <atagar(a)torproject.org> Date: Sun Sep 22 23:38:17 2013 -0700 Connection resolution support Adding long overdue support for process connection resolution... https://trac.torproject.org/7910 This is a highly popular capability of arm, and stem's counterpart for it is quite a bit cleaner (with tests!). That said, this still doesn't get around tor's annoying … [View More]DisableDebuggerAttachment feature which screws up proc permissions. That's something I'll need to figure out before our next arm or stem release... --- docs/change_log.rst | 1 + stem/util/connection.py | 195 ++++++++++++++++++++++++++++++++++-- stem/util/proc.py | 18 +++- test/integ/util/__init__.py | 2 +- test/integ/util/connection.py | 33 +++++++ test/settings.cfg | 1 + test/unit/util/connection.py | 217 ++++++++++++++++++++++++++++++++++++++++- 7 files changed, 455 insertions(+), 12 deletions(-) diff --git a/docs/change_log.rst b/docs/change_log.rst index 13b256d..505261a 100644 --- a/docs/change_log.rst +++ b/docs/change_log.rst @@ -58,6 +58,7 @@ The following are only available within stem's `git repository * **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.get_pid_by_name` can now pull for all processes with a given name * :func:`~stem.util.system.call` ignored the subprocess' exit status diff --git a/stem/util/connection.py b/stem/util/connection.py index e0b08df..4605a57 100644 --- a/stem/util/connection.py +++ b/stem/util/connection.py @@ -2,22 +2,40 @@ # See LICENSE for licensing information """ -Connection and networking based utility functions. This will likely be expanded -later to have all of `arm's functions -<https://gitweb.torproject.org/arm.git/blob/HEAD:/src/util/connections.py>`_, -but for now just moving the parts we need. +Connection and networking based utility functions. :: + get_connections - quieries the connections belonging to a given process + get_system_resolvers - provides connection resolution methods that are likely to be available + is_valid_ipv4_address - checks if a string is a valid IPv4 address is_valid_ipv6_address - checks if a string is a valid IPv6 address is_valid_port - checks if something is a valid representation for a port is_private_address - checks if an IPv4 address belongs to a private range or not + expand_ipv6_address - provides an IPv6 address with its collapsed portions expanded get_mask_ipv4 - provides the mask representation for a given number of bits get_mask_ipv6 - provides the IPv6 mask representation for a given number of bits + +.. data:: Resolver (enum) + + Method for resolving a process' connections. + + ================= =========== + Resolver Description + ================= =========== + **PROC** /proc contents + **NETSTAT** netstat command + **SS** ss command + **LSOF** lsof command + **SOCKSTAT** sockstat command under *nix + **BSD_SOCKSTAT** sockstat command under FreeBSD + **BSD_PROCSTAT** procstat command under FreeBSD + ================= =========== """ +import collections import hashlib import hmac import os @@ -25,8 +43,16 @@ import platform import re import stem.util.proc +import stem.util.system -from stem.util import enum +from stem.util import enum, log + +# Connection resolution is risky to log about since it's highly likely to +# contain sensitive information. That said, it's also difficult to get right in +# a platform independent fashion. To opt into the logging requried to +# troubleshoot connection resolution set the following... + +LOG_CONNECTION_RESOLUTION = False Resolver = enum.Enum( ('PROC', 'proc'), @@ -38,11 +64,162 @@ Resolver = enum.Enum( ('BSD_PROCSTAT', 'procstat (bsd)') ) +Connection = collections.namedtuple('Connection', [ + 'local_address', + 'local_port', + 'remote_address', + 'remote_port', + 'protocol', +]) + FULL_IPv4_MASK = "255.255.255.255" FULL_IPv6_MASK = "FFFF:FFFF:FFFF:FFFF:FFFF:FFFF:FFFF:FFFF" CRYPTOVARIABLE_EQUALITY_COMPARISON_NONCE = os.urandom(32) +RESOLVER_COMMAND = { + Resolver.PROC: '', + + # -n = prevents dns lookups, -p = include process + Resolver.NETSTAT: 'netstat -np', + + # -n = numeric ports, -p = include process, -t = tcp sockets, -u = udp sockets + Resolver.SS: 'ss -nptu', + + # -n = prevent dns lookups, -P = show port numbers (not names), -i = ip only, -w = no warnings + # (lsof provides a '-p <pid>' but oddly in practice it seems to be ~11-28% slower) + Resolver.LSOF: 'lsof -wnPi', + + Resolver.SOCKSTAT: 'sockstat', + + # -4 = IPv4, -c = connected sockets + Resolver.BSD_SOCKSTAT: 'sockstat -4c', + + # -f <pid> = process pid + Resolver.BSD_PROCSTAT: 'procstat -f {pid}', +} + +RESOLVER_FILTER = { + Resolver.PROC: '', + + # tcp 0 586 192.168.0.1:44284 38.229.79.2:443 ESTABLISHED 15843/tor + Resolver.NETSTAT: '^{protocol}\s+.*\s+{local_address}:{local_port}\s+{remote_address}:{remote_port}\s+ESTABLISHED\s+{pid}/{name}\s*$', + + # tcp ESTAB 0 0 192.168.0.20:44415 38.229.79.2:443 users:(("tor",15843,9)) + Resolver.SS: '^{protocol}\s+ESTAB\s+.*\s+{local_address}:{local_port}\s+{remote_address}:{remote_port}\s+users:$\("{name}",{pid},[0-9]+$\)$', + + # tor 3873 atagar 45u IPv4 40994 0t0 TCP 10.243.55.20:45724->194.154.227.109:9001 (ESTABLISHED) + Resolver.LSOF: '^{name}\s+{pid}\s+.*\s+{protocol}\s+{local_address}:{local_port}->{remote_address}:{remote_port} $ESTABLISHED$$', + + # atagar tor 15843 tcp4 192.168.0.20:44092 68.169.35.102:443 ESTABLISHED + Resolver.SOCKSTAT: '^\S+\s+{name}\s+{pid}\s+{protocol}4\s+{local_address}:{local_port}\s+{remote_address}:{remote_port}\s+ESTABLISHED$', + + # _tor tor 4397 12 tcp4 172.27.72.202:54011 127.0.0.1:9001 + Resolver.BSD_SOCKSTAT: '^\S+\s+{name}\s+{pid}\s+\S+\s+{protocol}4\s+{local_address}:{local_port}\s+{remote_address}:{remote_port}$', + + # 3561 tor 4 s - rw---n-- 2 0 TCP 10.0.0.2:9050 10.0.0.1:22370 + Resolver.BSD_PROCSTAT: '^\s*{pid}\s+{name}\s+.*\s+{protocol}\s+{local_address}:{local_port}\s+{remote_address}:{remote_port}$', +} + + +def get_connections(resolver, process_pid = None, process_name = None): + """ + Retrieves a list of the current connections for a given process. The provides + a list of Connection instances, which have four attributes... + + * local_address (str) + * local_port (int) + * remote_address (str) + * remote_port (int) + * protocol (str, generally either 'tcp' or 'udp') + + :param Resolver resolver: method of connection resolution to use + :param int process_pid: pid of the process to retrieve + :param str process_name: name of the process to retrieve + + :raises: + * **ValueError** if using **Resolver.PROC** or **Resolver.BSD_PROCSTAT** + and the process_pid wasn't provided + + * **IOError** if no connections are available or resolution fails + (generally they're indistinguishable). The common causes are the + command being unavailable or permissions. + """ + + def _log(msg): + if LOG_CONNECTION_RESOLUTION: + log.debug(msg) + + _log("=" * 80) + _log("Querying connections for resolver: %s, pid: %s, name: %s" % (resolver, process_pid, process_name)) + + if isinstance(process_pid, str): + try: + process_pid = int(process_pid) + except ValueError: + raise ValueError("Process pid was non-numeric: %s" % process_pid) + + if process_pid is None and resolver in (Resolver.PROC, Resolver.BSD_PROCSTAT): + raise ValueError("%s resolution requires a pid" % resolver) + + if resolver == Resolver.PROC: + return [Connection(*conn) for conn in stem.util.proc.get_connections(process_pid)] + + resolver_command = RESOLVER_COMMAND[resolver].format(pid = process_pid) + + try: + results = stem.util.system.call(resolver_command) + except OSError as exc: + raise IOError("Unable to query '%s': %s" % (resolver_command, exc)) + + resolver_regex_str = RESOLVER_FILTER[resolver].format( + protocol = '(?P<protocol>\S+)', + local_address = '(?P<local_address>[0-9.]+)', + local_port = '(?P<local_port>[0-9]+)', + remote_address = '(?P<remote_address>[0-9.]+)', + remote_port = '(?P<remote_port>[0-9]+)', + pid = process_pid if process_pid else '[0-9]*', + name = process_name if process_name else '\S*', + ) + + _log("Resolver regex: %s" % resolver_regex_str) + _log("Resolver results:\n%s" % '\n'.join(results)) + + connections = [] + resolver_regex = re.compile(resolver_regex_str) + + for line in results: + match = resolver_regex.match(line) + + if match: + attr = match.groupdict() + local_addr = attr['local_address'] + local_port = int(attr['local_port']) + remote_addr = attr['remote_address'] + remote_port = int(attr['remote_port']) + protocol = attr['protocol'].lower() + + if remote_addr == '0.0.0.0': + continue # procstat response for unestablished connections + + if not (is_valid_ipv4_address(local_addr) and is_valid_ipv4_address(remote_addr)): + _log("Invalid address (%s or %s): %s" % (local_addr, remote_addr, line)) + elif not (is_valid_port(local_port) and is_valid_port(remote_port)): + _log("Invalid port (%s or %s): %s" % (local_port, remote_port, line)) + elif protocol not in ('tcp', 'udp'): + _log("Unrecognized protocol (%s): %s" % (protocol, line)) + + conn = Connection(local_addr, local_port, remote_addr, remote_port, protocol) + connections.append(conn) + _log(str(conn)) + + _log("%i connections found" % len(connections)) + + if not connections: + raise IOError("No results found using: %s" % resolver_command) + + return connections + def get_system_resolvers(system = None): """ @@ -62,8 +239,14 @@ def get_system_resolvers(system = None): elif system in ('Darwin', 'OpenBSD'): resolvers = [Resolver.LSOF] elif system == 'FreeBSD': + # Netstat is available, but lacks a '-p' equivilant so we can't associate + # the results to processes. The platform also has a ss command, but it + # belongs to a spreadsheet application. + resolvers = [Resolver.BSD_SOCKSTAT, Resolver.BSD_PROCSTAT, Resolver.LSOF] else: + # Sockstat isn't available by default on ubuntu. + resolvers = [Resolver.NETSTAT, Resolver.SOCKSTAT, Resolver.LSOF, Resolver.SS] # proc resolution, by far, outperforms the others so defaults to this is able @@ -193,7 +376,7 @@ def is_private_address(address): if address.startswith("172."): second_octet = int(address.split('.')[1]) - if second_octet >= 16 and second_octet <= 31: + if second_octet >= 16 and second_octet <= 31: return True return False diff --git a/stem/util/proc.py b/stem/util/proc.py index b7efdef..401c319 100644 --- a/stem/util/proc.py +++ b/stem/util/proc.py @@ -309,23 +309,32 @@ def get_connections(pid): :param int pid: process id of the process to be queried :returns: A listing of connection tuples of the form **[(local_ipAddr1, - local_port1, foreign_ipAddr1, foreign_port1), ...]** (IP addresses are - strings and ports are ints) + local_port1, foreign_ipAddr1, foreign_port1, protocol), ...]** (addresses + and protocols are strings and ports are ints) :raises: **IOError** if it can't be determined """ + if isinstance(pid, str): + try: + pid = int(pid) + except ValueError: + raise IOError("Process pid was non-numeric: %s" % pid) + if pid == 0: return [] # fetches the inode numbers for socket file descriptors + start_time, parameter = time.time(), "process connections" inodes = [] + for fd in os.listdir("/proc/%s/fd" % pid): fd_path = "/proc/%s/fd/%s" % (pid, fd) try: # File descriptor link, such as 'socket:[30899]' + fd_name = os.readlink(fd_path) if fd_name.startswith('socket:['): @@ -341,7 +350,9 @@ def get_connections(pid): return [] # check for the connection information from the /proc/net contents + conn = [] + for proc_file_path in ("/proc/net/tcp", "/proc/net/udp"): try: proc_file = open(proc_file_path) @@ -357,7 +368,8 @@ def get_connections(pid): local_ip, local_port = _decode_proc_address_encoding(l_addr) foreign_ip, foreign_port = _decode_proc_address_encoding(f_addr) - conn.append((local_ip, local_port, foreign_ip, foreign_port)) + protocol = proc_file_path[10:] + conn.append((local_ip, local_port, foreign_ip, foreign_port, protocol)) proc_file.close() except IOError as exc: diff --git a/test/integ/util/__init__.py b/test/integ/util/__init__.py index eac6be5..2371a4e 100644 --- a/test/integ/util/__init__.py +++ b/test/integ/util/__init__.py @@ -2,4 +2,4 @@ Integration tests for stem.util.* contents. """ -__all__ = ["conf", "proc", "system"] +__all__ = ["conf", "connection", "proc", "system"] diff --git a/test/integ/util/connection.py b/test/integ/util/connection.py new file mode 100644 index 0000000..70ad7f9 --- /dev/null +++ b/test/integ/util/connection.py @@ -0,0 +1,33 @@ +""" +Integration tests for stem.util.connection functions against the tor process +that we're running. +""" + +import unittest + +import test.runner + +from stem.util.connection import get_connections, get_system_resolvers + + +class TestConnection(unittest.TestCase): + def test_get_connections(self): + runner = test.runner.get_runner() + + if not test.runner.Torrc.PORT in runner.get_options(): + test.runner.skip(self, "(no control port)") + return + elif not test.runner.get_runner().is_ptraceable(): + test.runner.skip(self, "(DisableDebuggerAttachment is set)") + return + + for resolver in get_system_resolvers(): + with runner.get_tor_socket(): + tor_pid = test.runner.get_runner().get_pid() + connections = get_connections(resolver, process_pid = tor_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))) diff --git a/test/settings.cfg b/test/settings.cfg index b97c57f..9838012 100644 --- a/test/settings.cfg +++ b/test/settings.cfg @@ -185,6 +185,7 @@ test.unit_tests 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.descriptor.reader.TestDescriptorReader diff --git a/test/unit/util/connection.py b/test/unit/util/connection.py index 40a2e02..03d83c1 100644 --- a/test/unit/util/connection.py +++ b/test/unit/util/connection.py @@ -9,7 +9,83 @@ from mock import patch import stem.util.connection -from stem.util.connection import Resolver +from stem.util.connection import Resolver, Connection + +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 - +""" + +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)) +""" + +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) +""" + +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 +""" + class TestConnection(unittest.TestCase): @patch('stem.util.proc.is_available') @@ -27,7 +103,6 @@ class TestConnection(unittest.TestCase): self.assertEqual([Resolver.NETSTAT, Resolver.SOCKSTAT, Resolver.LSOF, Resolver.SS], stem.util.connection.get_system_resolvers('Linux')) proc_mock.return_value = True - self.assertEqual([Resolver.PROC, Resolver.NETSTAT, Resolver.SOCKSTAT, Resolver.LSOF, Resolver.SS], stem.util.connection.get_system_resolvers('Linux')) # check that calling without an argument is equivilant to calling for this @@ -35,6 +110,144 @@ class TestConnection(unittest.TestCase): self.assertEqual(stem.util.connection.get_system_resolvers(platform.system()), stem.util.connection.get_system_resolvers()) + @patch('stem.util.proc.get_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'), + ('187.187.187.187', 48059, '204.204.204.204', 52428, 'tcp'), + ] + + expected = [ + Connection('17.17.17.17', 4369, '34.34.34.34', 8738, 'tcp'), + Connection('187.187.187.187', 48059, '204.204.204.204', 52428, 'tcp'), + ] + + 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')] + 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') + 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'), + Connection('192.168.0.1', 44415, '38.229.79.2', 443, 'tcp'), + ] + 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') + 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'), + Connection('192.168.0.1', 44092, '68.169.35.102', 443, 'tcp'), + ] + 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') + 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'), + Connection('192.168.0.1', 44092, '68.169.35.102', 443, 'tcp'), + ] + 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'), + Connection('172.27.72.202', 59374, '68.169.35.102', 9001, 'tcp'), + Connection('172.27.72.202', 59673, '213.24.100.160', 9001, 'tcp'), + Connection('172.27.72.202', 51946, '32.188.221.72', 443, 'tcp'), + Connection('172.27.72.202', 60344, '21.89.91.78', 9001, 'tcp'), + ] + 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'), + Connection('10.0.0.2', 9050, '10.0.0.1', 44381, 'tcp'), + Connection('10.0.0.2', 33734, '38.229.79.2', 443, 'tcp'), + Connection('10.0.0.2', 47704, '68.169.35.102', 9001, 'tcp'), + ] + 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) + def test_is_valid_ipv4_address(self): """ Checks the is_valid_ipv4_address function. [View Less]

1 0