Some stuff

2 files changed, 172 insertions, 76 deletions

diff --git a/lib/chutney/TorNet.py b/lib/chutney/TorNet.py
index 5697fdd..4ddda49 100644
--- a/lib/chutney/TorNet.py
+++ b/lib/chutney/TorNet.py
@@ -1,4 +1,3 @@
-#!/usr/bin/python
 #
 # Copyright 2011 Nick Mathewson, Michael Stone
 # Copyright 2013 The Tor Project
@@ -21,6 +20,7 @@ import re
 import errno
 import time
 import thread
+import random
 
 import stem.control
 
@@ -33,6 +33,8 @@ import urllib
 import socks
 import pycurl
 
+import Queue
+
 import chutney.Templating
 import chutney.Traffic
 
@@ -117,13 +119,13 @@ class Node(object):
         self._env['nodenum'] = num
 
     def query(self, url):
-        print("querying %i at port %i" % (self._env['nodenum'], self._env['socksport']))
+        #print("querying %i at port %i" % (self._env['nodenum'], self._env['socksport']))
 
         socks.setdefaultproxy(socks.PROXY_TYPE_SOCKS5, '127.0.0.1', self._env['socksport'])
         socket.socket = socks.socksocket
 
         def getaddrinfo(*args):
-            print("getaddrinfo " + str(args))
+            #print("getaddrinfo " + str(args))
             return [(socket.AF_INET, socket.SOCK_STREAM, 6, '', (args[0], args[1]))]
 
         socket.getaddrinfo = getaddrinfo
@@ -449,8 +451,6 @@ class LocalNodeController(NodeController):
         if pid is None:
             return False
 
-        print("checking if " + str(pid) + " is running")
-
         try:
             os.kill(pid, 0) # "kill 0" == "are you there?"
         except OSError, e:
@@ -688,12 +688,9 @@ class Network(object):
 
     def stop(self):
 
-        print("Closing all stem controllers")
         for n in self._nodes:
             if n._stemcontroller:
-                print("Closed stem controller")
                 n._stemcontroller.close()
-        print("Closed all stem controllers")
 
         controllers = [ n.getController() for n in self._nodes ]
         for sig, desc in [(signal.SIGINT, "SIGINT"),
@@ -705,12 +702,9 @@ class Network(object):
                     c.stop(sig=sig)
             print "Waiting for nodes to finish."
             for n in xrange(10):
-                print("loop " + str(n))
                 time.sleep(1)
-                print("after sleep")
                 if all(not c.isRunning() for c in controllers):
                     return
-                print("printing dot")
                 sys.stdout.write(".")
                 sys.stdout.flush()
             for c in controllers:
@@ -747,6 +741,11 @@ def usage(network):
         " ".join(x for x in dir(network) if not x.startswith("_")))])
 
 def runConfigFile(verb, f):
+    def stop(exitcode=0):
+        _THE_NETWORK.stop()
+        print("Network stoped, exiting")
+        sys.exit(exitcode)
+
     _GLOBALS = dict(_BASE_ENVIRON = _BASE_ENVIRON,
                     Node=Node,
                     EventType=stem.control.EventType,
@@ -755,6 +754,10 @@ def runConfigFile(verb, f):
                     reactor=reactor,
                     time=time,
                     thread=thread,
+                    Queue=Queue,
+                    random=random,
+                    log=log,
+                    stop=stop,
                     _THE_NETWORK=_THE_NETWORK)
 
     exec f in _GLOBALS
@@ -774,6 +777,9 @@ def runConfigFile(verb, f):
 
     return getattr(network, verb)()
 
+def log(string):
+    print(time.strftime("%b %d %H:%M:%S.000") + " " + str(string))
+
 def signal_handler(signal, frame):
     _THE_NETWORK.stop()
     print("Network stoped, exiting")
@@ -792,7 +798,7 @@ def main():
 
     f = open(sys.argv[2])
     result = runConfigFile(sys.argv[1], f)
-    print("run config file returns " + str(result))
+    #print("run config file returns " + str(result))
     if result is False:
         sys.exit(-1)
 
diff --git a/networks/hs-intro-fail b/networks/hs-intro-fail
index 222136c..3b18d0b 100644
--- a/networks/hs-intro-fail
+++ b/networks/hs-intro-fail
@@ -11,75 +11,93 @@ Relay = Node.create(10, {
     "torrc": "intro.tmpl"
 })
 
