tor-commits November 2011

tor-commits@lists.torproject.org

16 participants
987 discussions

[stem/master] Moving PROTOCOLINFO tests to be grouped by subject
by atagar＠torproject.org 21 Nov '11

21 Nov '11

commit 708e082fb7bdddf2261a44fb290d20d768bc180c Author: Damian Johnson <atagar(a)torproject.org> Date: Mon Nov 21 07:42:14 2011 -0800 Moving PROTOCOLINFO tests to be grouped by subject All the PROTOCOLINFO related tests might as well be together. Shuffling them around so all the tests can reside in a test/*/protocolinfo.py rather than have separate protocolinfo_response.py, protocolinfo_query.py, etc. --- run_tests.py | 8 +- test/integ/connection/__init__.py | 2 +- test/integ/connection/protocolinfo.py | 65 +++++++++ test/integ/connection/protocolinfo_response.py | 65 --------- test/unit/connection/__init__.py | 2 +- test/unit/connection/protocolinfo.py | 181 ++++++++++++++++++++++++ test/unit/connection/protocolinfo_response.py | 181 ------------------------ 7 files changed, 252 insertions(+), 252 deletions(-) diff --git a/run_tests.py b/run_tests.py index 9189908..2d12a57 100755 --- a/run_tests.py +++ b/run_tests.py @@ -16,13 +16,13 @@ import test.runner import test.unit.types.control_message import test.unit.types.control_line import test.unit.types.version -import test.unit.connection.protocolinfo_response +import test.unit.connection.protocolinfo import test.unit.util.enum import test.unit.util.system import test.integ.types.control_message import test.integ.util.conf import test.integ.util.system -import test.integ.connection.protocolinfo_response +import test.integ.connection.protocolinfo import stem.util.enum import stem.util.term as term @@ -35,13 +35,13 @@ DIVIDER = "=" * 70 UNIT_TESTS = (("stem.types.ControlMessage", test.unit.types.control_message.TestControlMessage), ("stem.types.ControlLine", test.unit.types.control_line.TestControlLine), ("stem.types.Version", test.unit.types.version.TestVerion), - ("stem.connection.ProtocolInfoResponse", test.unit.connection.protocolinfo_response.TestProtocolInfoResponse), + ("stem.connection.ProtocolInfoResponse", test.unit.connection.protocolinfo.TestProtocolInfoResponse), ("stem.util.enum", test.unit.util.enum.TestEnum), ("stem.util.system", test.unit.util.system.TestSystem), ) INTEG_TESTS = (("stem.types.ControlMessage", test.integ.types.control_message.TestControlMessage), - ("stem.connection.ProtocolInfoResponse", test.integ.connection.protocolinfo_response.TestProtocolInfoResponse), + ("stem.connection.ProtocolInfoResponse", test.integ.connection.protocolinfo.TestProtocolInfoResponse), ("stem.util.conf", test.integ.util.conf.TestConf), ("stem.util.system", test.integ.util.system.TestSystem), ) diff --git a/test/integ/connection/__init__.py b/test/integ/connection/__init__.py index 6a71f2a..dd0925e 100644 --- a/test/integ/connection/__init__.py +++ b/test/integ/connection/__init__.py @@ -2,5 +2,5 @@ Integration tests for stem.connection. """ -__all__ = ["protocolinfo_response"] +__all__ = ["protocolinfo"] diff --git a/test/integ/connection/protocolinfo.py b/test/integ/connection/protocolinfo.py new file mode 100644 index 0000000..27b5f1f --- /dev/null +++ b/test/integ/connection/protocolinfo.py @@ -0,0 +1,65 @@ +""" +Integration tests for the stem.connections.ProtocolInfoResponse class. +""" + +import socket +import unittest + +import test.runner +import stem.types +import stem.connection + +class TestProtocolInfoResponse(unittest.TestCase): + """ + Processes a ProtocolInfo query for a variety of setups. + """ + + def testProtocolInfoResponse(self): + """ + Makes a PROTOCOLINFO query and processes the response for our control + connection. + """ + + runner = test.runner.get_runner() + connection_type = runner.get_connection_type() + + if connection_type == test.runner.TorConnection.NONE: + self.skipTest("(no connection)") + + control_socket = runner.get_tor_socket(False) + control_socket_file = control_socket.makefile() + + control_socket_file.write("PROTOCOLINFO\r\n") + control_socket_file.flush() + + protocolinfo_response = stem.types.read_message(control_socket_file) + stem.connection.ProtocolInfoResponse.convert(protocolinfo_response) + + # 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.assertEqual((), protocolinfo_response.unknown_auth_methods) + self.assertEqual(None, protocolinfo_response.socket) + + if connection_type == test.runner.TorConnection.NO_AUTH: + self.assertEqual((stem.connection.AuthMethod.NONE,), protocolinfo_response.auth_methods) + self.assertEqual(None, protocolinfo_response.cookie_file) + elif connection_type == test.runner.TorConnection.PASSWORD: + self.assertEqual((stem.connection.AuthMethod.PASSWORD,), protocolinfo_response.auth_methods) + self.assertEqual(None, protocolinfo_response.cookie_file) + elif connection_type == test.runner.TorConnection.COOKIE: + self.assertEqual((stem.connection.AuthMethod.COOKIE,), protocolinfo_response.auth_methods) + self.assertEqual(runner.get_auth_cookie_path(), protocolinfo_response.cookie_file) + elif connection_type == test.runner.TorConnection.MULTIPLE: + self.assertEqual((stem.connection.AuthMethod.COOKIE, stem.connection.AuthMethod.PASSWORD), protocolinfo_response.auth_methods) + self.assertEqual(runner.get_auth_cookie_path(), protocolinfo_response.cookie_file) + elif connection_type == test.runner.TorConnection.SOCKET: + self.assertEqual((stem.connection.AuthMethod.NONE,), protocolinfo_response.auth_methods) + self.assertEqual(None, protocolinfo_response.cookie_file) + else: + self.fail("Unrecognized connection type: %s" % connection_type) + diff --git a/test/integ/connection/protocolinfo_response.py b/test/integ/connection/protocolinfo_response.py deleted file mode 100644 index 27b5f1f..0000000 --- a/test/integ/connection/protocolinfo_response.py +++ /dev/null @@ -1,65 +0,0 @@ -""" -Integration tests for the stem.connections.ProtocolInfoResponse class. -""" - -import socket -import unittest - -import test.runner -import stem.types -import stem.connection - -class TestProtocolInfoResponse(unittest.TestCase): - """ - Processes a ProtocolInfo query for a variety of setups. - """ - - def testProtocolInfoResponse(self): - """ - Makes a PROTOCOLINFO query and processes the response for our control - connection. - """ - - runner = test.runner.get_runner() - connection_type = runner.get_connection_type() - - if connection_type == test.runner.TorConnection.NONE: - self.skipTest("(no connection)") - - control_socket = runner.get_tor_socket(False) - control_socket_file = control_socket.makefile() - - control_socket_file.write("PROTOCOLINFO\r\n") - control_socket_file.flush() - - protocolinfo_response = stem.types.read_message(control_socket_file) - stem.connection.ProtocolInfoResponse.convert(protocolinfo_response) - - # 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.assertEqual((), protocolinfo_response.unknown_auth_methods) - self.assertEqual(None, protocolinfo_response.socket) - - if connection_type == test.runner.TorConnection.NO_AUTH: - self.assertEqual((stem.connection.AuthMethod.NONE,), protocolinfo_response.auth_methods) - self.assertEqual(None, protocolinfo_response.cookie_file) - elif connection_type == test.runner.TorConnection.PASSWORD: - self.assertEqual((stem.connection.AuthMethod.PASSWORD,), protocolinfo_response.auth_methods) - self.assertEqual(None, protocolinfo_response.cookie_file) - elif connection_type == test.runner.TorConnection.COOKIE: - self.assertEqual((stem.connection.AuthMethod.COOKIE,), protocolinfo_response.auth_methods) - self.assertEqual(runner.get_auth_cookie_path(), protocolinfo_response.cookie_file) - elif connection_type == test.runner.TorConnection.MULTIPLE: - self.assertEqual((stem.connection.AuthMethod.COOKIE, stem.connection.AuthMethod.PASSWORD), protocolinfo_response.auth_methods) - self.assertEqual(runner.get_auth_cookie_path(), protocolinfo_response.cookie_file) - elif connection_type == test.runner.TorConnection.SOCKET: - self.assertEqual((stem.connection.AuthMethod.NONE,), protocolinfo_response.auth_methods) - self.assertEqual(None, protocolinfo_response.cookie_file) - else: - self.fail("Unrecognized connection type: %s" % connection_type) - diff --git a/test/unit/connection/__init__.py b/test/unit/connection/__init__.py index 440773e..f93234b 100644 --- a/test/unit/connection/__init__.py +++ b/test/unit/connection/__init__.py @@ -2,5 +2,5 @@ Unit tests for stem.connection. """ -__all__ = ["protocolinfo_response"] +__all__ = ["protocolinfo"] diff --git a/test/unit/connection/protocolinfo.py b/test/unit/connection/protocolinfo.py new file mode 100644 index 0000000..b9dcbb8 --- /dev/null +++ b/test/unit/connection/protocolinfo.py @@ -0,0 +1,181 @@ +""" +Unit tests for the stem.connection.ProtocolInfoResponse class. +""" + +import unittest +import StringIO +import stem.connection +import stem.types + +NO_AUTH = """250-PROTOCOLINFO 1 +250-AUTH METHODS=NULL +250-VERSION Tor="0.2.1.30" +250 OK +""".replace("\n", "\r\n") + +PASSWORD_AUTH = """250-PROTOCOLINFO 1 +250-AUTH METHODS=HASHEDPASSWORD +250-VERSION Tor="0.2.1.30" +250 OK +""".replace("\n", "\r\n") + +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 +""".replace("\n", "\r\n") + +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 +""".replace("\n", "\r\n") + +UNKNOWN_AUTH = """250-PROTOCOLINFO 1 +250-AUTH METHODS=MAGIC,HASHEDPASSWORD,PIXIE_DUST +250-VERSION Tor="0.2.1.30" +250 OK +""".replace("\n", "\r\n") + +MINIMUM_RESPONSE = """250-PROTOCOLINFO 5 +250 OK +""".replace("\n", "\r\n") + +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 +""".replace("\n", "\r\n") + +class TestProtocolInfoResponse(unittest.TestCase): + """ + Tests the parsing of ControlMessages for PROTOCOLINFO responses. + """ + + def test_convert(self): + """ + Exercises functionality of the convert method both when it works and + there's an error. + """ + + # working case + control_message = stem.types.read_message(StringIO.StringIO(NO_AUTH)) + stem.connection.ProtocolInfoResponse.convert(control_message) + + # now this should be a ProtocolInfoResponse (ControlMessage subclass) + self.assertTrue(isinstance(control_message, stem.types.ControlMessage)) + self.assertTrue(isinstance(control_message, stem.connection.ProtocolInfoResponse)) + + # exercise some of the ControlMessage functionality + self.assertTrue(str(control_message).startswith("PROTOCOLINFO 1")) + self.assertEquals(NO_AUTH, control_message.raw_content()) + + # attempt to convert the wrong type + self.assertRaises(TypeError, stem.connection.ProtocolInfoResponse.convert, "hello world") + + # attempt to convert a different message type + bw_event_control_message = stem.types.read_message(StringIO.StringIO("650 BW 32326 2856\r\n")) + self.assertRaises(stem.types.ProtocolError, stem.connection.ProtocolInfoResponse.convert, bw_event_control_message) + + def test_no_auth(self): + """ + Checks a response when there's no authentication. + """ + + control_message = stem.types.read_message(StringIO.StringIO(NO_AUTH)) + stem.connection.ProtocolInfoResponse.convert(control_message) + + self.assertEquals(1, control_message.protocol_version) + self.assertEquals(stem.types.Version("0.2.1.30"), control_message.tor_version) + self.assertEquals((stem.connection.AuthMethod.NONE, ), control_message.auth_methods) + self.assertEquals((), control_message.unknown_auth_methods) + self.assertEquals(None, control_message.cookie_file) + self.assertEquals(None, control_message.socket) + + def test_password_auth(self): + """ + Checks a response with password authentication. + """ + + control_message = stem.types.read_message(StringIO.StringIO(PASSWORD_AUTH)) + stem.connection.ProtocolInfoResponse.convert(control_message) + self.assertEquals((stem.connection.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 = stem.types.read_message(StringIO.StringIO(COOKIE_AUTH)) + stem.connection.ProtocolInfoResponse.convert(control_message) + self.assertEquals((stem.connection.AuthMethod.COOKIE, ), control_message.auth_methods) + self.assertEquals("/tmp/my data\\\"dir//control_auth_cookie", control_message.cookie_file) + + def test_multiple_auth(self): + """ + Checks a response with multiple authentication methods. + """ + + control_message = stem.types.read_message(StringIO.StringIO(MULTIPLE_AUTH)) + stem.connection.ProtocolInfoResponse.convert(control_message) + self.assertEquals((stem.connection.AuthMethod.COOKIE, stem.connection.AuthMethod.PASSWORD), control_message.auth_methods) + self.assertEquals("/home/atagar/.tor/control_auth_cookie", control_message.cookie_file) + + def test_unknown_auth(self): + """ + Checks a response with an unrecognized authtentication method. + """ + + control_message = stem.types.read_message(StringIO.StringIO(UNKNOWN_AUTH)) + stem.connection.ProtocolInfoResponse.convert(control_message) + self.assertEquals((stem.connection.AuthMethod.UNKNOWN, stem.connection.AuthMethod.PASSWORD), control_message.auth_methods) + self.assertEquals(("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 = stem.types.read_message(StringIO.StringIO(MINIMUM_RESPONSE)) + stem.connection.ProtocolInfoResponse.convert(control_message) + + self.assertEquals(5, control_message.protocol_version) + self.assertEquals(None , control_message.tor_version) + self.assertEquals((), control_message.auth_methods) + self.assertEquals((), control_message.unknown_auth_methods) + self.assertEquals(None, control_message.cookie_file) + self.assertEquals(None, control_message.socket) + + def test_relative_cookie(self): + """ + Checks an authentication cookie with a relative path where expansion both + succeeds and fails. + """ + + # we need to mock both pid and cwd lookups since the general cookie + # expanion works by... + # - resolving the pid of the "tor" process + # - using that to get tor's cwd + + def call_mocking(command): + if command == stem.util.system.GET_PID_BY_NAME_PGREP % "tor": + return ["10"] + if command == stem.util.system.GET_CWD_PWDX % 10: + return ["10: /tmp/foo"] + + stem.util.system.CALL_MOCKING = call_mocking + + control_message = stem.types.read_message(StringIO.StringIO(RELATIVE_COOKIE_PATH)) + stem.connection.ProtocolInfoResponse.convert(control_message) + self.assertEquals("/tmp/foo/tor-browser_en-US/Data/control_auth_cookie", control_message.cookie_file) + + # exercise cookie expansion where both calls fail (should work, just + # leaving the path unexpanded) + + stem.util.system.CALL_MOCKING = lambda cmd: None + control_message = stem.types.read_message(StringIO.StringIO(RELATIVE_COOKIE_PATH)) + stem.connection.ProtocolInfoResponse.convert(control_message) + self.assertEquals("./tor-browser_en-US/Data/control_auth_cookie", control_message.cookie_file) + diff --git a/test/unit/connection/protocolinfo_response.py b/test/unit/connection/protocolinfo_response.py deleted file mode 100644 index b9dcbb8..0000000 --- a/test/unit/connection/protocolinfo_response.py +++ /dev/null @@ -1,181 +0,0 @@ -""" -Unit tests for the stem.connection.ProtocolInfoResponse class. -""" - -import unittest -import StringIO -import stem.connection -import stem.types - -NO_AUTH = """250-PROTOCOLINFO 1 -250-AUTH METHODS=NULL -250-VERSION Tor="0.2.1.30" -250 OK -""".replace("\n", "\r\n") - -PASSWORD_AUTH = """250-PROTOCOLINFO 1 -250-AUTH METHODS=HASHEDPASSWORD -250-VERSION Tor="0.2.1.30" -250 OK -""".replace("\n", "\r\n") - -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 -""".replace("\n", "\r\n") - -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 -""".replace("\n", "\r\n") - -UNKNOWN_AUTH = """250-PROTOCOLINFO 1 -250-AUTH METHODS=MAGIC,HASHEDPASSWORD,PIXIE_DUST -250-VERSION Tor="0.2.1.30" -250 OK -""".replace("\n", "\r\n") - -MINIMUM_RESPONSE = """250-PROTOCOLINFO 5 -250 OK -""".replace("\n", "\r\n") - -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 -""".replace("\n", "\r\n") - -class TestProtocolInfoResponse(unittest.TestCase): - """ - Tests the parsing of ControlMessages for PROTOCOLINFO responses. - """ - - def test_convert(self): - """ - Exercises functionality of the convert method both when it works and - there's an error. - """ - - # working case - control_message = stem.types.read_message(StringIO.StringIO(NO_AUTH)) - stem.connection.ProtocolInfoResponse.convert(control_message) - - # now this should be a ProtocolInfoResponse (ControlMessage subclass) - self.assertTrue(isinstance(control_message, stem.types.ControlMessage)) - self.assertTrue(isinstance(control_message, stem.connection.ProtocolInfoResponse)) - - # exercise some of the ControlMessage functionality - self.assertTrue(str(control_message).startswith("PROTOCOLINFO 1")) - self.assertEquals(NO_AUTH, control_message.raw_content()) - - # attempt to convert the wrong type - self.assertRaises(TypeError, stem.connection.ProtocolInfoResponse.convert, "hello world") - - # attempt to convert a different message type - bw_event_control_message = stem.types.read_message(StringIO.StringIO("650 BW 32326 2856\r\n")) - self.assertRaises(stem.types.ProtocolError, stem.connection.ProtocolInfoResponse.convert, bw_event_control_message) - - def test_no_auth(self): - """ - Checks a response when there's no authentication. - """ - - control_message = stem.types.read_message(StringIO.StringIO(NO_AUTH)) - stem.connection.ProtocolInfoResponse.convert(control_message) - - self.assertEquals(1, control_message.protocol_version) - self.assertEquals(stem.types.Version("0.2.1.30"), control_message.tor_version) - self.assertEquals((stem.connection.AuthMethod.NONE, ), control_message.auth_methods) - self.assertEquals((), control_message.unknown_auth_methods) - self.assertEquals(None, control_message.cookie_file) - self.assertEquals(None, control_message.socket) - - def test_password_auth(self): - """ - Checks a response with password authentication. - """ - - control_message = stem.types.read_message(StringIO.StringIO(PASSWORD_AUTH)) - stem.connection.ProtocolInfoResponse.convert(control_message) - self.assertEquals((stem.connection.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 = stem.types.read_message(StringIO.StringIO(COOKIE_AUTH)) - stem.connection.ProtocolInfoResponse.convert(control_message) - self.assertEquals((stem.connection.AuthMethod.COOKIE, ), control_message.auth_methods) - self.assertEquals("/tmp/my data\\\"dir//control_auth_cookie", control_message.cookie_file) - - def test_multiple_auth(self): - """ - Checks a response with multiple authentication methods. - """ - - control_message = stem.types.read_message(StringIO.StringIO(MULTIPLE_AUTH)) - stem.connection.ProtocolInfoResponse.convert(control_message) - self.assertEquals((stem.connection.AuthMethod.COOKIE, stem.connection.AuthMethod.PASSWORD), control_message.auth_methods) - self.assertEquals("/home/atagar/.tor/control_auth_cookie", control_message.cookie_file) - - def test_unknown_auth(self): - """ - Checks a response with an unrecognized authtentication method. - """ - - control_message = stem.types.read_message(StringIO.StringIO(UNKNOWN_AUTH)) - stem.connection.ProtocolInfoResponse.convert(control_message) - self.assertEquals((stem.connection.AuthMethod.UNKNOWN, stem.connection.AuthMethod.PASSWORD), control_message.auth_methods) - self.assertEquals(("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 = stem.types.read_message(StringIO.StringIO(MINIMUM_RESPONSE)) - stem.connection.ProtocolInfoResponse.convert(control_message) - - self.assertEquals(5, control_message.protocol_version) - self.assertEquals(None , control_message.tor_version) - self.assertEquals((), control_message.auth_methods) - self.assertEquals((), control_message.unknown_auth_methods) - self.assertEquals(None, control_message.cookie_file) - self.assertEquals(None, control_message.socket) - - def test_relative_cookie(self): - """ - Checks an authentication cookie with a relative path where expansion both - succeeds and fails. - """ - - # we need to mock both pid and cwd lookups since the general cookie - # expanion works by... - # - resolving the pid of the "tor" process - # - using that to get tor's cwd - - def call_mocking(command): - if command == stem.util.system.GET_PID_BY_NAME_PGREP % "tor": - return ["10"] - if command == stem.util.system.GET_CWD_PWDX % 10: - return ["10: /tmp/foo"] - - stem.util.system.CALL_MOCKING = call_mocking - - control_message = stem.types.read_message(StringIO.StringIO(RELATIVE_COOKIE_PATH)) - stem.connection.ProtocolInfoResponse.convert(control_message) - self.assertEquals("/tmp/foo/tor-browser_en-US/Data/control_auth_cookie", control_message.cookie_file) - - # exercise cookie expansion where both calls fail (should work, just - # leaving the path unexpanded) - - stem.util.system.CALL_MOCKING = lambda cmd: None - control_message = stem.types.read_message(StringIO.StringIO(RELATIVE_COOKIE_PATH)) - stem.connection.ProtocolInfoResponse.convert(control_message) - self.assertEquals("./tor-browser_en-US/Data/control_auth_cookie", control_message.cookie_file) -

1 0

[stem/master] Resetting system call mocking after test
by atagar＠torproject.org 21 Nov '11

21 Nov '11

commit e17bfdd0c44b004468bd3121fd5408e2a29074fc Author: Damian Johnson <atagar(a)torproject.org> Date: Mon Nov 21 07:51:00 2011 -0800 Resetting system call mocking after test The protocolinfo test mocked system calls but didn't reset the mock when it was done. This didn't cause any errors but that was only luck (the system unit tests probably ran afterward and cleared the mock when it was done). Oops, this is gonna be an easy testing bug to introduce... :/ --- test/unit/connection/protocolinfo.py | 3 +++ 1 files changed, 3 insertions(+), 0 deletions(-) diff --git a/test/unit/connection/protocolinfo.py b/test/unit/connection/protocolinfo.py index b9dcbb8..fc9ab64 100644 --- a/test/unit/connection/protocolinfo.py +++ b/test/unit/connection/protocolinfo.py @@ -178,4 +178,7 @@ class TestProtocolInfoResponse(unittest.TestCase): control_message = stem.types.read_message(StringIO.StringIO(RELATIVE_COOKIE_PATH)) stem.connection.ProtocolInfoResponse.convert(control_message) self.assertEquals("./tor-browser_en-US/Data/control_auth_cookie", control_message.cookie_file) + + # reset system call mocking + stem.util.system.CALL_MOCKING = None

1 0

[stem/master] Expanding coverage of PROTOCOLINFO integ test
by atagar＠torproject.org 21 Nov '11

21 Nov '11

commit 07fd7f7d23f5312d4b4ee4ef64d63fbe97a911ba Author: Damian Johnson <atagar(a)torproject.org> Date: Mon Nov 21 04:29:10 2011 -0800 Expanding coverage of PROTOCOLINFO integ test Providing the assertions for all connection configurations in the integ test. --- test/integ/connection/protocolinfo_response.py | 33 ++++++++++++++++------- test/runner.py | 18 +++++++++++-- 2 files changed, 38 insertions(+), 13 deletions(-) diff --git a/test/integ/connection/protocolinfo_response.py b/test/integ/connection/protocolinfo_response.py index dfb5566..27b5f1f 100644 --- a/test/integ/connection/protocolinfo_response.py +++ b/test/integ/connection/protocolinfo_response.py @@ -21,8 +21,12 @@ class TestProtocolInfoResponse(unittest.TestCase): """ runner = test.runner.get_runner() + connection_type = runner.get_connection_type() + + if connection_type == test.runner.TorConnection.NONE: + self.skipTest("(no connection)") + control_socket = runner.get_tor_socket(False) - if not control_socket: self.skipTest("(no control socket)") control_socket_file = control_socket.makefile() control_socket_file.write("PROTOCOLINFO\r\n") @@ -38,15 +42,24 @@ class TestProtocolInfoResponse(unittest.TestCase): self.assertNotEqual(None, protocolinfo_response.tor_version) self.assertNotEqual(None, protocolinfo_response.auth_methods) - if runner.get_connection_type() != test.runner.TorConnection.NO_AUTH: - self.skipTest("(haven't yet implemented...)") # TODO: implement - - # TODO: The following is for the default integ test configuration. We - # should run tests that exercise all of tor's startup configs - # (password/cookie auth and control sockets) - - self.assertEqual((stem.connection.AuthMethod.NONE,), protocolinfo_response.auth_methods) self.assertEqual((), protocolinfo_response.unknown_auth_methods) - self.assertEqual(None, protocolinfo_response.cookie_file) self.assertEqual(None, protocolinfo_response.socket) + + if connection_type == test.runner.TorConnection.NO_AUTH: + self.assertEqual((stem.connection.AuthMethod.NONE,), protocolinfo_response.auth_methods) + self.assertEqual(None, protocolinfo_response.cookie_file) + elif connection_type == test.runner.TorConnection.PASSWORD: + self.assertEqual((stem.connection.AuthMethod.PASSWORD,), protocolinfo_response.auth_methods) + self.assertEqual(None, protocolinfo_response.cookie_file) + elif connection_type == test.runner.TorConnection.COOKIE: + self.assertEqual((stem.connection.AuthMethod.COOKIE,), protocolinfo_response.auth_methods) + self.assertEqual(runner.get_auth_cookie_path(), protocolinfo_response.cookie_file) + elif connection_type == test.runner.TorConnection.MULTIPLE: + self.assertEqual((stem.connection.AuthMethod.COOKIE, stem.connection.AuthMethod.PASSWORD), protocolinfo_response.auth_methods) + self.assertEqual(runner.get_auth_cookie_path(), protocolinfo_response.cookie_file) + elif connection_type == test.runner.TorConnection.SOCKET: + self.assertEqual((stem.connection.AuthMethod.NONE,), protocolinfo_response.auth_methods) + self.assertEqual(None, protocolinfo_response.cookie_file) + else: + self.fail("Unrecognized connection type: %s" % connection_type) diff --git a/test/runner.py b/test/runner.py index e39bd92..9d26deb 100644 --- a/test/runner.py +++ b/test/runner.py @@ -230,6 +230,20 @@ class Runner: test_dir = self._get("_test_dir") return os.path.join(test_dir, "torrc") + def get_auth_cookie_path(self): + """ + Provides the absolute path for our authentication cookie if we have one. + + Returns: + str with our auth cookie path + + Raises: + RunnerStopped if we aren't running + """ + + test_dir = self._get("_test_dir") + return os.path.join(test_dir, "control_auth_cookie") + def get_torrc_contents(self): """ Provides the contents of our torrc. @@ -282,7 +296,7 @@ class Runner: # TODO: replace with higher level connection functions when we have them - connection_type, test_dir = self.get_connection_type(), self._get("_test_dir") + connection_type, cookie_path = self.get_connection_type(), self.get_auth_cookie_path() if connection_type == None: return None conn_opts = CONNECTION_OPTS[connection_type] @@ -299,8 +313,6 @@ class Runner: control_socket_file = control_socket.makefile() if OPT_COOKIE in conn_opts: - cookie_path = os.path.join(test_dir, "control_auth_cookie") - auth_cookie = open(cookie_path, "r") auth_cookie_contents = auth_cookie.read() auth_cookie.close()

1 0

[stem/master] Function to query PROTOCOLINFO via a control port
by atagar＠torproject.org 21 Nov '11

21 Nov '11

commit 7f89ff58d2ad6ecbde7f8225e7b2c02ec400be1b Author: Damian Johnson <atagar(a)torproject.org> Date: Mon Nov 21 08:36:20 2011 -0800 Function to query PROTOCOLINFO via a control port Implementation and integ testing to query a PROTOCOLINFO response via a control port. Next is to do the same for control sockets. --- run_tests.py | 2 +- stem/connection.py | 74 ++++++++++++++++++++++++++++++++- test/integ/connection/protocolinfo.py | 63 ++++++++++++++++++++-------- 3 files changed, 120 insertions(+), 19 deletions(-) diff --git a/run_tests.py b/run_tests.py index 2d12a57..76e1abb 100755 --- a/run_tests.py +++ b/run_tests.py @@ -41,7 +41,7 @@ UNIT_TESTS = (("stem.types.ControlMessage", test.unit.types.control_message.Test ) INTEG_TESTS = (("stem.types.ControlMessage", test.integ.types.control_message.TestControlMessage), - ("stem.connection.ProtocolInfoResponse", test.integ.connection.protocolinfo.TestProtocolInfoResponse), + ("stem.connection.ProtocolInfoResponse", test.integ.connection.protocolinfo.TestProtocolInfo), ("stem.util.conf", test.integ.util.conf.TestConf), ("stem.util.system", test.integ.util.system.TestSystem), ) diff --git a/stem/connection.py b/stem/connection.py index 3165fba..3e97e9e 100644 --- a/stem/connection.py +++ b/stem/connection.py @@ -28,6 +28,78 @@ LOGGER = logging.getLogger("stem") AuthMethod = stem.util.enum.Enum("NONE", "PASSWORD", "COOKIE", "UNKNOWN") +def get_protocolinfo_port(control_addr = "127.0.0.1", control_port = 9051, keep_alive = False): + """ + Issues a PROTOCOLINFO query to a control port, getting information about the + tor process running on it. + + Arguments: + control_addr (str) - ip address of the controller + control_port (int) - port number of the controller + keep_alive (bool) - keeps the socket used to issue the PROTOCOLINFO query + open if True, closes otherwise + + Returns: + ProtocolInfoResponse with the response given by the tor process + + Raises: + stem.types.ProtocolError if the PROTOCOLINFO response is malformed + stem.types.SocketError if problems arise in establishing or using the + socket + """ + + control_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) + control_socket_file = control_socket.makefile() + protocolinfo_response, raised_exc = None, None + + try: + # initiates connection + control_socket.connect((control_addr, control_port)) + + # issues the PROTOCOLINFO query + control_socket_file.write("PROTOCOLINFO 1\r\n") + control_socket_file.flush() + + protocolinfo_response = stem.types.read_message(control_socket_file) + ProtocolInfoResponse.convert(protocolinfo_response) + except socket.error, exc: + raised_exc = stem.types.SocketError(exc) + except (stem.types.ProtocolError, stem.types.SocketError), exc: + raised_exc = exc + + control_socket_file.close() # done with the linked file + + if not keep_alive or raised_exc: + # shut down the socket we were using + try: control_socket.shutdown(socket.SHUT_RDWR) + except socket.error: pass + + control_socket.close() + else: + # if we're keeping the socket open then attach it to the response + protocolinfo_response.socket = control_socket + + if raised_exc: + raise raised_exc + else: + # if we have an unresolved cookie path then try to expand it again, using + # our port to infer a pid + + cookie_path = protocolinfo_response.cookie_file + if cookie_path and control_addr == "127.0.0.1" and stem.util.system.is_relative_path(cookie_path): + try: + tor_pid = stem.util.system.get_pid_by_port(control_port) + if not tor_pid: raise IOError("pid lookup failed") + + tor_cwd = stem.util.system.get_cwd(tor_pid) + if not tor_cwd: raise IOError("cwd lookup failed") + + protocolinfo_response.cookie_file = stem.util.system.expand_path(cookie_path, tor_cwd) + except IOError, exc: + LOGGER.debug("unable to expand relative tor cookie path by port: %s" % exc) + + return protocolinfo_response + class ProtocolInfoResponse(stem.types.ControlMessage): """ Version one PROTOCOLINFO query response. @@ -166,7 +238,7 @@ class ProtocolInfoResponse(stem.types.ControlMessage): self.cookie_file = stem.util.system.expand_path(self.cookie_file, tor_cwd) except IOError, exc: - LOGGER.debug("unable to expand relative tor cookie path: %s" % exc) + LOGGER.debug("unable to expand relative tor cookie path by name: %s" % exc) elif line_type == "VERSION": # Line format: # VersionLine = "250-VERSION" SP "Tor=" TorVersion OptArguments CRLF diff --git a/test/integ/connection/protocolinfo.py b/test/integ/connection/protocolinfo.py index 27b5f1f..73a7884 100644 --- a/test/integ/connection/protocolinfo.py +++ b/test/integ/connection/protocolinfo.py @@ -1,20 +1,21 @@ """ -Integration tests for the stem.connections.ProtocolInfoResponse class. +Integration tests for the stem.connections.ProtocolInfoResponse class and +related functions. """ -import socket import unittest import test.runner import stem.types import stem.connection -class TestProtocolInfoResponse(unittest.TestCase): +class TestProtocolInfo(unittest.TestCase): """ - Processes a ProtocolInfo query for a variety of setups. + Queries and parses PROTOCOLINFO. This should be run with the 'CONNECTION' + integ target to exercise the widest range of use cases. """ - def testProtocolInfoResponse(self): + def test_parsing(self): """ Makes a PROTOCOLINFO query and processes the response for our control connection. @@ -29,7 +30,7 @@ class TestProtocolInfoResponse(unittest.TestCase): control_socket = runner.get_tor_socket(False) control_socket_file = control_socket.makefile() - control_socket_file.write("PROTOCOLINFO\r\n") + control_socket_file.write("PROTOCOLINFO 1\r\n") control_socket_file.flush() protocolinfo_response = stem.types.read_message(control_socket_file) @@ -42,24 +43,52 @@ class TestProtocolInfoResponse(unittest.TestCase): self.assertNotEqual(None, protocolinfo_response.tor_version) self.assertNotEqual(None, protocolinfo_response.auth_methods) - self.assertEqual((), protocolinfo_response.unknown_auth_methods) self.assertEqual(None, protocolinfo_response.socket) + self.assert_protocolinfo_attr(protocolinfo_response, connection_type) + + def test_get_protocolinfo_port(self): + """ + Exercises the stem.connection.get_protocolinfo_port function. + """ + + connection_type = test.runner.get_runner().get_connection_type() + + if test.runner.OPT_PORT in test.runner.CONNECTION_OPTS[connection_type]: + protocolinfo_response = stem.connection.get_protocolinfo_port(control_port = test.runner.CONTROL_PORT) + self.assertEqual(None, protocolinfo_response.socket) + self.assert_protocolinfo_attr(protocolinfo_response, connection_type) + else: + # we don't have a control port + self.assertRaises(stem.types.SocketError, stem.connection.get_protocolinfo_port, "127.0.0.1", test.runner.CONTROL_PORT) + + def assert_protocolinfo_attr(self, protocolinfo_response, connection_type): + """ + Makes assertions that the protocolinfo response's attributes match those of + a given connection type. + """ + + # This should never have test.runner.TorConnection.NONE. If we somehow got + # a protocolinfo_response from that config then we have an issue. :) if connection_type == test.runner.TorConnection.NO_AUTH: - self.assertEqual((stem.connection.AuthMethod.NONE,), protocolinfo_response.auth_methods) - self.assertEqual(None, protocolinfo_response.cookie_file) + auth_methods = (stem.connection.AuthMethod.NONE,) elif connection_type == test.runner.TorConnection.PASSWORD: - self.assertEqual((stem.connection.AuthMethod.PASSWORD,), protocolinfo_response.auth_methods) - self.assertEqual(None, protocolinfo_response.cookie_file) + auth_methods = (stem.connection.AuthMethod.PASSWORD,) elif connection_type == test.runner.TorConnection.COOKIE: - self.assertEqual((stem.connection.AuthMethod.COOKIE,), protocolinfo_response.auth_methods) - self.assertEqual(runner.get_auth_cookie_path(), protocolinfo_response.cookie_file) + auth_methods = (stem.connection.AuthMethod.COOKIE,) elif connection_type == test.runner.TorConnection.MULTIPLE: - self.assertEqual((stem.connection.AuthMethod.COOKIE, stem.connection.AuthMethod.PASSWORD), protocolinfo_response.auth_methods) - self.assertEqual(runner.get_auth_cookie_path(), protocolinfo_response.cookie_file) + auth_methods = (stem.connection.AuthMethod.COOKIE, stem.connection.AuthMethod.PASSWORD) elif connection_type == test.runner.TorConnection.SOCKET: - self.assertEqual((stem.connection.AuthMethod.NONE,), protocolinfo_response.auth_methods) - self.assertEqual(None, protocolinfo_response.cookie_file) + auth_methods = (stem.connection.AuthMethod.NONE,) else: self.fail("Unrecognized connection type: %s" % connection_type) + + self.assertEqual((), protocolinfo_response.unknown_auth_methods) + self.assertEqual(auth_methods, protocolinfo_response.auth_methods) + + if test.runner.OPT_COOKIE in test.runner.CONNECTION_OPTS[connection_type]: + auth_cookie_path = test.runner.get_runner().get_auth_cookie_path() + self.assertEqual(auth_cookie_path, protocolinfo_response.cookie_file) + else: + self.assertEqual(None, protocolinfo_response.cookie_file)

1 0

[stem/master] Integ target for running with a relative data dir
by atagar＠torproject.org 21 Nov '11

21 Nov '11

commit d3b8f0aed7d715721724a7a94e96a188f1ee4e79 Author: Damian Johnson <atagar(a)torproject.org> Date: Mon Nov 21 10:13:10 2011 -0800 Integ target for running with a relative data dir Having a relative path for our data directory can cause headaches since tor then provides relative paths for the data it gives (for instance, for the authentication cookie location). Adding an integration testing target to have a relative data directory, to better exercise the path expansion code. --- run_tests.py | 3 ++- test/integ/util/system.py | 13 +++++++------ test/runner.py | 30 +++++++++++++++++++++++++++--- test/testrc.sample | 4 ++++ 4 files changed, 40 insertions(+), 10 deletions(-) diff --git a/run_tests.py b/run_tests.py index 76e1abb..93a715a 100755 --- a/run_tests.py +++ b/run_tests.py @@ -47,10 +47,11 @@ INTEG_TESTS = (("stem.types.ControlMessage", test.integ.types.control_message.Te ) # Integration tests above the basic suite. -TARGETS = stem.util.enum.Enum(*[(v, v) for v in ("ONLINE", "CONNECTION")]) +TARGETS = stem.util.enum.Enum(*[(v, v) for v in ("ONLINE", "RELATIVE", "CONNECTION")]) TARGET_ATTR = { TARGETS.ONLINE: ("test.integ.target.online", "Includes tests that require network activity."), + TARGETS.RELATIVE: ("test.integ.target.relative_data_dir", "Uses a relative path for tor's data directory."), TARGETS.CONNECTION: ("test.integ.target.connection", "Runs the suite over multiple connection configurations."), } diff --git a/test/integ/util/system.py b/test/integ/util/system.py index 9785400..dfce42d 100644 --- a/test/integ/util/system.py +++ b/test/integ/util/system.py @@ -175,9 +175,8 @@ class TestSystem(unittest.TestCase): Checks general usage of the stem.util.system.get_cwd function. """ - # tor's pwd will match our process since we started it runner = test.runner.get_runner() - self.assertEquals(os.getcwd(), stem.util.system.get_cwd(runner.get_pid())) + self.assertEquals(runner.get_tor_cwd(), stem.util.system.get_cwd(runner.get_pid())) self.assertEquals(None, stem.util.system.get_cwd(99999)) def test_get_cwd_pwdx(self): @@ -192,8 +191,9 @@ class TestSystem(unittest.TestCase): pwdx_prefix = stem.util.system.GET_CWD_PWDX % "" stem.util.system.CALL_MOCKING = lambda cmd: cmd.startswith(pwdx_prefix) - runner_pid = test.runner.get_runner().get_pid() - self.assertEquals(os.getcwd(), stem.util.system.get_cwd(runner_pid)) + runner = test.runner.get_runner() + runner_pid, tor_cwd = runner.get_pid(), runner.get_tor_cwd() + self.assertEquals(tor_cwd, stem.util.system.get_cwd(runner_pid)) def test_get_cwd_lsof(self): """ @@ -207,8 +207,9 @@ class TestSystem(unittest.TestCase): lsof_prefix = "lsof -a -p " stem.util.system.CALL_MOCKING = lambda cmd: cmd.startswith(lsof_prefix) - runner_pid = test.runner.get_runner().get_pid() - self.assertEquals(os.getcwd(), stem.util.system.get_cwd(runner_pid)) + runner = test.runner.get_runner() + runner_pid, tor_cwd = runner.get_pid(), runner.get_tor_cwd() + self.assertEquals(tor_cwd, stem.util.system.get_cwd(runner_pid)) def test_get_bsd_jail_id(self): """ diff --git a/test/runner.py b/test/runner.py index 9d26deb..b9b77f4 100644 --- a/test/runner.py +++ b/test/runner.py @@ -36,6 +36,7 @@ DEFAULT_CONFIG = { "test.integ.test_directory": "./test/data", "test.integ.log": "./test/data/log", "test.integ.target.online": False, + "test.integ.target.relative_data_dir": False, } # Methods for connecting to tor. General integration tests only run with the @@ -113,6 +114,7 @@ class Runner: # runtime attributes, set by the start method self._test_dir = "" + self._tor_cwd = "" self._torrc_contents = "" self._connection_type = None self._tor_process = None @@ -125,8 +127,8 @@ class Runner: Arguments: connection_type (TorConnection) - method for controllers to authenticate to tor - quiet (bool) - if False then this prints status information as we - start up to stdout + quiet (bool) - if False then this prints status information as we start + up to stdout Raises: OSError if unable to run test preparations or start tor @@ -153,12 +155,26 @@ class Runner: else: self._test_dir = tempfile.mktemp("-stem-integ") + original_cwd, data_dir_path = os.getcwd(), self._test_dir + + if self._config["test.integ.target.relative_data_dir"]: + 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) + self._connection_type = connection_type - self._torrc_contents = get_torrc(connection_type) % self._test_dir + self._torrc_contents = get_torrc(connection_type) % data_dir_path try: + self._tor_cwd = os.getcwd() self._run_setup(quiet) self._start_tor(quiet) + + # revert our cwd back to normal + if self._config["test.integ.target.relative_data_dir"]: + os.chdir(original_cwd) except OSError, exc: self.stop(quiet) raise exc @@ -185,6 +201,7 @@ class Runner: shutil.rmtree(self._test_dir, ignore_errors = True) self._test_dir = "" + self._tor_cwd = "" self._torrc_contents = "" self._connection_type = None self._tor_process = None @@ -244,6 +261,13 @@ class Runner: 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_torrc_contents(self): """ Provides the contents of our torrc. diff --git a/test/testrc.sample b/test/testrc.sample index 83f0861..c7ae7d1 100644 --- a/test/testrc.sample +++ b/test/testrc.sample @@ -16,6 +16,9 @@ # Runs tests with network activity. If set then we'll wait for tor to fully # bootstrap when starting, which won't happen without a network connection. # +# test.integ.target.relative_data_dir +# Uses a relative path for the tor data directory if set. +# # test.integ.target.connection # Runs integration tests for multiple connection and authentiction methods if # true. Otherwise they'll only be run for a single connection type. @@ -23,5 +26,6 @@ test.integ.test_directory ./test/data test.integ.log ./test/data/log test.integ.target.online false +test.integ.target.relative_data_dir false test.integ.target.connection false

1 0

[stem/master] Function to query PROTOCOLINFO via control socket
by atagar＠torproject.org 21 Nov '11

21 Nov '11

commit 56c2ea8c33e63456dc1316f3936439478e12cc03 Author: Damian Johnson <atagar(a)torproject.org> Date: Mon Nov 21 09:21:21 2011 -0800 Function to query PROTOCOLINFO via control socket Same as before, implementation and integ sanity check for making a PROTOCOLINFO query via a control socket. This has the common bits between it, the control port function, and a bit of the PROTOCOLINFO response parsing delegated to helper functions. --- stem/connection.py | 122 +++++++++++++++++++++++---------- test/integ/connection/protocolinfo.py | 29 ++++++-- test/unit/connection/protocolinfo.py | 12 ++-- 3 files changed, 114 insertions(+), 49 deletions(-) diff --git a/stem/connection.py b/stem/connection.py index 3e97e9e..476c9c3 100644 --- a/stem/connection.py +++ b/stem/connection.py @@ -1,5 +1,17 @@ """ Functions for connecting and authenticating to the tor process. + +get_protocolinfo_by_port - PROTOCOLINFO query via a control port. +get_protocolinfo_by_socket - PROTOCOLINFO query via a control socket. +ProtocolInfoResponse - Reply from a PROTOCOLINFO query. + |- Attributes: + | |- protocol_version + | |- tor_version + | |- auth_methods + | |- unknown_auth_methods + | |- cookie_path + | +- socket + +- convert - parses a ControlMessage, turning it into a ProtocolInfoResponse """ import Queue @@ -28,7 +40,7 @@ LOGGER = logging.getLogger("stem") AuthMethod = stem.util.enum.Enum("NONE", "PASSWORD", "COOKIE", "UNKNOWN") -def get_protocolinfo_port(control_addr = "127.0.0.1", control_port = 9051, keep_alive = False): +def get_protocolinfo_by_port(control_addr = "127.0.0.1", control_port = 9051, keep_alive = False): """ Issues a PROTOCOLINFO query to a control port, getting information about the tor process running on it. @@ -49,12 +61,50 @@ def get_protocolinfo_port(control_addr = "127.0.0.1", control_port = 9051, keep_ """ control_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) + connection_args = (control_addr, control_port) + protocolinfo_response = _get_protocolinfo_impl(control_socket, connection_args, keep_alive) + + # attempt to expand relative cookie paths using our port to infer the pid + protocolinfo_response.cookie_path = _expand_cookie_path(protocolinfo_response.cookie_path, stem.util.system.get_pid_by_port, control_port) + + return protocolinfo_response + +def get_protocolinfo_by_socket(socket_path = "/var/run/tor/control", keep_alive = False): + """ + Issues a PROTOCOLINFO query to a control socket, getting information about + the tor process running on it. + + Arguments: + socket_path (str) - path where the control socket is located + keep_alive (bool) - keeps the socket used to issue the PROTOCOLINFO query + open if True, closes otherwise + + Raises: + stem.types.ProtocolError if the PROTOCOLINFO response is malformed + stem.types.SocketError if problems arise in establishing or using the + socket + """ + + control_socket = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) + protocolinfo_response = _get_protocolinfo_impl(control_socket, socket_path, keep_alive) + + # attempt to expand relative cookie paths using our socket to infer the pid + protocolinfo_response.cookie_path = _expand_cookie_path(protocolinfo_response.cookie_path, stem.util.system.get_pid_by_open_file, socket_path) + + return protocolinfo_response + +def _get_protocolinfo_impl(control_socket, connection_args, keep_alive): + """ + Common implementation behind the get_protocolinfo_by_* functions. This + connects the given socket and issues a PROTOCOLINFO query with it. + """ + control_socket_file = control_socket.makefile() protocolinfo_response, raised_exc = None, None try: # initiates connection - control_socket.connect((control_addr, control_port)) + control_socket.connect(connection_args) # issues the PROTOCOLINFO query control_socket_file.write("PROTOCOLINFO 1\r\n") @@ -79,26 +129,36 @@ def get_protocolinfo_port(control_addr = "127.0.0.1", control_port = 9051, keep_ # if we're keeping the socket open then attach it to the response protocolinfo_response.socket = control_socket - if raised_exc: - raise raised_exc - else: - # if we have an unresolved cookie path then try to expand it again, using - # our port to infer a pid - - cookie_path = protocolinfo_response.cookie_file - if cookie_path and control_addr == "127.0.0.1" and stem.util.system.is_relative_path(cookie_path): - try: - tor_pid = stem.util.system.get_pid_by_port(control_port) - if not tor_pid: raise IOError("pid lookup failed") - - tor_cwd = stem.util.system.get_cwd(tor_pid) - if not tor_cwd: raise IOError("cwd lookup failed") - - protocolinfo_response.cookie_file = stem.util.system.expand_path(cookie_path, tor_cwd) - except IOError, exc: - LOGGER.debug("unable to expand relative tor cookie path by port: %s" % exc) - - return protocolinfo_response + if raised_exc: raise raised_exc + else: return protocolinfo_response + +def _expand_cookie_path(cookie_path, pid_resolver, pid_resolution_arg): + """ + Attempts to expand a relative cookie path with the given pid resolver. This + returns the input path if it's already absolute, None, or the system calls + fail. + """ + + if cookie_path and stem.util.system.is_relative_path(cookie_path): + try: + tor_pid = pid_resolver(pid_resolution_arg) + if not tor_pid: raise IOError("pid lookup failed") + + tor_cwd = stem.util.system.get_cwd(tor_pid) + if not tor_cwd: raise IOError("cwd lookup failed") + + cookie_path = stem.util.system.expand_path(cookie_path, tor_cwd) + except IOError, exc: + resolver_labels = { + stem.util.system.get_pid_by_name: " by name", + stem.util.system.get_pid_by_port: " by port", + stem.util.system.get_pid_by_open_file: " by socket file", + } + + pid_resolver_label = resolver_labels.get(pid_resolver, "") + LOGGER.debug("unable to expand relative tor cookie path%s: %s" % (pid_resolver_label, exc)) + + return cookie_path class ProtocolInfoResponse(stem.types.ControlMessage): """ @@ -119,7 +179,7 @@ class ProtocolInfoResponse(stem.types.ControlMessage): tor_version (stem.types.Version) - version of the tor process auth_methods (tuple) - AuthMethod types that tor will accept unknown_auth_methods (tuple) - strings of unrecognized auth methods - cookie_file (str) - path of tor's authentication cookie + cookie_path (str) - path of tor's authentication cookie socket (socket.socket) - socket used to make the query """ @@ -155,7 +215,7 @@ class ProtocolInfoResponse(stem.types.ControlMessage): self.protocol_version = None self.tor_version = None - self.cookie_file = None + self.cookie_path = None self.socket = None auth_methods, unknown_auth_methods = [], [] @@ -225,20 +285,10 @@ class ProtocolInfoResponse(stem.types.ControlMessage): # parse optional COOKIEFILE mapping (quoted and can have escapes) if line.is_next_mapping("COOKIEFILE", True, True): - self.cookie_file = line.pop_mapping(True, True)[1] + self.cookie_path = line.pop_mapping(True, True)[1] # attempt to expand relative cookie paths - if stem.util.system.is_relative_path(self.cookie_file): - try: - tor_pid = stem.util.system.get_pid_by_name("tor") - if not tor_pid: raise IOError("pid lookup failed") - - tor_cwd = stem.util.system.get_cwd(tor_pid) - if not tor_cwd: raise IOError("cwd lookup failed") - - self.cookie_file = stem.util.system.expand_path(self.cookie_file, tor_cwd) - except IOError, exc: - LOGGER.debug("unable to expand relative tor cookie path by name: %s" % exc) + self.cookie_path = _expand_cookie_path(self.cookie_path, stem.util.system.get_pid_by_name, "tor") elif line_type == "VERSION": # Line format: # VersionLine = "250-VERSION" SP "Tor=" TorVersion OptArguments CRLF diff --git a/test/integ/connection/protocolinfo.py b/test/integ/connection/protocolinfo.py index 73a7884..037f6dd 100644 --- a/test/integ/connection/protocolinfo.py +++ b/test/integ/connection/protocolinfo.py @@ -46,20 +46,35 @@ class TestProtocolInfo(unittest.TestCase): self.assertEqual(None, protocolinfo_response.socket) self.assert_protocolinfo_attr(protocolinfo_response, connection_type) - def test_get_protocolinfo_port(self): + def test_get_protocolinfo_by_port(self): """ - Exercises the stem.connection.get_protocolinfo_port function. + Exercises the stem.connection.get_protocolinfo_by_port function. """ connection_type = test.runner.get_runner().get_connection_type() if test.runner.OPT_PORT in test.runner.CONNECTION_OPTS[connection_type]: - protocolinfo_response = stem.connection.get_protocolinfo_port(control_port = test.runner.CONTROL_PORT) + protocolinfo_response = stem.connection.get_protocolinfo_by_port(control_port = test.runner.CONTROL_PORT) self.assertEqual(None, protocolinfo_response.socket) self.assert_protocolinfo_attr(protocolinfo_response, connection_type) else: # we don't have a control port - self.assertRaises(stem.types.SocketError, stem.connection.get_protocolinfo_port, "127.0.0.1", test.runner.CONTROL_PORT) + self.assertRaises(stem.types.SocketError, stem.connection.get_protocolinfo_by_port, "127.0.0.1", test.runner.CONTROL_PORT) + + def test_get_protocolinfo_by_socket(self): + """ + Exercises the stem.connection.get_protocolinfo_by_socket function. + """ + + connection_type = test.runner.get_runner().get_connection_type() + + if test.runner.OPT_SOCKET in test.runner.CONNECTION_OPTS[connection_type]: + protocolinfo_response = stem.connection.get_protocolinfo_by_socket(socket_path = test.runner.CONTROL_SOCKET_PATH) + self.assertEqual(None, protocolinfo_response.socket) + self.assert_protocolinfo_attr(protocolinfo_response, connection_type) + else: + # we don't have a control socket + self.assertRaises(stem.types.SocketError, stem.connection.get_protocolinfo_by_socket, test.runner.CONTROL_SOCKET_PATH) def assert_protocolinfo_attr(self, protocolinfo_response, connection_type): """ @@ -86,9 +101,9 @@ class TestProtocolInfo(unittest.TestCase): self.assertEqual((), protocolinfo_response.unknown_auth_methods) self.assertEqual(auth_methods, protocolinfo_response.auth_methods) + auth_cookie_path = None if test.runner.OPT_COOKIE in test.runner.CONNECTION_OPTS[connection_type]: auth_cookie_path = test.runner.get_runner().get_auth_cookie_path() - self.assertEqual(auth_cookie_path, protocolinfo_response.cookie_file) - else: - self.assertEqual(None, protocolinfo_response.cookie_file) + + self.assertEqual(auth_cookie_path, protocolinfo_response.cookie_path) diff --git a/test/unit/connection/protocolinfo.py b/test/unit/connection/protocolinfo.py index fc9ab64..3014cbb 100644 --- a/test/unit/connection/protocolinfo.py +++ b/test/unit/connection/protocolinfo.py @@ -89,7 +89,7 @@ class TestProtocolInfoResponse(unittest.TestCase): self.assertEquals(stem.types.Version("0.2.1.30"), control_message.tor_version) self.assertEquals((stem.connection.AuthMethod.NONE, ), control_message.auth_methods) self.assertEquals((), control_message.unknown_auth_methods) - self.assertEquals(None, control_message.cookie_file) + self.assertEquals(None, control_message.cookie_path) self.assertEquals(None, control_message.socket) def test_password_auth(self): @@ -110,7 +110,7 @@ class TestProtocolInfoResponse(unittest.TestCase): control_message = stem.types.read_message(StringIO.StringIO(COOKIE_AUTH)) stem.connection.ProtocolInfoResponse.convert(control_message) self.assertEquals((stem.connection.AuthMethod.COOKIE, ), control_message.auth_methods) - self.assertEquals("/tmp/my data\\\"dir//control_auth_cookie", control_message.cookie_file) + self.assertEquals("/tmp/my data\\\"dir//control_auth_cookie", control_message.cookie_path) def test_multiple_auth(self): """ @@ -120,7 +120,7 @@ class TestProtocolInfoResponse(unittest.TestCase): control_message = stem.types.read_message(StringIO.StringIO(MULTIPLE_AUTH)) stem.connection.ProtocolInfoResponse.convert(control_message) self.assertEquals((stem.connection.AuthMethod.COOKIE, stem.connection.AuthMethod.PASSWORD), control_message.auth_methods) - self.assertEquals("/home/atagar/.tor/control_auth_cookie", control_message.cookie_file) + self.assertEquals("/home/atagar/.tor/control_auth_cookie", control_message.cookie_path) def test_unknown_auth(self): """ @@ -145,7 +145,7 @@ class TestProtocolInfoResponse(unittest.TestCase): self.assertEquals(None , control_message.tor_version) self.assertEquals((), control_message.auth_methods) self.assertEquals((), control_message.unknown_auth_methods) - self.assertEquals(None, control_message.cookie_file) + self.assertEquals(None, control_message.cookie_path) self.assertEquals(None, control_message.socket) def test_relative_cookie(self): @@ -169,7 +169,7 @@ class TestProtocolInfoResponse(unittest.TestCase): control_message = stem.types.read_message(StringIO.StringIO(RELATIVE_COOKIE_PATH)) stem.connection.ProtocolInfoResponse.convert(control_message) - self.assertEquals("/tmp/foo/tor-browser_en-US/Data/control_auth_cookie", control_message.cookie_file) + self.assertEquals("/tmp/foo/tor-browser_en-US/Data/control_auth_cookie", control_message.cookie_path) # exercise cookie expansion where both calls fail (should work, just # leaving the path unexpanded) @@ -177,7 +177,7 @@ class TestProtocolInfoResponse(unittest.TestCase): stem.util.system.CALL_MOCKING = lambda cmd: None control_message = stem.types.read_message(StringIO.StringIO(RELATIVE_COOKIE_PATH)) stem.connection.ProtocolInfoResponse.convert(control_message) - self.assertEquals("./tor-browser_en-US/Data/control_auth_cookie", control_message.cookie_file) + self.assertEquals("./tor-browser_en-US/Data/control_auth_cookie", control_message.cookie_path) # reset system call mocking stem.util.system.CALL_MOCKING = None

1 0

[tor/master] All NT service configuration commands should make the process exit.
by nickm＠torproject.org 21 Nov '11

21 Nov '11

commit 45eadf39551bc1d3d00e677c8b7fd977a17aad01 Author: Nick Mathewson <nickm(a)torproject.org> Date: Thu Sep 8 21:54:12 2011 -0400 All NT service configuration commands should make the process exit. Fixes bug 3963; fix on 0.2.0.7-alpha. --- changes/bug3963 | 5 +++++ src/or/ntmain.c | 2 +- 2 files changed, 6 insertions(+), 1 deletions(-) diff --git a/changes/bug3963 b/changes/bug3963 new file mode 100644 index 0000000..2fc44a0 --- /dev/null +++ b/changes/bug3963 @@ -0,0 +1,5 @@ + o Minor bugfixes: + - When configuring, starting, or stopping an NT service, stop + immediately after the service configuration attempt has succeeded + or failed. Fixes bug3963; bugfix on 0.2.0.7-alpha. + diff --git a/src/or/ntmain.c b/src/or/ntmain.c index b2fee64..985fab7 100644 --- a/src/or/ntmain.c +++ b/src/or/ntmain.c @@ -728,6 +728,7 @@ nt_service_parse_options(int argc, char **argv, int *should_exit) if ((argc >= 3) && (!strcmp(argv[1], "-service") || !strcmp(argv[1], "--service"))) { nt_service_loadlibrary(); + *should_exit = 1; if (!strcmp(argv[2], "install")) return nt_service_install(argc, argv); if (!strcmp(argv[2], "remove")) @@ -737,7 +738,6 @@ nt_service_parse_options(int argc, char **argv, int *should_exit) if (!strcmp(argv[2], "stop")) return nt_service_cmd_stop(); printf("Unrecognized service command '%s'\n", argv[2]); - *should_exit = 1; return 1; } if (argc >= 2) {

1 0

[tor/master] Merge remote-tracking branch 'origin/maint-0.2.2'
by nickm＠torproject.org 21 Nov '11

21 Nov '11

commit 929074b368fe94cbe74a49e5353a35f60c6623af Merge: 0539c34 b3c988f Author: Nick Mathewson <nickm(a)torproject.org> Date: Mon Nov 21 10:52:38 2011 -0500 Merge remote-tracking branch 'origin/maint-0.2.2' changes/bug3963 | 5 +++++ src/or/ntmain.c | 2 +- 2 files changed, 6 insertions(+), 1 deletions(-)

1 0

[tor/master] Merge remote-tracking branch 'public/bug3963' into maint-0.2.2
by nickm＠torproject.org 21 Nov '11

21 Nov '11

commit b3c988f0d7e18c243074e3e583c10b204521088f Merge: fbcd7c0 45eadf3 Author: Nick Mathewson <nickm(a)torproject.org> Date: Mon Nov 21 10:52:15 2011 -0500 Merge remote-tracking branch 'public/bug3963' into maint-0.2.2 changes/bug3963 | 5 +++++ src/or/ntmain.c | 2 +- 2 files changed, 6 insertions(+), 1 deletions(-)

1 0

[tor/maint-0.2.2] All NT service configuration commands should make the process exit.
by nickm＠torproject.org 21 Nov '11

21 Nov '11

1 0

← Newer
1
...
32
33
34
35
36
37
38
...
99
Older →

Jump to page:

2025

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

tor-commits November 2011