class TorState(object): """ This tracks the current state of Tor using a TorControlProtocol. On setup it first queries the initial state of streams and circuits. It then asks for updates via the listeners. It requires an ITorControlProtocol instance. The control protocol doesn't need to be bootstrapped yet. The Deferred .post_boostrap is driggered when the TorState instance is fully ready to go. The easiest way is to use the helper method :func:`txtorcon.build_tor_connection`. For details, see the implementation of that. You may add an :class:`txtorcon.interface.IStreamAttacher` to provide a custom mapping for Strams to Circuits (by default Tor picks by itself). This is also a good example of the various listeners, and acts as an :class:`txtorcon.interface.ICircuitContainer` and :class:`txtorcon.interface.IRouterContainer`. """ implements(ICircuitListener, ICircuitContainer, IRouterContainer, IStreamListener) def __init__(self, protocol, bootstrap=True, write_state_diagram=False): self.protocol = ITorControlProtocol(protocol) ## fixme could use protocol.on_disconnect to re-connect; see issue #3 ## could override these to get your own Circuit/Stream subclasses ## to track these things self.circuit_factory = Circuit self.stream_factory = Stream self.attacher = None """If set, provides :class:`txtorcon.interface.IStreamAttacher` to attach new streams we hear about.""" self.tor_binary = 'tor' self.circuit_listeners = [] self.stream_listeners = [] self.addrmap = AddrMap() self.circuits = {} # keys on id (integer) self.streams = {} # keys on id (integer) self.routers = {} # keys by hexid (string) and by unique names self.routers_by_name = {} # keys on name, value always list (many duplicate "Unnamed" routers, for example) self.guards = {} # potentially-usable as entry guards, I think? (any router with 'Guard' flag) self.entry_guards = {} # from GETINFO entry-guards, our current entry guards self.unusable_entry_guards = [] # list of entry guards we didn't parse out self.authorities = {} # keys by name self.cleanup = None # see set_attacher class die(object): __name__ = 'die' # FIXME? just to ease spagetti.py:82's pain def __init__(self, msg): self.msg = msg def __call__(self, *args): raise RuntimeError(self.msg % tuple(args)) def nothing(*args): pass waiting_r = State("waiting_r") waiting_w = State("waiting_w") waiting_p = State("waiting_p") waiting_s = State("waiting_s") def ignorable_line(x): return x.strip() == '.' or x.strip() == 'OK' or x[:3] == 'ns/' or x.strip() == '' waiting_r.add_transition(Transition(waiting_r, ignorable_line, nothing)) waiting_r.add_transition(Transition(waiting_s, lambda x: x[:2] == 'r ', self._router_begin)) ## FIXME use better method/func than die!! waiting_r.add_transition(Transition(waiting_r, lambda x: x[:2] != 'r ', die('Expected "r " while parsing routers not "%s"'))) waiting_s.add_transition(Transition(waiting_w, lambda x: x[:2] == 's ', self._router_flags)) waiting_s.add_transition(Transition(waiting_s, lambda x: x[:2] == 'a ', self._router_address)) waiting_s.add_transition(Transition(waiting_r, ignorable_line, nothing)) waiting_s.add_transition(Transition(waiting_r, lambda x: x[:2] != 's ' and x[:2] != 'a ', die('Expected "s " while parsing routers not "%s"'))) waiting_s.add_transition(Transition(waiting_r, lambda x: x.strip() == '.', nothing)) waiting_w.add_transition(Transition(waiting_p, lambda x: x[:2] == 'w ', self._router_bandwidth)) waiting_w.add_transition(Transition(waiting_r, ignorable_line, nothing)) waiting_w.add_transition(Transition(waiting_s, lambda x: x[:2] == 'r ', self._router_begin)) # "w" lines are optional waiting_w.add_transition(Transition(waiting_r, lambda x: x[:2] != 'w ', die('Expected "w " while parsing routers not "%s"'))) waiting_w.add_transition(Transition(waiting_r, lambda x: x.strip() == '.', nothing)) waiting_p.add_transition(Transition(waiting_r, lambda x: x[:2] == 'p ', self._router_policy)) waiting_p.add_transition(Transition(waiting_r, ignorable_line, nothing)) waiting_p.add_transition(Transition(waiting_s, lambda x: x[:2] == 'r ', self._router_begin)) # "p" lines are optional waiting_p.add_transition(Transition(waiting_r, lambda x: x[:2] != 'p ', die('Expected "p " while parsing routers not "%s"'))) waiting_p.add_transition(Transition(waiting_r, lambda x: x.strip() == '.', nothing)) self._network_status_parser = FSM([waiting_r, waiting_s, waiting_w, waiting_p]) if write_state_diagram: with open('routerfsm.dot', 'w') as fsmfile: fsmfile.write(self._network_status_parser.dotty()) self.post_bootstrap = defer.Deferred() if bootstrap: if self.protocol.post_bootstrap: self.protocol.post_bootstrap.addCallback(self._bootstrap).addErrback(self.post_bootstrap.errback) else: self._bootstrap() def _router_begin(self, data): args = data.split() self._router = Router(self.protocol) self._router.from_consensus = True self._router.update(args[1], # nickname args[2], # idhash args[3], # orhash datetime.datetime.strptime(args[4] + args[5], '%Y-%m-%f%H:%M:%S'), args[6], # ip address args[7], # ORPort args[8]) # DirPort if self._router.id_hex in self.routers: ## FIXME should I do an update() on this one?? self._router = self.routers[self._router.id_hex] return if self._router.name in self.routers_by_name: self.routers_by_name[self._router.name].append(self._router) else: self.routers_by_name[self._router.name] = [self._router] if self._router.name in self.routers: self.routers[self._router.name] = None else: self.routers[self._router.name] = self._router self.routers[self._router.id_hex] = self._router def _router_flags(self, data): args = data.split() self._router.flags = args[1:] if 'guard' in self._router.flags: self.guards[self._router.id_hex] = self._router if 'authority' in self._router.flags: self.authorities[self._router.name] = self._router def _router_address(self, data): """only for IPv6 addresses""" self._router.ip_v6.append(data.split()[1].strip()) def _router_bandwidth(self, data): args = data.split() self._router.bandwidth = int(args[1].split('=')[1]) def _router_policy(self, data): args = data.split() self._router.policy = args[1:] self._router = None @defer.inlineCallbacks def _bootstrap(self, arg=None): "This takes an arg so we can use it as a callback (see __init__)." ## update list of routers (must be before we do the ## circuit-status) note that we're feeding each line ## incrementally to a state-machine called ## _network_status_parser, set up in constructor. "ns" should ## be the empty string, but we call _update_network_status for ## the de-duplication of named routers ns = yield self.protocol.get_info_incremental('ns/all', self._network_status_parser.process) self._update_network_status(ns) ## update list of existing circuits cs = yield self.protocol.get_info_raw('circuit-status') self._circuit_status(cs) ## update list of streams ss = yield self.protocol.get_info_raw('stream-status') self._stream_status(ss) ## update list of existing address-maps key = 'address-mappings/all' am = yield self.protocol.get_info_raw(key) ## strip addressmappsings/all= and OK\n from raw data am = am[len(key) + 1:] if am.strip() != 'OK': for line in am.split('\n')[:-1]: if len(line.strip()) == 0: continue # FIXME self.addrmap.update(line) self._add_events() entries = yield self.protocol.get_info_raw("entry-guards") for line in entries.split('\n')[1:]: if len(line.strip()) == 0 or line.strip() == 'OK': continue args = line.split() (name, status) = args[:2] name = name[:41] ## this is sometimes redundant, as a missing entry guard ## usually means it won't be in our list of routers right ## now, but just being on the safe side if status.lower() != 'up': self.unusable_entry_guards.append(line) continue try: self.entry_guards[name] = self.router_from_id(name) except KeyError: self.unusable_entry_guards.append(line) ## in case process/pid doesn't exist and we don't know the PID ## because we own it, we just leave it as 0 (previously ## guessed using psutil, but that only works if there's ## exactly one tor running anyway) try: pid = yield self.protocol.get_info_raw("process/pid") except TorProtocolError: pid = None self.tor_pid = 0 if pid: try: pid = parse_keywords(pid)['process/pid'] self.tor_pid = int(pid) except KeyError: self.tor_pid = 0 elif self.protocol.is_owned: self.tor_pid = self.protocol.is_owned self.post_bootstrap.callback(self) self.post_boostrap = None def undo_attacher(self): """ Shouldn't Tor handle this by turning this back to 0 if the controller that twiddled it disconnects? """ return self.protocol.set_conf("__LeaveStreamsUnattached", 0) def set_attacher(self, attacher, myreactor): """ Provide an :class:`txtorcon.interface.IStreamAttacher to associate streams to circuits. This won't get turned on until after bootstrapping is completed. ('__LeaveStreamsUnattached' needs to be set to '1' and the existing circuits list needs to be populated). """ react = IReactorCore(myreactor) if attacher: self.attacher = IStreamAttacher(attacher) else: self.attacher = None if self.attacher is None: self.undo_attacher() if self.cleanup: react.removeSystemEventTrigger(self.cleanup) self.cleanup = None else: self.protocol.set_conf("__LeaveStreamsUnattached", "1") self.cleanup = react.addSystemEventTrigger('before', 'shutdown', self.undo_attacher) return None stream_close_reasons = { 'REASON_MISC': 1, # (catch-all for unlisted reasons) 'REASON_RESOLVEFAILED': 2, # (couldn't look up hostname) 'REASON_CONNECTREFUSED': 3, # (remote host refused connection) [*] 'REASON_EXITPOLICY': 4, # (OR refuses to connect to host or port) 'REASON_DESTROY': 5, # (Circuit is being destroyed) 'REASON_DONE': 6, # (Anonymized TCP connection was closed) 'REASON_TIMEOUT': 7, # (Connection timed out, or OR timed out while connecting) 'REASON_NOROUTE': 8, # (Routing error while attempting to contact destination) 'REASON_HIBERNATING': 9, # (OR is temporarily hibernating) 'REASON_INTERNAL': 10, # (Internal error at the OR) 'REASON_RESOURCELIMIT': 11, # (OR has no resources to fulfill request) 'REASON_CONNRESET': 12, # (Connection was unexpectedly reset) 'REASON_TORPROTOCOL': 13, # (Sent when closing connection because of Tor protocol violations.) 'REASON_NOTDIRECTORY': 14} # (Client sent RELAY_BEGIN_DIR to a non-directory relay.) def close_stream(self, stream, reason='REASON_MISC', **kwargs): """ This sends a STREAMCLOSE command, using the specified reason (either an int or one of the 14 strings in section 6.3 of tor-spec.txt if the argument is a string). Any kwards are passed through as flags if they evaluated to true (e.g. "SomeFlag=True"). Currently there are none that Tor accepts. """ if type(stream) != int: ## assume it's a Stream instance stream = stream.id try: reason = int(reason) except ValueError: try: reason = TorState.stream_close_reasons[reason] except KeyError: raise ValueError('Unknown stream close reason "%s"' % str(reason)) flags = flags_from_dict(kwargs) ## stream is now an ID no matter what we passed in cmd = 'CLOSESTREAM %d %d%s' % (stream, reason, flags) return self.protocol.queue_command(cmd) def close_circuit(self, circid, **kwargs): """ This sends a CLOSECIRCUIT command, using any keyword arguments passed as the Flags (currently, that is just 'IfUnused' which means to only close the circuit when it is no longer used by any streams). :return: a Deferred which callbacks with the result of queuing the command to Tor (usually "OK"). If you want to instead know when the circuit is actually-gone, see :meth:`Circuit.close <txtorcon.circuit.Circuit.close>` """ if type(circid) != int: ## assume it's a Circuit instance circid = circid.id flags = flags_from_dict(kwargs) return self.protocol.queue_command('CLOSECIRCUIT %s%s' % (circid, flags)) def add_circuit_listener(self, icircuitlistener): listen = ICircuitListener(icircuitlistener) for circ in self.circuits.values(): circ.listen(listen) self.circuit_listeners.append(listen) def add_stream_listener(self, istreamlistener): listen = IStreamListener(istreamlistener) for stream in self.streams.values(): stream.listen(listen) self.stream_listeners.append(listen) def _find_circuit_after_extend(self, x): ex, circ_id = x.split() if ex != 'EXTENDED': raise RuntimeError('Expected EXTENDED, got "%s"' % x) circ_id = int(circ_id) circ = self._maybe_create_circuit(circ_id) circ.update([str(circ_id), 'EXTENDED']) return circ def build_circuit(self, routers=None): """ Builds a circuit consisting of exactly the routers specified, in order. This issues an EXTENDCIRCUIT call to Tor with all the routers specified. :param routers: a list of Router instances which is the path desired. A warming is issued if the first one isn't in self.entry_guards To allow Tor to choose the routers itself, pass None (the default) for routers. :return: A Deferred that will callback with a Circuit instance (with the .id member being valid, and probably nothing else). """ if routers is None or routers == []: cmd = "EXTENDCIRCUIT 0" else: if routers[0] not in self.entry_guards.values(): warnings.warn("Building a circuit not starting with a guard: %s" % (str(routers),), RuntimeWarning) cmd = "EXTENDCIRCUIT 0 " first = True for router in routers: if first: first = False else: cmd += ',' if isinstance(router, types.StringType) and len(router) == 40 and hashFromHexId(router): cmd += router else: cmd += router.id_hex[1:] d = self.protocol.queue_command(cmd) d.addCallback(self._find_circuit_after_extend) return d DO_NOT_ATTACH = object() def _maybe_attach(self, stream): """ If we've got a custom stream-attachment instance (see set_attacher) this will ask it for the appropriate circuit. Note that we ignore .exit URIs and let Tor deal with those (by passing circuit ID 0). The stream attacher is allowed to return a Deferred which will callback with the desired circuit. You may return the special object DO_NOT_ATTACH which will cause the circuit attacher to simply ignore the stream (neither attaching it, nor telling Tor to attach it). """ if self.attacher: if stream.target_host is not None and '.exit' in stream.target_host: ## we want to totally ignore .exit URIs as these are ## used to specify a particular exit node, and trying ## to do STREAMATTACH on them will fail with an error ## from Tor anyway. txtorlog.msg("ignore attacher:", stream) return circ = IStreamAttacher(self.attacher).attach_stream(stream, self.circuits) if circ is self.DO_NOT_ATTACH: return if circ is None: self.protocol.queue_command("ATTACHSTREAM %d 0" % stream.id) else: if isinstance(circ, defer.Deferred): class IssueStreamAttach: def __init__(self, state, streamid): self.stream_id = streamid self.state = state def __call__(self, arg): circid = arg.id self.state.protocol.queue_command("ATTACHSTREAM %d %d" % (self.stream_id, circid)) circ.addCallback(IssueStreamAttach(self, stream.id)).addErrback(log.err) else: if circ.id not in self.circuits: raise RuntimeError("Attacher returned a circuit unknown to me.") if circ.state != 'BUILT': raise RuntimeError("Can only attach to BUILT circuits; %d is in %s." % (circ.id, circ.state)) self.protocol.queue_command("ATTACHSTREAM %d %d" % (stream.id, circ.id)) def _circuit_status(self, data): """Used internally as a callback for updating Circuit information""" data = data[len('circuit-status='):].split('\n')[:-1] ## sometimes there's a newline after circuit-status= and ## sometimes not, so we get rid of it if len(data) and len(data[0].strip()) == 0: data = data[1:] for line in data: self._circuit_update(line) def _stream_status(self, data): "Used internally as a callback for updating Stream information" # there's a slight issue with a single-stream vs >= 2 streams, # in that in the latter case we have a line by itself with # "stream-status=" on it followed by the streams EXCEPT in the # single-stream case which has "stream-status=123 blahblah" # (i.e. the key + value on one line) lines = data.split('\n')[:-1] if len(lines) == 1: d = lines[0][len('stream-status='):] # if there are actually 0 streams, then there's nothing # left to parse if len(d): self._stream_update(d) else: [self._stream_update(line) for line in lines[1:]] def _update_network_status(self, data): """ Used internally as a callback for updating Router information from NS and NEWCONSENSUS events. """ for line in data.split('\n'): self._network_status_parser.process(line) txtorlog.msg(len(self.routers_by_name), "named routers found.") ## remove any names we added that turned out to have dups for (k, v) in self.routers.items(): if v is None: txtorlog.msg(len(self.routers_by_name[k]), "dups:", k) del self.routers[k] txtorlog.msg(len(self.guards), "GUARDs") def _maybe_create_circuit(self, circ_id): if circ_id not in self.circuits: c = self.circuit_factory(self) c.listen(self) [c.listen(x) for x in self.circuit_listeners] else: c = self.circuits[circ_id] return c def _circuit_update(self, line): """ Used internally as a callback to update Circuit information from CIRC events. """ #print "circuit_update",line args = line.split() circ_id = int(args[0]) c = self._maybe_create_circuit(circ_id) c.update(args) def _stream_update(self, line): """ Used internally as a callback to update Stream information from STREAM events. """ #print "stream_update",line if line.strip() == 'stream-status=': ## this happens if there are no active streams return args = line.split() assert len(args) >= 3 stream_id = int(args[0]) wasnew = False if stream_id not in self.streams: stream = self.stream_factory(self) self.streams[stream_id] = stream stream.listen(self) [stream.listen(x) for x in self.stream_listeners] wasnew = True self.streams[stream_id].update(args) ## if the update closed the stream, it won't be in our list ## anymore. FIXME: how can we ever hit such a case as the ## first update being a CLOSE? if wasnew and stream_id in self.streams: self._maybe_attach(self.streams[stream_id]) def _addr_map(self, addr): "Internal callback to update DNS cache. Listens to ADDRMAP." txtorlog.msg(" --> addr_map", addr) self.addrmap.update(addr) event_map = {'STREAM': _stream_update, 'CIRC': _circuit_update, 'NS': _update_network_status, 'NEWCONSENSUS': _update_network_status, 'ADDRMAP': _addr_map} """event_map used by add_events to map event_name -> unbound method""" @defer.inlineCallbacks def _add_events(self): """ Add listeners for all the events the controller is interested in. """ for (event, func) in self.event_map.items(): ## the map contains unbound methods, so we bind them ## to self so they call the right thing yield self.protocol.add_event_listener(event, types.MethodType(func, self, TorState)) ## ICircuitContainer def find_circuit(self, circid): "ICircuitContainer API" return self.circuits[circid] ## IRouterContainer def router_from_id(self, routerid): """IRouterContainer API""" try: return self.routers[routerid[:41]] except KeyError: if routerid[0] != '$': raise # just re-raise the KeyError router = Router(self.protocol) idhash = routerid[1:41] nick = '' is_named = False if len(routerid) > 41: nick = routerid[42:] is_named = routerid[41] == '=' router.update(nick, hashFromHexId(idhash), '0' * 27, 'unknown', 'unknown', '0', '0') router.name_is_unique = is_named self.routers[router.id_hex] = router return router ## implement IStreamListener def stream_new(self, stream): "IStreamListener: a new stream has been created" txtorlog.msg("stream_new", stream) def stream_succeeded(self, stream): "IStreamListener: stream has succeeded" txtorlog.msg("stream_succeeded", stream) def stream_attach(self, stream, circuit): """ IStreamListener: the stream has been attached to a circuit. It seems you get an attach to None followed by an attach to real circuit fairly frequently. Perhaps related to __LeaveStreamsUnattached? """ txtorlog.msg("stream_attach", stream.id, stream.target_host, " -> ", circuit) def stream_detach(self, stream, **kw): """ IStreamListener """ txtorlog.msg("stream_detach", stream.id) def stream_closed(self, stream, **kw): """ IStreamListener: stream has been closed (won't be in controller's list anymore) """ txtorlog.msg("stream_closed", stream.id) del self.streams[stream.id] def stream_failed(self, stream, **kw): """ IStreamListener: stream failed for some reason (won't be in controller's list anymore) """ txtorlog.msg("stream_failed", stream.id) del self.streams[stream.id] ## implement ICircuitListener def circuit_launched(self, circuit): "ICircuitListener API" txtorlog.msg("circuit_launched", circuit) self.circuits[circuit.id] = circuit def circuit_extend(self, circuit, router): "ICircuitListener API" txtorlog.msg("circuit_extend:", circuit.id, router) def circuit_built(self, circuit): "ICircuitListener API" txtorlog.msg("circuit_built:", circuit.id, "->".join("%s.%s" % (x.name, x.location.countrycode) for x in circuit.path), circuit.streams) def circuit_new(self, circuit): "ICircuitListener API" txtorlog.msg("circuit_new:", circuit.id) self.circuits[circuit.id] = circuit def circuit_destroy(self, circuit): "Used by circuit_closed and circuit_failed (below)" txtorlog.msg("circuit_destroy:", circuit.id) del self.circuits[circuit.id] def circuit_closed(self, circuit, **kw): "ICircuitListener API" txtorlog.msg("circuit_closed", circuit) self.circuit_destroy(circuit) def circuit_failed(self, circuit, **kw): "ICircuitListener API" txtorlog.msg("circuit_failed", circuit, str(kw)) self.circuit_destroy(circuit)
class TorState(object): """ This tracks the current state of Tor using a TorControlProtocol. On setup it first queries the initial state of streams and circuits. It then asks for updates via the listeners. It requires an ITorControlProtocol instance. The control protocol doesn't need to be bootstrapped yet. The Deferred .post_boostrap is driggered when the TorState instance is fully ready to go. The easiest way is to use the helper method :func:`txtorcon.build_tor_connection`. For details, see the implementation of that. You may add an :class:`txtorcon.interface.IStreamAttacher` to provide a custom mapping for Strams to Circuits (by default Tor picks by itself). This is also a good example of the various listeners, and acts as an :class:`txtorcon.interface.ICircuitContainer` and :class:`txtorcon.interface.IRouterContainer`. """ implements(ICircuitListener, ICircuitContainer, IRouterContainer, IStreamListener) def __init__(self, protocol, bootstrap=True, write_state_diagram=False): self.protocol = ITorControlProtocol(protocol) ## fixme could use protocol.on_disconnect to re-connect; see issue #3 ## could override these to get your own Circuit/Stream subclasses ## to track these things self.circuit_factory = Circuit self.stream_factory = Stream self.attacher = None """If set, provides :class:`txtorcon.interface.IStreamAttacher` to attach new streams we hear about.""" self.tor_binary = 'tor' self.circuit_listeners = [] self.stream_listeners = [] self.addrmap = AddrMap() self.circuits = {} # keys on id (integer) self.streams = {} # keys on id (integer) self.routers = {} # keys by hexid (string) and by unique names self.routers_by_name = { } # keys on name, value always list (many duplicate "Unnamed" routers, for example) self.guards = { } # potentially-usable as entry guards, I think? (any router with 'Guard' flag) self.entry_guards = { } # from GETINFO entry-guards, our current entry guards self.unusable_entry_guards = [ ] # list of entry guards we didn't parse out self.authorities = {} # keys by name self.cleanup = None # see set_attacher class die(object): __name__ = 'die' # FIXME? just to ease spagetti.py:82's pain def __init__(self, msg): self.msg = msg def __call__(self, *args): raise RuntimeError(self.msg % tuple(args)) def nothing(*args): pass waiting_r = State("waiting_r") waiting_w = State("waiting_w") waiting_p = State("waiting_p") waiting_s = State("waiting_s") def ignorable_line(x): return x.strip() == '.' or x.strip( ) == 'OK' or x[:3] == 'ns/' or x.strip() == '' waiting_r.add_transition(Transition(waiting_r, ignorable_line, nothing)) waiting_r.add_transition( Transition(waiting_s, lambda x: x[:2] == 'r ', self._router_begin)) ## FIXME use better method/func than die!! waiting_r.add_transition( Transition(waiting_r, lambda x: x[:2] != 'r ', die('Expected "r " while parsing routers not "%s"'))) waiting_s.add_transition( Transition(waiting_w, lambda x: x[:2] == 's ', self._router_flags)) waiting_s.add_transition( Transition(waiting_s, lambda x: x[:2] == 'a ', self._router_address)) waiting_s.add_transition(Transition(waiting_r, ignorable_line, nothing)) waiting_s.add_transition( Transition(waiting_r, lambda x: x[:2] != 's ' and x[:2] != 'a ', die('Expected "s " while parsing routers not "%s"'))) waiting_s.add_transition( Transition(waiting_r, lambda x: x.strip() == '.', nothing)) waiting_w.add_transition( Transition(waiting_p, lambda x: x[:2] == 'w ', self._router_bandwidth)) waiting_w.add_transition(Transition(waiting_r, ignorable_line, nothing)) waiting_w.add_transition( Transition(waiting_s, lambda x: x[:2] == 'r ', self._router_begin)) # "w" lines are optional waiting_w.add_transition( Transition(waiting_r, lambda x: x[:2] != 'w ', die('Expected "w " while parsing routers not "%s"'))) waiting_w.add_transition( Transition(waiting_r, lambda x: x.strip() == '.', nothing)) waiting_p.add_transition( Transition(waiting_r, lambda x: x[:2] == 'p ', self._router_policy)) waiting_p.add_transition(Transition(waiting_r, ignorable_line, nothing)) waiting_p.add_transition( Transition(waiting_s, lambda x: x[:2] == 'r ', self._router_begin)) # "p" lines are optional waiting_p.add_transition( Transition(waiting_r, lambda x: x[:2] != 'p ', die('Expected "p " while parsing routers not "%s"'))) waiting_p.add_transition( Transition(waiting_r, lambda x: x.strip() == '.', nothing)) self._network_status_parser = FSM( [waiting_r, waiting_s, waiting_w, waiting_p]) if write_state_diagram: with open('routerfsm.dot', 'w') as fsmfile: fsmfile.write(self._network_status_parser.dotty()) self.post_bootstrap = defer.Deferred() if bootstrap: if self.protocol.post_bootstrap: self.protocol.post_bootstrap.addCallback( self._bootstrap).addErrback(self.post_bootstrap.errback) else: self._bootstrap() def _router_begin(self, data): args = data.split() self._router = Router(self.protocol) self._router.from_consensus = True self._router.update( args[1], # nickname args[2], # idhash args[3], # orhash datetime.datetime.strptime(args[4] + args[5], '%Y-%m-%f%H:%M:%S'), args[6], # ip address args[7], # ORPort args[8]) # DirPort if self._router.id_hex in self.routers: ## FIXME should I do an update() on this one?? self._router = self.routers[self._router.id_hex] return if self._router.name in self.routers_by_name: self.routers_by_name[self._router.name].append(self._router) else: self.routers_by_name[self._router.name] = [self._router] if self._router.name in self.routers: self.routers[self._router.name] = None else: self.routers[self._router.name] = self._router self.routers[self._router.id_hex] = self._router def _router_flags(self, data): args = data.split() self._router.flags = args[1:] if 'guard' in self._router.flags: self.guards[self._router.id_hex] = self._router if 'authority' in self._router.flags: self.authorities[self._router.name] = self._router def _router_address(self, data): """only for IPv6 addresses""" self._router.ip_v6.append(data.split()[1].strip()) def _router_bandwidth(self, data): args = data.split() self._router.bandwidth = int(args[1].split('=')[1]) def _router_policy(self, data): args = data.split() self._router.policy = args[1:] self._router = None @defer.inlineCallbacks def _bootstrap(self, arg=None): "This takes an arg so we can use it as a callback (see __init__)." ## update list of routers (must be before we do the ## circuit-status) note that we're feeding each line ## incrementally to a state-machine called ## _network_status_parser, set up in constructor. "ns" should ## be the empty string, but we call _update_network_status for ## the de-duplication of named routers ns = yield self.protocol.get_info_incremental( 'ns/all', self._network_status_parser.process) self._update_network_status(ns) ## update list of existing circuits cs = yield self.protocol.get_info_raw('circuit-status') self._circuit_status(cs) ## update list of streams ss = yield self.protocol.get_info_raw('stream-status') self._stream_status(ss) ## update list of existing address-maps key = 'address-mappings/all' am = yield self.protocol.get_info_raw(key) ## strip addressmappsings/all= and OK\n from raw data am = am[len(key) + 1:] for line in am.split('\n'): if len(line.strip()) == 0: continue # FIXME self.addrmap.update(line) self._add_events() entries = yield self.protocol.get_info_raw("entry-guards") for line in entries.split('\n')[1:]: if len(line.strip()) == 0 or line.strip() == 'OK': continue args = line.split() (name, status) = args[:2] name = name[:41] ## this is sometimes redundant, as a missing entry guard ## usually means it won't be in our list of routers right ## now, but just being on the safe side if status.lower() != 'up': self.unusable_entry_guards.append(line) continue try: self.entry_guards[name] = self.router_from_id(name) except KeyError: self.unusable_entry_guards.append(line) ## in case process/pid doesn't exist and we don't know the PID ## because we own it, we just leave it as 0 (previously ## guessed using psutil, but that only works if there's ## exactly one tor running anyway) try: pid = yield self.protocol.get_info_raw("process/pid") except TorProtocolError: pid = None self.tor_pid = 0 if pid: try: pid = parse_keywords(pid)['process/pid'] self.tor_pid = int(pid) except KeyError: self.tor_pid = 0 elif self.protocol.is_owned: self.tor_pid = self.protocol.is_owned self.post_bootstrap.callback(self) self.post_boostrap = None def undo_attacher(self): """ Shouldn't Tor handle this by turning this back to 0 if the controller that twiddled it disconnects? """ return self.protocol.set_conf("__LeaveStreamsUnattached", 0) def set_attacher(self, attacher, myreactor): """ Provide an :class:`txtorcon.interface.IStreamAttacher` to associate streams to circuits. This won't get turned on until after bootstrapping is completed. ('__LeaveStreamsUnattached' needs to be set to '1' and the existing circuits list needs to be populated). """ react = IReactorCore(myreactor) if attacher: self.attacher = IStreamAttacher(attacher) else: self.attacher = None if self.attacher is None: self.undo_attacher() if self.cleanup: react.removeSystemEventTrigger(self.cleanup) self.cleanup = None else: self.protocol.set_conf("__LeaveStreamsUnattached", "1") self.cleanup = react.addSystemEventTrigger('before', 'shutdown', self.undo_attacher) return None stream_close_reasons = { 'REASON_MISC': 1, # (catch-all for unlisted reasons) 'REASON_RESOLVEFAILED': 2, # (couldn't look up hostname) 'REASON_CONNECTREFUSED': 3, # (remote host refused connection) [*] 'REASON_EXITPOLICY': 4, # (OR refuses to connect to host or port) 'REASON_DESTROY': 5, # (Circuit is being destroyed) 'REASON_DONE': 6, # (Anonymized TCP connection was closed) 'REASON_TIMEOUT': 7, # (Connection timed out, or OR timed out while connecting) 'REASON_NOROUTE': 8, # (Routing error while attempting to contact destination) 'REASON_HIBERNATING': 9, # (OR is temporarily hibernating) 'REASON_INTERNAL': 10, # (Internal error at the OR) 'REASON_RESOURCELIMIT': 11, # (OR has no resources to fulfill request) 'REASON_CONNRESET': 12, # (Connection was unexpectedly reset) 'REASON_TORPROTOCOL': 13, # (Sent when closing connection because of Tor protocol violations.) 'REASON_NOTDIRECTORY': 14 } # (Client sent RELAY_BEGIN_DIR to a non-directory relay.) def close_stream(self, stream, reason='REASON_MISC', **kwargs): """ This sends a STREAMCLOSE command, using the specified reason (either an int or one of the 14 strings in section 6.3 of tor-spec.txt if the argument is a string). Any kwards are passed through as flags if they evaluated to true (e.g. "SomeFlag=True"). Currently there are none that Tor accepts. """ if type(stream) != int: ## assume it's a Stream instance stream = stream.id try: reason = int(reason) except ValueError: try: reason = TorState.stream_close_reasons[reason] except KeyError: raise ValueError('Unknown stream close reason "%s"' % str(reason)) flags = flags_from_dict(kwargs) ## stream is now an ID no matter what we passed in cmd = 'CLOSESTREAM %d %d%s' % (stream, reason, flags) return self.protocol.queue_command(cmd) def close_circuit(self, circid, **kwargs): """ This sends a CLOSECIRCUIT command, using any keyword arguments passed as the Flags (currently, that is just 'IfUnused' which means to only close the circuit when it is no longer used by any streams). :param circid: Either a circuit-id (int) or a Circuit instance :return: a Deferred which callbacks with the result of queuing the command to Tor (usually "OK"). If you want to instead know when the circuit is actually-gone, see :meth:`Circuit.close <txtorcon.circuit.Circuit.close>` """ if type(circid) != int: ## assume it's a Circuit instance circid = circid.id flags = flags_from_dict(kwargs) return self.protocol.queue_command('CLOSECIRCUIT %s%s' % (circid, flags)) def add_circuit_listener(self, icircuitlistener): listen = ICircuitListener(icircuitlistener) for circ in self.circuits.values(): circ.listen(listen) self.circuit_listeners.append(listen) def add_stream_listener(self, istreamlistener): listen = IStreamListener(istreamlistener) for stream in self.streams.values(): stream.listen(listen) self.stream_listeners.append(listen) def _find_circuit_after_extend(self, x): ex, circ_id = x.split() if ex != 'EXTENDED': raise RuntimeError('Expected EXTENDED, got "%s"' % x) circ_id = int(circ_id) circ = self._maybe_create_circuit(circ_id) circ.update([str(circ_id), 'EXTENDED']) return circ def build_circuit(self, routers=None): """ Builds a circuit consisting of exactly the routers specified, in order. This issues an EXTENDCIRCUIT call to Tor with all the routers specified. :param routers: a list of Router instances which is the path desired. A warming is issued if the first one isn't in self.entry_guards To allow Tor to choose the routers itself, pass None (the default) for routers. :return: A Deferred that will callback with a Circuit instance (with the .id member being valid, and probably nothing else). """ if routers is None or routers == []: cmd = "EXTENDCIRCUIT 0" else: if routers[0] not in self.entry_guards.values(): warnings.warn( "Building a circuit not starting with a guard: %s" % (str(routers), ), RuntimeWarning) cmd = "EXTENDCIRCUIT 0 " first = True for router in routers: if first: first = False else: cmd += ',' if isinstance(router, types.StringType) and len( router) == 40 and hashFromHexId(router): cmd += router else: cmd += router.id_hex[1:] d = self.protocol.queue_command(cmd) d.addCallback(self._find_circuit_after_extend) return d DO_NOT_ATTACH = object() def _maybe_attach(self, stream): """ If we've got a custom stream-attachment instance (see set_attacher) this will ask it for the appropriate circuit. Note that we ignore .exit URIs and let Tor deal with those (by passing circuit ID 0). The stream attacher is allowed to return a Deferred which will callback with the desired circuit. You may return the special object DO_NOT_ATTACH which will cause the circuit attacher to simply ignore the stream (neither attaching it, nor telling Tor to attach it). """ if self.attacher: if stream.target_host is not None and '.exit' in stream.target_host: ## we want to totally ignore .exit URIs as these are ## used to specify a particular exit node, and trying ## to do STREAMATTACH on them will fail with an error ## from Tor anyway. txtorlog.msg("ignore attacher:", stream) return circ = IStreamAttacher(self.attacher).attach_stream( stream, self.circuits) if circ is self.DO_NOT_ATTACH: return if circ is None: self.protocol.queue_command("ATTACHSTREAM %d 0" % stream.id) else: if isinstance(circ, defer.Deferred): class IssueStreamAttach: def __init__(self, state, streamid): self.stream_id = streamid self.state = state def __call__(self, arg): circid = arg.id self.state.protocol.queue_command( "ATTACHSTREAM %d %d" % (self.stream_id, circid)) circ.addCallback(IssueStreamAttach( self, stream.id)).addErrback(log.err) else: if circ.id not in self.circuits: raise RuntimeError( "Attacher returned a circuit unknown to me.") if circ.state != 'BUILT': raise RuntimeError( "Can only attach to BUILT circuits; %d is in %s." % (circ.id, circ.state)) self.protocol.queue_command("ATTACHSTREAM %d %d" % (stream.id, circ.id)) def _circuit_status(self, data): """Used internally as a callback for updating Circuit information""" data = data[len('circuit-status='):].split('\n') ## sometimes there's a newline after circuit-status= and ## sometimes not, so we get rid of it if len(data) and len(data[0].strip()) == 0: data = data[1:] for line in data: self._circuit_update(line) def _stream_status(self, data): "Used internally as a callback for updating Stream information" # there's a slight issue with a single-stream vs >= 2 streams, # in that in the latter case we have a line by itself with # "stream-status=" on it followed by the streams EXCEPT in the # single-stream case which has "stream-status=123 blahblah" # (i.e. the key + value on one line) lines = data.split('\n') if len(lines) == 1: d = lines[0][len('stream-status='):] # if there are actually 0 streams, then there's nothing # left to parse if len(d): self._stream_update(d) else: [self._stream_update(line) for line in lines[1:]] def _update_network_status(self, data): """ Used internally as a callback for updating Router information from NS and NEWCONSENSUS events. """ for line in data.split('\n'): self._network_status_parser.process(line) txtorlog.msg(len(self.routers_by_name), "named routers found.") ## remove any names we added that turned out to have dups for (k, v) in self.routers.items(): if v is None: txtorlog.msg(len(self.routers_by_name[k]), "dups:", k) del self.routers[k] txtorlog.msg(len(self.guards), "GUARDs") def _maybe_create_circuit(self, circ_id): if circ_id not in self.circuits: c = self.circuit_factory(self) c.listen(self) [c.listen(x) for x in self.circuit_listeners] else: c = self.circuits[circ_id] return c def _circuit_update(self, line): """ Used internally as a callback to update Circuit information from CIRC events. """ #print "circuit_update",line args = line.split() circ_id = int(args[0]) c = self._maybe_create_circuit(circ_id) c.update(args) def _stream_update(self, line): """ Used internally as a callback to update Stream information from STREAM events. """ #print "stream_update",line if line.strip() == 'stream-status=': ## this happens if there are no active streams return args = line.split() assert len(args) >= 3 stream_id = int(args[0]) wasnew = False if stream_id not in self.streams: stream = self.stream_factory(self) self.streams[stream_id] = stream stream.listen(self) [stream.listen(x) for x in self.stream_listeners] wasnew = True self.streams[stream_id].update(args) ## if the update closed the stream, it won't be in our list ## anymore. FIXME: how can we ever hit such a case as the ## first update being a CLOSE? if wasnew and stream_id in self.streams: self._maybe_attach(self.streams[stream_id]) def _addr_map(self, addr): "Internal callback to update DNS cache. Listens to ADDRMAP." txtorlog.msg(" --> addr_map", addr) self.addrmap.update(addr) event_map = { 'STREAM': _stream_update, 'CIRC': _circuit_update, 'NS': _update_network_status, 'NEWCONSENSUS': _update_network_status, 'ADDRMAP': _addr_map } """event_map used by add_events to map event_name -> unbound method""" @defer.inlineCallbacks def _add_events(self): """ Add listeners for all the events the controller is interested in. """ for (event, func) in self.event_map.items(): ## the map contains unbound methods, so we bind them ## to self so they call the right thing yield self.protocol.add_event_listener( event, types.MethodType(func, self, TorState)) ## ICircuitContainer def find_circuit(self, circid): "ICircuitContainer API" return self.circuits[circid] ## IRouterContainer def router_from_id(self, routerid): """IRouterContainer API""" try: return self.routers[routerid[:41]] except KeyError: if routerid[0] != '$': raise # just re-raise the KeyError router = Router(self.protocol) idhash = routerid[1:41] nick = '' is_named = False if len(routerid) > 41: nick = routerid[42:] is_named = routerid[41] == '=' router.update(nick, hashFromHexId(idhash), '0' * 27, 'unknown', 'unknown', '0', '0') router.name_is_unique = is_named self.routers[router.id_hex] = router return router ## implement IStreamListener def stream_new(self, stream): "IStreamListener: a new stream has been created" txtorlog.msg("stream_new", stream) def stream_succeeded(self, stream): "IStreamListener: stream has succeeded" txtorlog.msg("stream_succeeded", stream) def stream_attach(self, stream, circuit): """ IStreamListener: the stream has been attached to a circuit. It seems you get an attach to None followed by an attach to real circuit fairly frequently. Perhaps related to __LeaveStreamsUnattached? """ txtorlog.msg("stream_attach", stream.id, stream.target_host, " -> ", circuit) def stream_detach(self, stream, **kw): """ IStreamListener """ txtorlog.msg("stream_detach", stream.id) def stream_closed(self, stream, **kw): """ IStreamListener: stream has been closed (won't be in controller's list anymore) """ txtorlog.msg("stream_closed", stream.id) del self.streams[stream.id] def stream_failed(self, stream, **kw): """ IStreamListener: stream failed for some reason (won't be in controller's list anymore) """ txtorlog.msg("stream_failed", stream.id) del self.streams[stream.id] ## implement ICircuitListener def circuit_launched(self, circuit): "ICircuitListener API" txtorlog.msg("circuit_launched", circuit) self.circuits[circuit.id] = circuit def circuit_extend(self, circuit, router): "ICircuitListener API" txtorlog.msg("circuit_extend:", circuit.id, router) def circuit_built(self, circuit): "ICircuitListener API" txtorlog.msg( "circuit_built:", circuit.id, "->".join("%s.%s" % (x.name, x.location.countrycode) for x in circuit.path), circuit.streams) def circuit_new(self, circuit): "ICircuitListener API" txtorlog.msg("circuit_new:", circuit.id) self.circuits[circuit.id] = circuit def circuit_destroy(self, circuit): "Used by circuit_closed and circuit_failed (below)" txtorlog.msg("circuit_destroy:", circuit.id) del self.circuits[circuit.id] def circuit_closed(self, circuit, **kw): "ICircuitListener API" txtorlog.msg("circuit_closed", circuit) self.circuit_destroy(circuit) def circuit_failed(self, circuit, **kw): "ICircuitListener API" txtorlog.msg("circuit_failed", circuit, str(kw)) self.circuit_destroy(circuit)
class TorControlProtocol(LineOnlyReceiver): """ This is the main class that talks to a Tor and implements the "raw" procotol. This instance does not track state; see :class:`txtorcon.TorState` for the current state of all Circuits, Streams and Routers. :meth:`txtorcon.TorState.build_circuit` allows you to build custom circuits. :meth:`txtorcon.TorControlProtocol.add_event_listener` can be used to listen for specific events. To see how circuit and stream listeners are used, see :class:`txtorcon.TorState`, which is also the place to go if you wish to add your own stream or circuit listeners. """ implements(ITorControlProtocol) def __init__(self, password=None): """ password is only used if the Tor doesn't have COOKIE authentication turned on. Tor's default is COOKIE. """ self.password = password """If set, a password to use for authentication to Tor (default is to use COOKIE, however).""" self.version = None """Version of Tor we've connected to.""" self.is_owned = None """If not None, this is the PID of the Tor process we own (TAKEOWNERSHIP, etc).""" self.events = {} """events we've subscribed to (keyed by name like "GUARD", "STREAM")""" self.valid_events = {} """all valid events (name -> Event instance)""" self.valid_signals = [] """A list of all valid signals we accept from Tor""" self.post_bootstrap = defer.Deferred() """ This Deferred is triggered when we're done setting up (authentication, getting information from Tor). You will want to use this to do things with the :class:`TorControlProtocol` class when it's set up, like:: def setup_complete(proto): print "Setup complete, attached to Tor version",proto.version def setup(proto): proto.post_bootstrap.addCallback(setup_complete) TCP4ClientEndpoint(reactor, "localhost", 9051).connect(TorProtocolFactory()) d.addCallback(setup) See the helper method :func:`txtorcon.build_tor_connection`. """ ## variables related to the state machine self.defer = None # Deferred we returned for the current command self.response = '' self.code = None self.command = None # currently processing this command self.commands = [] # queued commands ## Here we build up the state machine. Mostly it's pretty ## simply, confounded by the fact that 600's (notify) can come ## at any time AND can be multi-line itself. Luckily, these ## can't be nested, nor can the responses be interleaved. idle = State("IDLE") recv = State("RECV") recvmulti = State("RECV_PLUS") recvnotify = State("NOTIFY_MULTILINE") idle.add_transition(Transition(idle, self._is_single_line_response, self._broadcast_response)) idle.add_transition(Transition(recvmulti, self._is_multi_line, self._start_command)) idle.add_transition(Transition(recv, self._is_continuation_line, self._start_command)) recv.add_transition(Transition(recv, self._is_continuation_line, self._accumulate_response)) recv.add_transition(Transition(idle, self._is_finish_line, self._broadcast_response)) recvmulti.add_transition(Transition(recv, self._is_end_line, lambda x: None)) recvmulti.add_transition(Transition(recvmulti, self._is_not_end_line, self._accumulate_multi_response)) self.fsm = FSM([recvnotify, idle, recvmulti, recv]) self.state_idle = idle ## hand-set initial state default start state is first in the ## list; the above looks nice in dotty though self.fsm.state = idle if DEBUG: self.debuglog = open('txtorcon-debug.log', 'w') with open('fsm.dot', 'w') as fsmfile: fsmfile.write(self.fsm.dotty()) ## see end of file for all the state machine matcher and ## transition methods. def get_info_raw(self, *args): """ Mostly for internal use; gives you the raw string back from the GETINFO command. See :meth:`getinfo <txtorcon.TorControlProtocol.get_info>` """ info = ' '.join(map(lambda x: str(x), list(args))) return self.queue_command('GETINFO %s' % info) def get_info_incremental(self, key, line_cb): """ Mostly for internal use; calls GETINFO for a single key and calls line_cb with each line received, as it is received. See :meth:`getinfo <txtorcon.TorControlProtocol.get_info>` """ return self.queue_command('GETINFO %s' % key, line_cb) ## The following methods are the main TorController API and ## probably the most interesting for users. def get_info(self, *args): """ Uses GETINFO to obtain informatoin from Tor. :param args: should be a list or tuple of strings which are valid information keys. For valid keys, see control-spec.txt from torspec. .. todo:: make some way to automagically obtain valid keys, either from running Tor or parsing control-spec :return: a ``Deferred`` which will callback with a dict containing the keys you asked for. This just inserts ``parse_keywords`` in the callback chain; if you want to avoid the parsing into a dict, you can use get_info_raw instead. """ return self.get_info_raw(*args).addCallback(parse_keywords).addErrback(log.err) def get_conf(self, *args): """ Uses GETCONF to obtain configuration values from Tor. :param args: any number of strings which are keys to get. To get all valid configuraiton names, you can call: ``get_info('config/names')`` :return: a Deferred which callbacks with one or many configuration values (depends on what you asked for). See control-spec for valid keys (you can also use TorConfig which will come set up with all the keys that are valid). The value will be a dict. Note that Tor differentiates between an empty value and a default value; in the raw protocol one looks like '250 MyFamily' versus '250 MyFamily=' where the latter is set to the empty string and the former is a default value. We differentiate these by setting the value in the dict to DEFAULT_VALUE for the default value case, or an empty string otherwise. """ return self.queue_command('GETCONF %s' % ' '.join(args)).addCallback(parse_keywords).addErrback(log.err) def get_conf_raw(self, *args): """ Same as get_conf, except that the results are not parsed into a dict """ return self.queue_command('GETCONF %s' % ' '.join(args)) def set_conf(self, *args): """ set configuration values. see control-spec for valid keys. args is treated as a list containing name then value pairs. For example, ``set_conf('foo', 'bar')`` will (attempt to) set the key 'foo' to value 'bar'. :return: a ``Deferred`` that will callback with the response ('OK') or errback with the error code and message (e.g. ``"552 Unrecognized option: Unknown option 'foo'. Failing."``) """ if len(args) % 2: d = defer.Deferred() d.errback(RuntimeError("Expected an even number of arguments.")) return d strargs = map(lambda x: str(x), args) keys = [strargs[i] for i in range(0, len(strargs), 2)] values = [strargs[i] for i in range(1, len(strargs), 2)] def maybe_quote(s): if ' ' in s: return '"%s"' % s return s values = map(maybe_quote, values) args = ' '.join(map(lambda x, y: '%s=%s' % (x, y), keys, values)) return self.queue_command('SETCONF ' + args) def signal(self, nm): """ Issues a signal to Tor. See control-spec or :attr:`txtorcon.TorControlProtocol.valid_signals` for which ones are available and their return values. :return: a ``Deferred`` which callbacks with Tor's response (``OK`` or something like ``552 Unrecognized signal code "foo"``). """ if not nm in self.valid_signals: raise RuntimeError("Invalid signal " + nm) return self.queue_command('SIGNAL %s' % nm) def add_event_listener(self, evt, callback): """ :param evt: event name, see also :var:`txtorcon.TorControlProtocol.events` .keys() Add a listener to an Event object. This may be called multiple times for the same event. If it's the first listener, a new SETEVENTS call will be initiated to Tor. Currently the callback is any callable that takes a single argument, that is the text collected for the event from the tor control protocol. :Return: ``None`` .. todo:: need an interface for the callback """ if not evt in self.valid_events.values(): try: evt = self.valid_events[evt] except: raise RuntimeError("Unknown event type: " + evt) if evt.name not in self.events: self.events[evt.name] = evt self.queue_command('SETEVENTS %s' % ' '.join(self.events.keys())) evt.listen(callback) return None def remove_event_listener(self, evt, cb): if not evt in self.valid_events.values(): try: evt = self.valid_events[evt] except: raise RuntimeError("Unknown event type: " + evt) evt.unlisten(cb) if len(evt.callbacks) == 0: del self.events[evt.name] self.queue_command('SETEVENTS %s' % ' '.join(self.events.keys())) def protocolinfo(self): """ :return: a Deferred which will give you PROTOCOLINFO; see control-spec """ return self.queue_command("PROTOCOLINFO 1") def authenticate(self, passphrase): """Call the AUTHENTICATE command.""" return self.queue_command('AUTHENTICATE ' + passphrase.encode("hex")) def quit(self): return self.queue_command('QUIT') def queue_command(self, cmd, arg=None): """ returns a Deferred which will fire with the response data when we get it """ d = defer.Deferred() self.commands.append((d, cmd, arg)) self._maybe_issue_command() return d ## the remaining methods are internal API implementations, ## callbacks and state-tracking methods -- you shouldn't have any ## need to call them. def lineReceived(self, line): """ :api:`twisted.protocols.basic.LineOnlyReceiver` API """ if DEBUG: self.debuglog.write(line + '\n') self.debuglog.flush() self.fsm.process(line) def connectionMade(self): "LineOnlyReceiver API (or parent?)" txtorlog.msg('got connection, authenticating') self.protocolinfo().addCallback(self._do_authenticate).addErrback(self._auth_failed) def _handle_notify(self, code, rest): """ Internal method to deal with 600-level responses. """ firstline = rest[:rest.find('\n')] args = firstline.split() if args[0] in self.events: self.events[args[0]].got_update(rest[len(args[0]) + 1:]) return raise RuntimeError("Wasn't listening for event of type " + args[0]) def _maybe_issue_command(self): """ If there's at least one command queued and we're not currently processing a command, this will issue the next one on the wire. """ if self.command: return if len(self.commands): self.command = self.commands.pop(0) (d, cmd, cmd_arg) = self.command self.defer = d if DEBUG: #print "NOTIFY",code,rest self.debuglog.write(cmd + '\n') self.debuglog.flush() self.transport.write(cmd + '\r\n') def _auth_failed(self, fail): """ Errback if authentication fails. """ if self.post_bootstrap: self.post_bootstrap.errback(fail) return None return fail def _safecookie_authchallenge(self, reply): """ Callback on AUTHCHALLENGE SAFECOOKIE """ kw = parse_keywords(reply.replace(' ', '\n')) server_hash = base64.b16decode(kw['SERVERHASH']) server_nonce = base64.b16decode(kw['SERVERNONCE']) ## FIXME put string in global. or something. expected_server_hash = hmac_sha256("Tor safe cookie authentication server-to-controller hash", self.cookie_data + self.client_nonce + server_nonce) if not compare_via_hash(expected_server_hash, server_hash): raise RuntimeError('Server hash not expected; wanted "%s" and got "%s".' % (base64.b16encode(expected_server_hash), base64.b16encode(server_hash))) client_hash = hmac_sha256("Tor safe cookie authentication controller-to-server hash", self.cookie_data + self.client_nonce + server_nonce) client_hash_hex = base64.b16encode(client_hash) return self.queue_command('AUTHENTICATE %s' % client_hash_hex) def _do_authenticate(self, protoinfo): """ Callback on PROTOCOLINFO to actually authenticate once we know what's supported. """ methods = None for line in protoinfo.split('\n'): if line[:5] == 'AUTH ': kw = parse_keywords(line[5:].replace(' ', '\n')) methods = kw['METHODS'].split(',') if not methods: raise RuntimeError("Didn't find AUTH line in PROTOCOLINFO response.") if 'SAFECOOKIE' in methods: cookie = re.search('COOKIEFILE="(.*)"', protoinfo).group(1) self.cookie_data = open(cookie,'r').read() if len(self.cookie_data) != 32: raise RuntimeError("Expected authentication cookie to be 32 bytes, got %d" % len(self.cookie_data)) txtorlog.msg("Using SAFECOOKIE authentication",cookie,len(self.cookie_data),"bytes") self.client_nonce = os.urandom(32) d = self.queue_command('AUTHCHALLENGE SAFECOOKIE %s' % base64.b16encode(self.client_nonce)) d.addCallback(self._safecookie_authchallenge).addCallback(self._bootstrap).addErrback(self._auth_failed) return elif 'COOKIE' in methods: cookie = re.search('COOKIEFILE="(.*)"', protoinfo).group(1) with open(cookie, 'r') as cookiefile: data = cookiefile.read() if len(data) != 32: raise RuntimeError("Expected authentication cookie to be 32 bytes, got %d" % len(data)) txtorlog.msg("Using COOKIE authentication", cookie, len(data), "bytes") self.authenticate(data).addCallback(self._bootstrap).addErrback(self._auth_failed) return if self.password: self.authenticate(self.password).addCallback(self._bootstrap).addErrback(self._auth_failed) return raise RuntimeError("The Tor I connected to doesn't support SAFECOOKIE nor COOKIE authentication and I have no password.") def _set_valid_events(self, events): "used as a callback; see _bootstrap" self.valid_events = {} for x in events.split(): self.valid_events[x] = Event(x) @defer.inlineCallbacks def _bootstrap(self, *args): """ The inlineCallbacks decorator allows us to make this method look synchronous; see the Twisted docs. Each yeild is for a Deferred after which the method continues. When this method finally exits, we're set up and do the post_bootstrap callback. """ ## unfortunately I don't see a way to get this from the runing ## tor like the events...so this was taken from some version ## of the control-spec and must be kept up-to-date (or accpet ## any signal name and just wait for the reply? self.valid_signals = ["RELOAD", "DUMP", "DEBUG", "NEWNYM", "CLEARDNSCACHE"] self.version = yield self.get_info('version') self.version = self.version['version'] txtorlog.msg("Connected to a Tor with VERSION", self.version) eventnames = yield self.get_info('events/names') eventnames = eventnames['events/names'] self._set_valid_events(eventnames) yield self.queue_command('USEFEATURE EXTENDED_EVENTS') self.post_bootstrap.callback(self) self.post_bootstrap = None defer.returnValue(self) ## ## State Machine transitions and matchers. See the __init__ method ## for a way to output a GraphViz dot diagram of the machine. ## def _is_end_line(self, line): "for FSM" return line.strip() == '.' def _is_not_end_line(self, line): "for FSM" return not self._is_end_line(line) def _is_single_line_response(self, line): "for FSM" try: code = int(line[:3]) except: return False sl = len(line) > 3 and line[3] == ' ' # print "single line?",line,sl if sl: self.code = code return True return False def _start_command(self, line): "for FSM" # print "startCommand",self.code,line self.code = int(line[:3]) # print "startCommand:",self.code if self.command and self.command[2] != None: self.command[2](line[4:]) else: self.response = line[4:] + '\n' return None def _is_continuation_line(self, line): "for FSM" # print "isContinuationLine",self.code,line code = int(line[:3]) if self.code and self.code != code: raise RuntimeError("Unexpected code %d, wanted %d" % (code,self.code)) return line[3] == '-' def _is_multi_line(self, line): "for FSM" # print "isMultiLine",self.code,line,line[3] == '+' code = int(line[:3]) if self.code and self.code != code: raise RuntimeError("Unexpected code %d, wanted %d" % (code,self.code)) return line[3] == '+' def _accumulate_multi_response(self, line): "for FSM" if self.command and self.command[2] != None: self.command[2](line) else: self.response += (line + '\n') return None def _accumulate_response(self, line): "for FSM" if self.command and self.command[2] != None: self.command[2](line[4:]) else: self.response += (line[4:] + '\n') return None def _is_finish_line(self, line): "for FSM" # print "isFinish",line if len(line) < 1: return False if line[0] == '.': return True if len(line) > 3 and line[3] == ' ': return True return False def _broadcast_response(self, line): "for FSM" # print "BCAST",line if len(line) > 3: if self.code >= 200 and self.code < 300 and self.command and self.command[2] != None: self.command[2](line[4:]) resp = '' else: resp = self.response + line[4:] else: resp = self.response self.response = '' if self.code >= 200 and self.code < 300: if self.defer is None: raise RuntimeError("Got a response, but didn't issue a command."); self.defer.callback(resp) elif self.code >= 500 and self.code < 600: err = TorProtocolError(self.code, resp) self.defer.errback(err) elif self.code >= 600 and self.code < 700: self._handle_notify(self.code, resp) self.code = None return elif self.code is None: raise RuntimeError("No code set yet in broadcast response.") else: raise RuntimeError("Unknown code in broadcast response %d." % self.code) ## note: we don't do this for 600-level responses self.command = None self.code = None self.defer = None self._maybe_issue_command() return None
class TorControlProtocol(LineOnlyReceiver): """ This is the main class that talks to a Tor and implements the "raw" procotol. This instance does not track state; see :class:`txtorcon.TorState` for the current state of all Circuits, Streams and Routers. :meth:`txtorcon.TorState.build_circuit` allows you to build custom circuits. :meth:`txtorcon.TorControlProtocol.add_event_listener` can be used to listen for specific events. To see how circuit and stream listeners are used, see :class:`txtorcon.TorState`, which is also the place to go if you wish to add your own stream or circuit listeners. """ implements(ITorControlProtocol) def __init__(self, password_function=None): """ :param password_function: A zero-argument callable which returns a password (or Deferred). It is only called if the Tor doesn't have COOKIE authentication turned on. Tor's default is COOKIE. """ self.password_function = password_function """If set, a callable to query for a password to use for authentication to Tor (default is to use COOKIE, however). May return Deferred.""" self.version = None """Version of Tor we've connected to.""" self.is_owned = None """If not None, this is the PID of the Tor process we own (TAKEOWNERSHIP, etc).""" self.events = {} """events we've subscribed to (keyed by name like "GUARD", "STREAM")""" self.valid_events = {} """all valid events (name -> Event instance)""" self.valid_signals = [] """A list of all valid signals we accept from Tor""" self.on_disconnect = defer.Deferred() """ This Deferred is triggered when the connection is closed. If there was an error, the errback is called instead. """ self.post_bootstrap = defer.Deferred() """ This Deferred is triggered when we're done setting up (authentication, getting information from Tor). You will want to use this to do things with the :class:`TorControlProtocol` class when it's set up, like:: def setup_complete(proto): print "Setup complete, attached to Tor version",proto.version def setup(proto): proto.post_bootstrap.addCallback(setup_complete) TCP4ClientEndpoint(reactor, "localhost", 9051).connect(TorProtocolFactory()) d.addCallback(setup) See the helper method :func:`txtorcon.build_tor_connection`. """ ## variables related to the state machine self.defer = None # Deferred we returned for the current command self.response = '' self.code = None self.command = None # currently processing this command self.commands = [] # queued commands ## Here we build up the state machine. Mostly it's pretty ## simply, confounded by the fact that 600's (notify) can come ## at any time AND can be multi-line itself. Luckily, these ## can't be nested, nor can the responses be interleaved. idle = State("IDLE") recv = State("RECV") recvmulti = State("RECV_PLUS") recvnotify = State("NOTIFY_MULTILINE") idle.add_transition( Transition(idle, self._is_single_line_response, self._broadcast_response)) idle.add_transition( Transition(recvmulti, self._is_multi_line, self._start_command)) idle.add_transition( Transition(recv, self._is_continuation_line, self._start_command)) recv.add_transition( Transition(recvmulti, self._is_multi_line, self._accumulate_response)) recv.add_transition( Transition(recv, self._is_continuation_line, self._accumulate_response)) recv.add_transition( Transition(idle, self._is_finish_line, self._broadcast_response)) recvmulti.add_transition( Transition(recv, self._is_end_line, lambda x: None)) recvmulti.add_transition( Transition(recvmulti, self._is_not_end_line, self._accumulate_multi_response)) self.fsm = FSM([recvnotify, idle, recvmulti, recv]) self.state_idle = idle ## hand-set initial state default start state is first in the ## list; the above looks nice in dotty though self.fsm.state = idle self.stop_debug() def start_debug(self): self.debuglog = open('txtorcon-debug.log', 'w') def stop_debug(self): def noop(*args, **kw): pass class NullLog(object): write = noop flush = noop self.debuglog = NullLog() def graphviz_data(self): return self.fsm.dotty() ## see end of file for all the state machine matcher and ## transition methods. def get_info_raw(self, *args): """ Mostly for internal use; gives you the raw string back from the GETINFO command. See :meth:`getinfo <txtorcon.TorControlProtocol.get_info>` """ info = ' '.join(map(lambda x: str(x), list(args))) return self.queue_command('GETINFO %s' % info) def get_info_incremental(self, key, line_cb): """ Mostly for internal use; calls GETINFO for a single key and calls line_cb with each line received, as it is received. See :meth:`getinfo <txtorcon.TorControlProtocol.get_info>` """ def strip_ok_and_call(line): if line.strip() != 'OK': line_cb(line) return self.queue_command('GETINFO %s' % key, strip_ok_and_call) ## The following methods are the main TorController API and ## probably the most interesting for users. def get_info(self, *args): """ Uses GETINFO to obtain informatoin from Tor. :param args: should be a list or tuple of strings which are valid information keys. For valid keys, see control-spec.txt from torspec. .. todo:: make some way to automagically obtain valid keys, either from running Tor or parsing control-spec :return: a ``Deferred`` which will callback with a dict containing the keys you asked for. This just inserts ``parse_keywords`` in the callback chain; if you want to avoid the parsing into a dict, you can use get_info_raw instead. """ return self.get_info_raw(*args).addCallback(parse_keywords) def get_conf(self, *args): """ Uses GETCONF to obtain configuration values from Tor. :param args: any number of strings which are keys to get. To get all valid configuraiton names, you can call: ``get_info('config/names')`` :return: a Deferred which callbacks with one or many configuration values (depends on what you asked for). See control-spec for valid keys (you can also use TorConfig which will come set up with all the keys that are valid). The value will be a dict. Note that Tor differentiates between an empty value and a default value; in the raw protocol one looks like '250 MyFamily' versus '250 MyFamily=' where the latter is set to the empty string and the former is a default value. We differentiate these by setting the value in the dict to DEFAULT_VALUE for the default value case, or an empty string otherwise. """ return self.queue_command( 'GETCONF %s' % ' '.join(args)).addCallback(parse_keywords).addErrback(log.err) def get_conf_raw(self, *args): """ Same as get_conf, except that the results are not parsed into a dict """ return self.queue_command('GETCONF %s' % ' '.join(args)) def set_conf(self, *args): """ set configuration values. see control-spec for valid keys. args is treated as a list containing name then value pairs. For example, ``set_conf('foo', 'bar')`` will (attempt to) set the key 'foo' to value 'bar'. :return: a ``Deferred`` that will callback with the response ('OK') or errback with the error code and message (e.g. ``"552 Unrecognized option: Unknown option 'foo'. Failing."``) """ if len(args) % 2: d = defer.Deferred() d.errback(RuntimeError("Expected an even number of arguments.")) return d strargs = map(lambda x: str(x), args) keys = [strargs[i] for i in range(0, len(strargs), 2)] values = [strargs[i] for i in range(1, len(strargs), 2)] def maybe_quote(s): if ' ' in s: return '"%s"' % s return s values = map(maybe_quote, values) args = ' '.join(map(lambda x, y: '%s=%s' % (x, y), keys, values)) return self.queue_command('SETCONF ' + args) def signal(self, nm): """ Issues a signal to Tor. See control-spec or :attr:`txtorcon.TorControlProtocol.valid_signals` for which ones are available and their return values. :return: a ``Deferred`` which callbacks with Tor's response (``OK`` or something like ``552 Unrecognized signal code "foo"``). """ if nm not in self.valid_signals: raise RuntimeError("Invalid signal " + nm) return self.queue_command('SIGNAL %s' % nm) def add_event_listener(self, evt, callback): """ :param evt: event name, see also :var:`txtorcon.TorControlProtocol.events` .keys() Add a listener to an Event object. This may be called multiple times for the same event. If it's the first listener, a new SETEVENTS call will be initiated to Tor. Currently the callback is any callable that takes a single argument, that is the text collected for the event from the tor control protocol. .. note:: this is a low-level interface; if you want to follow circuit or stream creation etc. see TorState and methods like add_circuit_listener :Return: ``None`` .. todo:: need an interface for the callback show how to tie in Stem parsing if you want """ if evt not in self.valid_events.values(): try: evt = self.valid_events[evt] except: raise RuntimeError("Unknown event type: " + evt) if evt.name not in self.events: self.events[evt.name] = evt self.queue_command('SETEVENTS %s' % ' '.join(self.events.keys())) evt.listen(callback) return None def remove_event_listener(self, evt, cb): if evt not in self.valid_events.values(): # this lets us pass a string or a real event-object try: evt = self.valid_events[evt] except: raise RuntimeError("Unknown event type: " + evt) evt.unlisten(cb) if len(evt.callbacks) == 0: # note there's a slight window here for an event of this # type to come in before the SETEVENTS succeeds; see # _handle_notify which explicitly ignore this case. del self.events[evt.name] self.queue_command('SETEVENTS %s' % ' '.join(self.events.keys())) def protocolinfo(self): """ :return: a Deferred which will give you PROTOCOLINFO; see control-spec """ return self.queue_command("PROTOCOLINFO 1") def authenticate(self, passphrase): """Call the AUTHENTICATE command.""" return self.queue_command('AUTHENTICATE ' + passphrase.encode("hex")) def quit(self): """ Sends the QUIT command, which asks Tor to hang up on this controller connection. If you've taken ownership of the Tor to which you're connected, this should also cause it to exit. Otherwise, it won't. """ return self.queue_command('QUIT') def queue_command(self, cmd, arg=None): """ returns a Deferred which will fire with the response data when we get it Note that basically every request is ultimately funelled through this command. """ d = defer.Deferred() self.commands.append((d, cmd, arg)) self._maybe_issue_command() return d ## the remaining methods are internal API implementations, ## callbacks and state-tracking methods -- you shouldn't have any ## need to call them. def lineReceived(self, line): """ :api:`twisted.protocols.basic.LineOnlyReceiver` API """ self.debuglog.write(line + '\n') self.debuglog.flush() self.fsm.process(line) def connectionMade(self): "Protocol API" txtorlog.msg('got connection, authenticating') self.protocolinfo().addCallback(self._do_authenticate).addErrback( self._auth_failed) def connectionLost(self, reason): "Protocol API" txtorlog.msg('connection terminated: ' + str(reason)) if self.on_disconnect.callbacks: if reason.check(ConnectionDone): self.on_disconnect.callback(self) else: self.on_disconnect.errback(reason) self.on_disconnect = None return None def _handle_notify(self, code, rest): """ Internal method to deal with 600-level responses. """ firstline = rest[:rest.find('\n')] args = firstline.split() if args[0] in self.events: self.events[args[0]].got_update(rest[len(args[0]) + 1:]) return # not considering this an error, as there's a slight window # after remove_event_listener is called (so the handler is # deleted) but the SETEVENTS command has not yet succeeded def _maybe_issue_command(self): """ If there's at least one command queued and we're not currently processing a command, this will issue the next one on the wire. """ if self.command: return if len(self.commands): self.command = self.commands.pop(0) (d, cmd, cmd_arg) = self.command self.defer = d self.debuglog.write(cmd + '\n') self.debuglog.flush() self.transport.write(cmd + '\r\n') def _auth_failed(self, fail): """ Errback if authentication fails. """ self.post_bootstrap.errback(fail) return None def _safecookie_authchallenge(self, reply): """ Callback on AUTHCHALLENGE SAFECOOKIE """ kw = parse_keywords(reply.replace(' ', '\n')) server_hash = base64.b16decode(kw['SERVERHASH']) server_nonce = base64.b16decode(kw['SERVERNONCE']) ## FIXME put string in global. or something. expected_server_hash = hmac_sha256( "Tor safe cookie authentication server-to-controller hash", self.cookie_data + self.client_nonce + server_nonce) if not compare_via_hash(expected_server_hash, server_hash): raise RuntimeError( 'Server hash not expected; wanted "%s" and got "%s".' % (base64.b16encode(expected_server_hash), base64.b16encode(server_hash))) client_hash = hmac_sha256( "Tor safe cookie authentication controller-to-server hash", self.cookie_data + self.client_nonce + server_nonce) client_hash_hex = base64.b16encode(client_hash) return self.queue_command('AUTHENTICATE %s' % client_hash_hex) def _do_authenticate(self, protoinfo): """ Callback on PROTOCOLINFO to actually authenticate once we know what's supported. """ methods = None for line in protoinfo.split('\n'): if line[:5] == 'AUTH ': kw = parse_keywords(line[5:].replace(' ', '\n')) methods = kw['METHODS'].split(',') if not methods: raise RuntimeError( "Didn't find AUTH line in PROTOCOLINFO response.") if 'SAFECOOKIE' in methods: cookie = re.search('COOKIEFILE="(.*)"', protoinfo).group(1) self.cookie_data = open(cookie, 'r').read() if len(self.cookie_data) != 32: raise RuntimeError( "Expected authentication cookie to be 32 bytes, got %d" % len(self.cookie_data)) txtorlog.msg("Using SAFECOOKIE authentication", cookie, len(self.cookie_data), "bytes") self.client_nonce = os.urandom(32) d = self.queue_command('AUTHCHALLENGE SAFECOOKIE %s' % base64.b16encode(self.client_nonce)) d.addCallback(self._safecookie_authchallenge).addCallback( self._bootstrap).addErrback(self._auth_failed) return elif 'COOKIE' in methods: cookie = re.search('COOKIEFILE="(.*)"', protoinfo).group(1) with open(cookie, 'r') as cookiefile: data = cookiefile.read() if len(data) != 32: raise RuntimeError( "Expected authentication cookie to be 32 bytes, got %d" % len(data)) txtorlog.msg("Using COOKIE authentication", cookie, len(data), "bytes") self.authenticate(data).addCallback(self._bootstrap).addErrback( self._auth_failed) return if self.password_function: passwd = defer.maybeDeferred(self.password_function) passwd.addCallback(self._do_password_authentication).addErrback( self._auth_failed) return raise RuntimeError( "The Tor I connected to doesn't support SAFECOOKIE nor COOKIE authentication and I have no password_function specified." ) def _do_password_authentication(self, passwd): if not passwd: raise RuntimeError("No password available.") self.authenticate(passwd).addCallback(self._bootstrap).addErrback( self._auth_failed) def _set_valid_events(self, events): "used as a callback; see _bootstrap" self.valid_events = {} for x in events.split(): self.valid_events[x] = Event(x) @defer.inlineCallbacks def _bootstrap(self, *args): """ The inlineCallbacks decorator allows us to make this method look synchronous; see the Twisted docs. Each yeild is for a Deferred after which the method continues. When this method finally exits, we're set up and do the post_bootstrap callback. """ ## unfortunately I don't see a way to get this from the runing ## tor like the events...so this was taken from some version ## of the control-spec and must be kept up-to-date (or accpet ## any signal name and just wait for the reply? self.valid_signals = [ "RELOAD", "DUMP", "DEBUG", "NEWNYM", "CLEARDNSCACHE" ] self.version = yield self.get_info('version') self.version = self.version['version'] txtorlog.msg("Connected to a Tor with VERSION", self.version) eventnames = yield self.get_info('events/names') eventnames = eventnames['events/names'] self._set_valid_events(eventnames) yield self.queue_command('USEFEATURE EXTENDED_EVENTS') self.post_bootstrap.callback(self) defer.returnValue(self) ## ## State Machine transitions and matchers. See the __init__ method ## for a way to output a GraphViz dot diagram of the machine. ## def _is_end_line(self, line): "for FSM" return line.strip() == '.' def _is_not_end_line(self, line): "for FSM" return not self._is_end_line(line) def _is_single_line_response(self, line): "for FSM" try: code = int(line[:3]) except: return False sl = len(line) > 3 and line[3] == ' ' #print "single line?",line,sl if sl: self.code = code return True return False def _start_command(self, line): "for FSM" # print "startCommand",self.code,line self.code = int(line[:3]) # print "startCommand:",self.code if self.command and self.command[2] is not None: self.command[2](line[4:]) else: self.response = line[4:] + '\n' return None def _is_continuation_line(self, line): "for FSM" # print "isContinuationLine",self.code,line code = int(line[:3]) if self.code and self.code != code: raise RuntimeError("Unexpected code %d, wanted %d" % (code, self.code)) return line[3] == '-' def _is_multi_line(self, line): "for FSM" # print "isMultiLine",self.code,line,line[3] == '+' code = int(line[:3]) if self.code and self.code != code: raise RuntimeError("Unexpected code %d, wanted %d" % (code, self.code)) return line[3] == '+' def _accumulate_multi_response(self, line): "for FSM" if self.command and self.command[2] is not None: self.command[2](line) else: self.response += (line + '\n') return None def _accumulate_response(self, line): "for FSM" if self.command and self.command[2] is not None: self.command[2](line[4:]) else: self.response += (line[4:] + '\n') return None def _is_finish_line(self, line): "for FSM" # print "isFinish",line if len(line) < 1: return False if line[0] == '.': return True if len(line) > 3 and line[3] == ' ': return True return False def _broadcast_response(self, line): "for FSM" # print "BCAST",line if len(line) > 3: if self.code >= 200 and self.code < 300 and self.command and self.command[ 2] is not None: self.command[2](line[4:]) resp = '' else: resp = self.response + line[4:] else: resp = self.response self.response = '' if self.code >= 200 and self.code < 300: if self.defer is None: raise RuntimeError( 'Got a response, but didn\'t issue a command: "%s"' % resp) if resp.endswith('\nOK'): resp = resp[:-3] self.defer.callback(resp) elif self.code >= 500 and self.code < 600: err = TorProtocolError(self.code, resp) self.defer.errback(err) elif self.code >= 600 and self.code < 700: self._handle_notify(self.code, resp) self.code = None return elif self.code is None: raise RuntimeError("No code set yet in broadcast response.") else: raise RuntimeError("Unknown code in broadcast response %d." % self.code) ## note: we don't do this for 600-level responses self.command = None self.code = None self.defer = None self._maybe_issue_command() return None