-Client = Node.create(4, {
+Client = Node.create(6, {
     "tag": "c",
     "torrc": "client.tmpl"
 })
 
-initialNodes = Authority + Relay + Client
+initial_nodes = Authority + Relay + Client
 
-HiddenService = Node(
+# hidden service (hs) nodes
+
+hs_node_1 = Node(
     tag="h",
     hiddenservice=1,
     torrc="hidden-service.tmpl",
     hiddenservicetarget="127.0.0.1:8081"
 )
 
-initialNodes.append(HiddenService)
+initial_nodes.append(hs_node_1)
 
-DelayedHiddenService = Node(
+hs_node_2 = Node(
     tag="h",
     hiddenservice=1,
     torrc="hidden-service.tmpl",
     hiddenservicetarget="127.0.0.1:8082"
 )
 
-#nodes = {}
+hs_nodes = (hs_node_1, hs_node_2)
+
+nodes_by_fingerprint = {}
 
-#for node in initialNodes + [ DelayedHiddenService ]:
-#    nodes[node._env.nodenum] = node
+#{ nodenum: { circuit: "fingerprint", circuit: "fingerprint" } }
 
 # Introduction Point Tracking
 
-nodeIntroCircuits = {}
+node_intro_circuits = {}
+
+node_intro_events = {}
 
-def trackIntroductionPoints(node):
+def track_introduction_points(node):
     nodenum = node._env["nodenum"]
-    nodeIntroCircuits[nodenum] = {}
+    nodenick = node._env["nick"]
 
-    def listener(logevent):
-        if not (logevent.message.startswith("rend_services_introduce") or
-                logevent.message.startswith("rend_service_launch_establish_intro") or
-                logevent.message.startswith("rend_service_intro_has_opened")):
-            return
+    node_intro_circuits[nodenum] = {}
 
-        #print(logevent.message)
+    node_intro_events[nodenum] = Queue.Queue()
 
-        """prefix = "rend_service_launch_establish_intro(): Launched circuit "
+    def listener(logevent):
+        prefix = "rend_service_intro_has_opened(): Established circuit "
         if logevent.message.startswith(prefix):
             circuit = logevent.message[len(prefix):].split(" ")[0]
-            introid = logevent.message[len(prefix):].split(" ")[4]
+            fingerprint = logevent.message[len(prefix):].split(" ")[1][1:]
 
-            nodeCircuits[nodenum][circuit] = introid
-            return
+            node_intro_circuits[nodenum][circuit] = fingerprint
 
-        prefix = "rend_service_launch_establish_intro(): The intro circuit "
-        if logevent.message.startswith(prefix):
-            circuit = logevent.message[len(prefix):].split(" ")[0]
-            introid = logevent.message[len(prefix):].split(" ")[6]
+            added_intro_node = nodes_by_fingerprint[fingerprint]
 
-            nodeCircuits[nodenum][circuit] = introid
-            return"""
+            log("%s: added %s (%s)" % (nodenick, added_intro_node._env["nick"], fingerprint))
 
-        prefix = "rend_service_intro_has_opened(): Established circuit "
-        if logevent.message.startswith(prefix):
-            circuit = logevent.message[len(prefix):].split(" ")[0]
-            introid = logevent.message[len(prefix):].split(" ")[1]
+            node_intro_events[nodenum].put(("added", fingerprint))
+
+        prefix = "rend_services_introduce(): Giving up on "
+        if logevent.message.startswith(prefix) or "Giving up on" in logevent.message:
+            log(logevent.message)
+            fingerprint = logevent.message[len(prefix):].split(" ")[0][1:41]
+
+            for_deletion = []
+
+            for circuit, fp in node_intro_circuits[nodenum].iteritems():
+                #log("circuit " + str(circuit) + " fp " + str(fp))
+                if fingerprint == fp:
+                    for_deletion.append(circuit)
+
+            if len(for_deletion) == 0:
+                log("got log message " + logevent.message + " but not deleting an introduction point")
+
+            for circuit in for_deletion:
+                fingerprint = node_intro_circuits[nodenum][circuit]
+
+                removed_intro_node = nodes_by_fingerprint[fingerprint]
+
+                log("%s: removed %s (%s)" % (nodenick, removed_intro_node._env["nick"], fingerprint))
+
+                node_intro_events[nodenum].put(("removed", fingerprint))
+                del node_intro_circuits[nodenum][circuit]
 
-            nodeIntroCircuits[nodenum][circuit] = introid
-            return
 
     node.getStemController().add_event_listener(listener, EventType.INFO)
+    log("Tracking introduction points for " + node._env["nick"])
 
 # Use twisted to create web servers in this script
 class Site(resource.Resource):
@@ -95,74 +113,146 @@ class Site(resource.Resource):
         return str(self.siteNum)
 
 def start_test():
-    print("Starting test")
+    log("Starting test")
 
     port8081 = reactor.listenTCP(8081, server.Site(Site(1)))
     port8082 = reactor.listenTCP(8082, server.Site(Site(2)))
 
     def cleanup():
         port8081.stopListening()
-        print("stopped 8081")
+        log("stopped 8081")
         port8082.stopListening()
-        print("stopped 8082")
+        log("stopped 8082")
         reactor.stop()
-        print("stopped the reactor")
+        log("stopped the reactor")
 
-    def test():
-        print("connecting to clients")
+    def watch_for_new_intro_points():
+        log("begining to watch for the establishment of new introduction points")
+
+        changed = [False for n in hs_nodes]
+
+        intro_points_before = [set(node_intro_circuits[n._env["nodenum"]].values()) for n in hs_nodes]
+
+        time.sleep(60)
+
+        intro_points_after = [set(node_intro_circuits[n._env["nodenum"]].values()) for n in hs_nodes]
+
+        for i, node in enumerate(hs_nodes):
+            before = intro_points_before[i]
+            after = intro_points_after[i]
+
+            if before != after:
+                changed[i] = True
+
+        if all(changed):
+            log("All changed")
+        else:
+            log("All did not change")
+
+        check_same_intro_points()
+
+        connection_test()
+
+        cleanup()
+
+        stop()
+
+    def connection_test():
+        log("connecting to clients")
         responses = {"1": 0, "2": 0}
 
         for c in Client:
             result = c.query("http://2oiifbe3wne4iaqb.onion/");
 
-            responses[result] += 1
+            if result in responses:
+                responses[result] += 1
+            else:
+                log("Unknown response:")
 
-            print(result)
+        log(responses)
 
-        print(responses)
+    def test():
+        connection_test()
 
         time.sleep(5)
 
-        print("disabling an introduction point")
+        # Clear out the event queues such that the events are relevant
+        for node in hs_nodes:
+            nodenum = node._env["nodenum"]
 
-        # Need to be able to tell which introduction points are being used
+            log("replaced queue")
+            node_intro_events[nodenum] = Queue.Queue()
 
-        cleanup()
+        # Select a random node that is being used as an introduction point
+        nodenum = random.choice(node_intro_circuits.keys())
+        fingerprint = random.choice(node_intro_circuits[nodenum].values())
+
+        node = nodes_by_fingerprint[fingerprint]
+
+        log("stopping " + node._env["nick"] + " (" + fingerprint + ")")
+
+        node.getController().stop()
+
+        watch_for_new_intro_points()
 
     thread.start_new_thread(test, ())
 
-    print("running reactor")
+    log("running reactor")
+
     reactor.run(installSignalHandlers=0)
 
+def check_same_intro_points():
+    intro_sets = []
+    for introduction_points in node_intro_circuits.values():
+        intro_sets.append(set(introduction_points.values()))
+
+    if intro_sets[0].issubset(intro_sets[1]) and intro_sets[1].issubset(intro_sets[0]):
+        log("Same introduction points")
+        for fingerprint in node_intro_circuits.values()[0].values():
+            node = nodes_by_fingerprint[fingerprint]
+            log(" - " + node._env["nick"] + "(" + fingerprint + ")")
+        return True
+    else:
+        log("Not the same introduction points")
+        for num, circuits in node_intro_circuits.items():
+            log("node %i" % num)
+            for fingerprint in circuits.values():
+                node = nodes_by_fingerprint[fingerprint]
+                log(" - " + node._env["nick"] + "(" + fingerprint + ")")
+        return False
+
 def start():
-    print("Starting hidden service test")
+    log("Starting hidden service test")
 
-    if not all([ n.getController().start() for n in initialNodes ]):
+    if not all([ n.getController().start() for n in initial_nodes ]):
         return False
-    else:
-        print("All initial nodes running")
 
-    trackIntroductionPoints(HiddenService)
+    log("All initial nodes running")
 
-    def start_listener(logevent):
-        # Probably after what needs waiting for
-        if "Successfully uploaded v2 rend descriptors" in logevent.message:
-            print("Node Circuits")
-            print(nodeIntroCircuits)
+    for n in Authority + Relay:
+        fingerprint = n.getStemController().get_info("fingerprint")
+        nodes_by_fingerprint[fingerprint] = n
 
-            start_test()
+    track_introduction_points(hs_node_1)
 
     def log_listener(logevent):
         if "Successfully uploaded v2 rend descriptors" in logevent.message:
-            print("log message: " + logevent.message)
+            hs_node_1.getStemController().remove_event_listener(log_listener)
+
+            def start_listener(logevent):
+
+                # Probably after what needs waiting for
+                if "Successfully uploaded v2 rend descriptors" in logevent.message:
+                    hs_node_2.getStemController().remove_event_listener(start_listener)
 
-            print("Node Circuits")
-            print(nodeIntroCircuits)
+                    if check_same_intro_points():
+                        thread.start_new_thread(start_test, ())
+                        log("finished running start_test in another thread")
 
-            DelayedHiddenService.getController().start()
+            hs_node_2.getController().start()
 
-            DelayedHiddenService.getStemController().add_event_listener(start_listener, EventType.INFO)
+            track_introduction_points(hs_node_2)
 
-            trackIntroductionPoints(DelayedHiddenService)
+            hs_node_2.getStemController().add_event_listener(start_listener, EventType.INFO)
 
-    HiddenService.getStemController().add_event_listener(log_listener, EventType.INFO)
+    hs_node_1.getStemController().add_event_listener(log_listener, EventType.INFO)