- tor-commits - lists.torproject.org

[arm/release] Previous cookie path change broke general uses
by atagar＠torproject.org 25 Sep '11

25 Sep '11

commit e5fa6d9b99f7eabac6d86e1d4952173d4aad70f5 Author: Damian Johnson <atagar(a)torproject.org> Date: Mon Sep 12 08:36:26 2011 -0700 Previous cookie path change broke general uses The hack to account for os.path.join's dumb implementation broke the general use case where the user *doesn't* have a path prefix by making it relative... oops. --- src/starter.py | 9 +++++---- 1 files changed, 5 insertions(+), 4 deletions(-) diff --git a/src/starter.py b/src/starter.py index e4e7096..dd5f5c9 100644 --- a/src/starter.py +++ b/src/starter.py @@ -233,10 +233,11 @@ def _torCtlConnect(controlAddr="127.0.0.1", controlPort=9051, passphrase=None, i # with the second argument then it will swallow the prefix. Ie... # os.path.join("/tmp", "/foo") => "/foo" - pathSuffix = conn._cookiePath - if pathSuffix.startswith("/"): pathSuffix = pathSuffix[1:] - - conn._cookiePath = os.path.join(pathPrefix, pathSuffix) + if pathPrefix: + pathSuffix = conn._cookiePath + if pathSuffix.startswith("/"): pathSuffix = pathSuffix[1:] + + conn._cookiePath = os.path.join(pathPrefix, pathSuffix) conn.authenticate(authValue) return conn

1 0

[arm/release] Util for getting condensed exit policies
by atagar＠torproject.org 25 Sep '11

25 Sep '11

commit 8a40c745ce5f040aef38963b2a047ba2f92ee392 Author: Damian Johnson <atagar(a)torproject.org> Date: Mon Sep 12 19:27:14 2011 -0700 Util for getting condensed exit policies Expanding the ExitPolicy class to provide condensed exit policies like the tor consensus. --- src/util/torTools.py | 92 ++++++++++++++++++++++++++++++++++++++++++++++++++ 1 files changed, 92 insertions(+), 0 deletions(-) diff --git a/src/util/torTools.py b/src/util/torTools.py index 7c14d18..b9d9ac8 100644 --- a/src/util/torTools.py +++ b/src/util/torTools.py @@ -2286,6 +2286,21 @@ class Controller(TorCtl.PostEventListener): self.connLock.release() +class ExitPolicyIterator: + """ + Basic iterator for cycling through ExitPolicy entries. + """ + + def __init__(self, head): + self.head = head + + def next(self): + if self.head: + lastHead = self.head + self.head = self.head.nextRule + return lastHead + else: raise StopIteration + class ExitPolicy: """ Single rule from the user's exit policy. These are chained together to form @@ -2301,6 +2316,9 @@ class ExitPolicy: nextRule - next rule to be checked when queries don't match this policy """ + # cached summary string + self.summaryStr = None + # sanitize the input a bit, cleaning up tabs and stripping quotes ruleEntry = ruleEntry.replace("\\t", " ").replace("\"", "") @@ -2405,6 +2423,80 @@ class ExitPolicy: if self.nextRule: return self.nextRule.check(ipAddress, port) else: return True # fell off the chain without a conclusion (shouldn't happen...) + def getSummary(self): + """ + Provides a summary description of the policy chain similar to the + consensus. This excludes entries that don't cover all ips, and is either + a whitelist or blacklist policy based on the final entry. For instance... + accept 80, 443 # just accepts ports 80/443 + reject 1-1024, 5555 # just accepts non-privilaged ports, excluding 5555 + """ + + if not self.summaryStr: + # determines if we're a whitelist or blacklist + isWhitelist = False # default in case we don't have a catch-all policy at the end + + for rule in self: + if rule.isIpWildcard and rule.isPortWildcard: + isWhitelist = not rule.isAccept + break + + # Iterates over the rules and adds the the ports we'll return (ie, allows + # if a whitelist and rejects if a blacklist). Reguardless of a port's + # allow/reject policy, all further entries with that port are ignored since + # policies respect the first matching rule. + + displayPorts, skipPorts = [], [] + + for rule in self: + if not rule.isIpWildcard: continue + + if rule.minPort == rule.maxPort: + portRange = [rule.minPort] + else: + portRange = range(rule.minPort, rule.maxPort + 1) + + for port in portRange: + if port in skipPorts: continue + + # if accept + whitelist or reject + blacklist then add + if rule.isAccept == isWhitelist: + displayPorts.append(port) + + # all further entries with this port are to be ignored + skipPorts.append(port) + + # gets a list of the port ranges + if displayPorts: + displayRanges, tmpRange = [], [] + displayPorts.sort() + displayPorts.append(None) # ending item to include last range in loop + + for port in displayPorts: + if not tmpRange or tmpRange[-1] + 1 == port: + tmpRange.append(port) + else: + if len(tmpRange) > 1: + displayRanges.append("%i-%i" % (tmpRange[0], tmpRange[-1])) + else: + displayRanges.append(str(tmpRange[0])) + + tmpRange = [port] + else: + # everything for the inverse + isWhitelist = not isWhitelist + displayRanges = ["1-65535"] + + # constructs the summary string + labelPrefix = "accept " if isWhitelist else "reject " + + self.summaryStr = (labelPrefix + ", ".join(displayRanges)).strip() + + return self.summaryStr + + def __iter__(self): + return ExitPolicyIterator(self) + def __str__(self): # This provides the actual policy rather than the entry used to construct # it so the 'private' keyword is expanded.

1 0

[arm/release] Replacing displayed consensus policy with util
by atagar＠torproject.org 25 Sep '11

25 Sep '11

commit aa3e3ee7a397edb18595d86dc2652d63053b3584 Author: Damian Johnson <atagar(a)torproject.org> Date: Mon Sep 12 19:44:58 2011 -0700 Replacing displayed consensus policy with util Using the ExitPolicy class' summary rather than the string from the consensus. Unless I'm misunderstanding how the consensus policy is derived, these should be equivilant. However, since this doesn't rely on the policy being in the consensus this will be rendered the same for both new and old versions of tor. --- src/cli/connections/connEntry.py | 20 ++++---------------- 1 files changed, 4 insertions(+), 16 deletions(-) diff --git a/src/cli/connections/connEntry.py b/src/cli/connections/connEntry.py index 075dfb2..de3fb01 100644 --- a/src/cli/connections/connEntry.py +++ b/src/cli/connections/connEntry.py @@ -711,28 +711,16 @@ class ConnectionLine(entries.ConnectionPanelLine): if len(nsLines) >= 2 and nsLines[1].startswith("s "): flags = nsLines[1][2:] - # The network status exit policy doesn't exist for older tor versions. - # If unavailable we'll need the full exit policy which is on the - # descriptor (if that's available). + exitPolicy = conn.getRelayExitPolicy(fingerprint) - exitPolicy = "unknown" - if len(nsLines) >= 4 and nsLines[3].startswith("p "): - exitPolicy = nsLines[3][2:].replace(",", ", ") - elif descEntry: - # the descriptor has an individual line for each entry in the exit policy - exitPolicyEntries = [] - - for line in descEntry.split("\n"): - if line.startswith("accept") or line.startswith("reject"): - exitPolicyEntries.append(line.strip()) - - exitPolicy = ", ".join(exitPolicyEntries) + if exitPolicy: policyLabel = exitPolicy.getSummary() + else: policyLabel = "unknown" dirPortLabel = "" if dirPort == "0" else "dirport: %s" % dirPort lines[2] = "nickname: %-25s orport: %-10s %s" % (nickname, orPort, dirPortLabel) lines[3] = "published: %s %s" % (pubDate, pubTime) lines[4] = "flags: %s" % flags.replace(" ", ", ") - lines[5] = "exit policy: %s" % exitPolicy + lines[5] = "exit policy: %s" % policyLabel if descEntry: torVersion, platform, contact = "", "", ""

1 0

[arm/release] Util function for getting a relay's exit policy
by atagar＠torproject.org 25 Sep '11

25 Sep '11

commit 2828ee86dee7028bc2a1265a26204f54af45c181 Author: Damian Johnson <atagar(a)torproject.org> Date: Mon Sep 12 10:07:52 2011 -0700 Util function for getting a relay's exit policy Function that fetches a relay's exit policy, first using the descriptor and falling back to its consensus entry. I'm a little concerned that obsolete descriptor data can throw this off but not sure of a better method for doing this... --- src/util/torTools.py | 78 ++++++++++++++++++++++++++++++++++++++++++++++++-- 1 files changed, 75 insertions(+), 3 deletions(-) diff --git a/src/util/torTools.py b/src/util/torTools.py index c81847c..7c14d18 100644 --- a/src/util/torTools.py +++ b/src/util/torTools.py @@ -14,7 +14,7 @@ import Queue from TorCtl import TorCtl, TorUtil -from util import enum, log, procTools, sysTools, uiTools +from util import connections, enum, log, procTools, sysTools, uiTools # enums for tor's controller state: # INIT - attached to a new controller @@ -1117,10 +1117,10 @@ class Controller(TorCtl.PostEventListener): isPrivateRejected = self.getOption("ExitPolicyRejectPrivate", True) if isPrivateRejected: - result = ExitPolicy("reject private", result) - myAddress = self.getInfo("address") if myAddress: result = ExitPolicy("reject %s" % myAddress, result) + + result = ExitPolicy("reject private", result) else: # no ORPort is set so all relaying is disabled result = ExitPolicy("reject *:*", None) @@ -1250,6 +1250,78 @@ class Controller(TorCtl.PostEventListener): return result + def getRelayExitPolicy(self, relayFingerprint, allowImprecision = True): + """ + Provides the ExitPolicy instance associated with the given relay. The tor + consensus entries don't indicate if private addresses are rejected or + address-specific policies, so this is only used as a fallback if a recent + descriptor is unavailable. This returns None if unable to determine the + policy. + + Arguments: + relayFingerprint - fingerprint of the relay + allowImprecision - make use of consensus policies as a fallback + """ + + self.connLock.acquire() + + result = None + if self.isAlive(): + # attempts to fetch the policy via the descriptor + descriptor = self.getDescriptorEntry(relayFingerprint) + + if descriptor: + exitPolicyEntries = [] + for line in descriptor.split("\n"): + if line.startswith("accept ") or line.startswith("reject "): + exitPolicyEntries.append(line) + + # construct the policy chain + for entry in reversed(exitPolicyEntries): + result = ExitPolicy(entry, result) + elif allowImprecision: + # Falls back to using the consensus entry, which is both less precise + # and unavailable with older tor versions. This assumes that the relay + # has ExitPolicyRejectPrivate set and won't include address-specific + # policies. + + consensusLine, relayAddress = None, None + + nsEntry = self.getConsensusEntry(relayFingerprint) + if nsEntry: + for line in nsEntry.split("\n"): + if line.startswith("r "): + # fetch the relay's public address, which we'll need for the + # ExitPolicyRejectPrivate policy entry + + lineComp = line.split(" ") + if len(lineComp) >= 7 and connections.isValidIpAddress(lineComp[6]): + relayAddress = lineComp[6] + elif line.startswith("p "): + consensusLine = line + break + + if consensusLine: + acceptance, ports = consensusLine.split(" ")[1:] + + # starts with a reject-all for whitelists and accept-all for blacklists + if acceptance == "accept": + result = ExitPolicy("reject *:*", None) + else: + result = ExitPolicy("accept *:*", None) + + # adds each of the ports listed in the consensus + for port in reversed(ports.split(",")): + result = ExitPolicy("%s *:%s" % (acceptance, port), result) + + # adds ExitPolicyRejectPrivate since this is the default + if relayAddress: result = ExitPolicy("reject %s" % relayAddress, result) + result = ExitPolicy("reject private", result) + + self.connLock.release() + + return result + def getRelayAddress(self, relayFingerprint, default = None): """ Provides the (IP Address, ORPort) tuple for a given relay. If the lookup

1 0

[arm/release] Implementing /info interpretor option
by atagar＠torproject.org 25 Sep '11

25 Sep '11

commit 6b4af377238ac7e863f4b001987d6d4786a003ad Author: Damian Johnson <atagar(a)torproject.org> Date: Mon Sep 12 20:23:03 2011 -0700 Implementing /info interpretor option This provides a reader friendly summary of relay information. Relayed can be queried this way by fingerprint, nickname, or IP address. --- src/cli/connections/connEntry.py | 2 +- src/cli/controller.py | 3 +- src/util/torInterpretor.py | 131 +++++++++++++++++++++++++++++++++++++- 3 files changed, 133 insertions(+), 3 deletions(-) diff --git a/src/cli/connections/connEntry.py b/src/cli/connections/connEntry.py index de3fb01..02f7069 100644 --- a/src/cli/connections/connEntry.py +++ b/src/cli/connections/connEntry.py @@ -718,7 +718,7 @@ class ConnectionLine(entries.ConnectionPanelLine): dirPortLabel = "" if dirPort == "0" else "dirport: %s" % dirPort lines[2] = "nickname: %-25s orport: %-10s %s" % (nickname, orPort, dirPortLabel) - lines[3] = "published: %s %s" % (pubDate, pubTime) + lines[3] = "published: %s %s" % (pubTime, pubDate) lines[4] = "flags: %s" % flags.replace(" ", ", ") lines[5] = "exit policy: %s" % policyLabel diff --git a/src/cli/controller.py b/src/cli/controller.py index a0b465c..a841492 100644 --- a/src/cli/controller.py +++ b/src/cli/controller.py @@ -24,7 +24,7 @@ import cli.connections.connPanel from TorCtl import TorCtl -from util import connections, conf, enum, log, panel, sysTools, torConfig, torTools +from util import connections, conf, enum, hostnames, log, panel, sysTools, torConfig, torTools ARM_CONTROLLER = None @@ -568,6 +568,7 @@ def shutdownDaemons(): # joins on utility daemon threads - this might take a moment since the # internal threadpools being joined might be sleeping + hostnames.stop() resourceTrackers = sysTools.RESOURCE_TRACKERS.values() resolver = connections.getResolver("tor") if connections.isResolverAlive("tor") else None for tracker in resourceTrackers: tracker.stop() diff --git a/src/util/torInterpretor.py b/src/util/torInterpretor.py index 7eaec16..d6f9340 100644 --- a/src/util/torInterpretor.py +++ b/src/util/torInterpretor.py @@ -9,7 +9,7 @@ import readline import version -from util import enum, torTools +from util import connections, enum, hostnames, torTools INIT_MSG = """Arm %s Control Interpretor Enter \"/help\" for usage information and \"/quit\" to stop. @@ -269,6 +269,130 @@ class ControlInterpretor: outputEntry.append((lineText[match.end():] + "\n", OUTPUT_FORMAT)) printedLines.append(lineText) + def doInfo(self, arg, outputEntry): + """ + Performs the '/info' operation, looking up a relay by fingerprint, IP + address, or nickname and printing its descriptor and consensus entries in a + pretty fashion. + """ + + fingerprint, conn = None, torTools.getConn() + + # TODO: also recognize <ip>:<port> entries? + + # determines the fingerprint, leaving it unset and adding an error message + # if unsuccessful + if not arg: + outputEntry.append(("No fingerprint or nickname to look up", ERROR_FORMAT)) + elif len(arg) == 40 and re.match("^[0-9a-fA-F]+$", arg): + # we got a fingerprint (fourty character hex string) + fingerprint = arg + elif connections.isValidIpAddress(arg): + # we got an ip address, look up the fingerprint + fpMatches = conn.getRelayFingerprint(arg, getAllMatches = True) + + if len(fpMatches) == 0: + outputEntry.append(("No relays found at %s" % arg, ERROR_FORMAT)) + elif len(fpMatches) == 1: + fingerprint = fpMatches[0][1] + else: + outputEntry.append(("Multiple relays at %s, specify which by giving a port" % arg, ERROR_FORMAT)) + + for i in range(len(fpMatches)): + relayEntry = outputEntry[i] + outputEntry.append((" %i. or port: %-5s fingerprint: %s" % (i + 1, relayEntry[0], relayEntry[1]), ERROR_FORMAT)) + else: + # we got something else, treat it as a nickname + fingerprint = conn.getNicknameFingerprint(arg) + + if not fingerprint: + outputEntry.append(("No relay with the nickname of '%s' found" % arg, ERROR_FORMAT)) + + if fingerprint: + consensusEntry = conn.getConsensusEntry(fingerprint) + + # The nickname, address, and port lookups are all based on the consensus + # entry so if this succeeds we should be pretty confident that those + # queries will work too. + + if not consensusEntry: + outputEntry.append(("Unable to find consensus information for %s" % fingerprint, ERROR_FORMAT)) + return + + address, port = conn.getRelayAddress(fingerprint, (None, None)) + + # ... but not sure enough that we won't check + if not address or not port: return + + locale = conn.getInfo("ip-to-country/%s" % address, "??") + hostname = hostnames.resolve(address, 10) + + # TODO: Most of the following is copied from the _getDetailContent method + # of cli/connections/connEntry.py - useful bits should be refactored. + consensusLines = consensusEntry.split("\n") + + firstLineComp = consensusLines[0].split(" ") + if len(firstLineComp) >= 9: + _, nickname, _, _, pubDate, pubTime, _, orPort, _ = firstLineComp[:9] + else: nickname, pubDate, pubTime, orPort = "", "", "", "" + + flags = "unknown" + if len(consensusLines) >= 2 and consensusLines[1].startswith("s "): + flags = consensusLines[1][2:] + + exitPolicy = conn.getRelayExitPolicy(fingerprint) + + if exitPolicy: policyLabel = exitPolicy.getSummary() + else: policyLabel = "unknown" + + # fetches information from the descriptor if it's available + torVersion, platform, contact = "", "", "" + descriptorEntry = conn.getDescriptorEntry(fingerprint) + + if descriptorEntry: + for descLine in descriptorEntry.split("\n"): + if descLine.startswith("platform"): + # has the tor version and platform, ex: + # platform Tor 0.2.1.29 (r318f470bc5f2ad43) on Linux x86_64 + + torVersion = descLine[13:descLine.find(" ", 13)] + platform = descLine[descLine.rfind(" on ") + 4:] + elif descLine.startswith("contact"): + contact = descLine[8:] + + # clears up some highly common obscuring + for alias in (" at ", " AT "): contact = contact.replace(alias, "@") + for alias in (" dot ", " DOT "): contact = contact.replace(alias, ".") + + break # contact lines come after the platform + + headingAttr, infoAttr = (Attr.BOLD, Color.BLUE), () + + outputEntry.append(("%s (%s)\n" % (nickname, fingerprint), infoAttr)) + + outputEntry.append(("address: ", headingAttr)) + outputEntry.append(("%s:%s (%s, %s)\n" % (address, port, locale, hostname), infoAttr)) + + outputEntry.append(("published: ", headingAttr)) + outputEntry.append(("%s %s" % (pubTime, pubDate) + "\n", infoAttr)) + + if torVersion and platform: + outputEntry.append(("os: ", headingAttr)) + outputEntry.append((platform + "\n", infoAttr)) + + outputEntry.append(("version: ", headingAttr)) + outputEntry.append((torVersion + "\n", infoAttr)) + + outputEntry.append(("flags: ", headingAttr)) + outputEntry.append((flags.replace(" ", ", ") + "\n", infoAttr)) + + outputEntry.append(("exit policy: ", headingAttr)) + outputEntry.append((policyLabel + "\n", infoAttr)) + + if contact: + outputEntry.append(("contact: ", headingAttr)) + outputEntry.append((contact + "\n", infoAttr)) + def handleQuery(self, input): """ Processes the given input. Requests starting with a '/' are special @@ -308,6 +432,7 @@ class ControlInterpretor: if cmd == "/quit": raise InterpretorClosed() elif cmd == "/write": self.doWrite(arg, outputEntry) elif cmd == "/find": self.doFind(arg, outputEntry) + elif cmd == "/info": self.doInfo(arg, outputEntry) else: outputEntry.append(("Not yet implemented...", ERROR_FORMAT)) # TODO: implement @@ -393,6 +518,10 @@ def prompt(): # moves cursor to the next line and terminates (most commonly # KeyboardInterrupt and EOFErro) print + + # stop daemons + hostnames.stop() + break for line in outputEntry:

1 0

[arm/release] Tab completion for control prompt input
by atagar＠torproject.org 25 Sep '11

25 Sep '11

commit aaec744638d997447db3b4c50a3080d93835dd12 Author: Damian Johnson <atagar(a)torproject.org> Date: Sun Aug 28 17:41:17 2011 -0700 Tab completion for control prompt input This provides autocompletion for the control prompt based on the capabilities of the attached tor instance (fetching options from GETINFO info/names, config/names, etc). This uses readline so it's working for the terminal prompt but not the panel interpretor (which will need a validator implementation). --- src/util/torInterpretor.py | 122 +++++++++++++++++++++++++++++++++++++++++-- 1 files changed, 116 insertions(+), 6 deletions(-) diff --git a/src/util/torInterpretor.py b/src/util/torInterpretor.py index 866495d..fecc2ac 100644 --- a/src/util/torInterpretor.py +++ b/src/util/torInterpretor.py @@ -62,14 +62,115 @@ def format(msg, *attr): if encodings: return (CSI % ";".join(encodings)) + msg + RESET - else: - raise IOError("BLARG! %s" % str(attr)) - return msg + else: return msg + +class TorCommandOptions: + """ + Command autocompleter, fetching the valid options from the attached Tor + instance. + """ + + def __init__(self): + self.commands = [] + conn = torTools.getConn() + + # adds all of the valid GETINFO options + infoOptions = conn.getInfo("info/names") + if infoOptions: + for line in infoOptions.split("\n"): + if " " in line: + # skipping non-existant options mentioned in: + # https://trac.torproject.org/projects/tor/ticket/3844 + + if line.startswith("config/*") or line.startswith("dir-usage"): + continue + + # strips off the ending asterisk if it accepts a value + infoOpt = line.split(" ", 1)[0] + + if infoOpt.endswith("*"): + infoOpt = infoOpt[:-1] + + self.commands.append("GETINFO %s" % infoOpt) + else: self.commands.append("GETINFO ") + + # adds all of the valid GETCONF / SETCONF / RESETCONF options + confOptions = conn.getInfo("config/names") + if confOptions: + # individual options are '<name> <type>' pairs + confEntries = [opt.split(" ", 1)[0] for opt in confOptions.split("\n")] + self.commands += ["GETCONF %s" % conf for conf in confEntries] + self.commands += ["SETCONF %s " % conf for conf in confEntries] + self.commands += ["RESETCONF %s" % conf for conf in confEntries] + else: + self.commands.append("GETCONF ") + self.commands.append("SETCONF ") + self.commands.append("RESETCONF ") + + # adds all of the valid SETEVENT options + eventOptions = conn.getInfo("events/names") + if eventOptions: + self.commands += ["SETEVENT %s" % event for event in eventOptions.split(" ")] + else: self.commands.append("SETEVENT ") + + # adds all of the valid USEFEATURE options + featureOptions = conn.getInfo("features/names") + if featureOptions: + self.commands += ["USEFEATURE %s" % feature for feature in featureOptions.split(" ")] + else: self.commands.append("USEFEATURE ") + + # adds all of the valid SIGNAL options + # this can't yet be fetched dynamically, as per: + # https://trac.torproject.org/projects/tor/ticket/3842 + + signals = ("RELOAD", "SHUTDOWN", "DUMP", "DEBUG", "HALT", "HUP", "INT", + "USR1", "USR2", "TERM", "NEWNYM", "CLEARDNSCACHE") + self.commands += ["SIGNAL %s" % sig for sig in signals] + + # shouldn't use AUTHENTICATE since we only provide the prompt with an + # authenticated controller connection + #self.commands.append("AUTHENTICATE") + + # other options + self.commands.append("SAVECONF") + self.commands.append("MAPADDRESS ") + self.commands.append("EXTENDCIRCUIT ") + self.commands.append("SETCIRCUITPURPOSE ") + self.commands.append("SETROUTERPURPOSE ") + self.commands.append("ATTACHSTREAM ") + self.commands.append("+POSTDESCRIPTOR ") # TODO: needs to support multiline options for this (ugg) + self.commands.append("REDIRECTSTREAM ") + self.commands.append("CLOSESTREAM ") + self.commands.append("CLOSECIRCUIT ") + self.commands.append("RESOLVE ") + self.commands.append("PROTOCOLINFO ") + self.commands.append("+LOADCONF") # TODO: another multiline... + self.commands.append("TAKEOWNERSHIP") + self.commands.append("QUIT") # TODO: give a confirmation when the user does this? + + def complete(self, text, state): + # provides case insensetive autocompletion options based on self.commands + for cmd in self.commands: + if cmd.lower().startswith(text.lower()): + if not state: return cmd + else: state -= 1 def prompt(): prompt = format(">>> ", Color.GREEN, Attr.BOLD) input = "" + # sets up tab autocompetion + torCommands = TorCommandOptions() + readline.parse_and_bind("tab: complete") + readline.set_completer(torCommands.complete) + + # Essentially disables autocompletion by word delimiters. This is because + # autocompletion options are full commands (ex. "GETINFO version") so we want + # "GETINFO" to match to all the options rather than be treated as a complete + # command by itself. + + readline.set_completer_delims("\n") + formatMap = {} # mapping of Format to Color and Attr enums formatMap[Formats.PROMPT] = (Attr.BOLD, Color.GREEN) formatMap[Formats.INPUT] = (Color.CYAN, ) @@ -82,7 +183,13 @@ def prompt(): formatMap[Formats.ERROR] = (Attr.BOLD, Color.RED) while input != "/quit": - input = raw_input(prompt) + try: + input = raw_input(prompt) + except: + # moves cursor to the next line and terminates (most commonly + # KeyboardInterrupt and EOFErro) + print + break _, outputEntry = handleQuery(input) @@ -129,16 +236,19 @@ def handleQuery(input): if " " in input: cmd, arg = input.split(" ", 1) else: cmd, arg = input, "" + # makes commands uppercase to match the spec + cmd = cmd.upper() + inputEntry.append((cmd + " ", Formats.INPUT_CMD)) if arg: inputEntry.append((arg, Formats.INPUT_ARG)) - if cmd.upper() == "GETINFO": + if cmd == "GETINFO": try: response = conn.getInfo(arg, suppressExc = False) outputEntry.append((response, Formats.OUTPUT)) except Exception, exc: outputEntry.append((str(exc), Formats.ERROR)) - elif cmd.upper() == "SETCONF": + elif cmd == "SETCONF": if "=" in arg: param, value = arg.split("=", 1)

1 0

[arm/release] Basic tab completion for interpretor panel
by atagar＠torproject.org 25 Sep '11

25 Sep '11

commit 7b58a20d69150d3628b758ddef7c014b740cb5de Author: Damian Johnson <atagar(a)torproject.org> Date: Sun Aug 28 18:27:16 2011 -0700 Basic tab completion for interpretor panel This performs tab completion in the interpretor panel when there's a single match. This does not, however, provide suggestions or common prefix completion yet. The suggestions in particular are gonna be a pita... --- src/cli/interpretorPanel.py | 3 +++ src/util/textInput.py | 34 ++++++++++++++++++++++++++++++++++ src/util/torInterpretor.py | 16 +++++++++++++++- 3 files changed, 52 insertions(+), 1 deletions(-) diff --git a/src/cli/interpretorPanel.py b/src/cli/interpretorPanel.py index 162fd19..95866db 100644 --- a/src/cli/interpretorPanel.py +++ b/src/cli/interpretorPanel.py @@ -61,8 +61,11 @@ class InterpretorPanel(panel.Panel): self.redraw(True) # intercepts input so user can cycle through the history + torCommands = torInterpretor.TorCommandOptions() + validator = textInput.BasicValidator() validator = textInput.HistoryValidator(self.previousCommands, validator) + validator = textInput.TabCompleter(torCommands.getMatches, validator) xOffset = len(torInterpretor.PROMPT) if len(self.contents) > self.maxY - 1: diff --git a/src/util/textInput.py b/src/util/textInput.py index c3c229f..31a5305 100644 --- a/src/util/textInput.py +++ b/src/util/textInput.py @@ -148,3 +148,37 @@ class HistoryValidator(TextInputValidator): return PASS +class TabCompleter(TextInputValidator): + """ + Provides tab completion based on the current input, finishing if there's only + a single match. This expects a functor that accepts the current input and + provides matches. + """ + + def __init__(self, completer, nextValidator = None): + TextInputValidator.__init__(self, nextValidator) + + # functor that accepts a string and gives a list of matches + self.completer = completer + + def handleKey(self, key, textbox): + # Matches against the tab key. The ord('\t') is nine, though strangely none + # of the curses.KEY_*TAB constants match this... + if key == 9: + matches = self.completer(textbox.gather().strip()) + + if len(matches) == 1: + # only a single match, fill it in + newInput = matches[0] + y, _ = textbox.win.getyx() + _, maxX = textbox.win.getmaxyx() + textbox.win.clear() + textbox.win.addstr(y, 0, newInput[:maxX - 1]) + textbox.win.move(y, min(len(newInput), maxX - 1)) + elif len(matches) > 1: + pass # TODO: somehow display matches... this is not gonna be fun + + return None + + return PASS + diff --git a/src/util/torInterpretor.py b/src/util/torInterpretor.py index fecc2ac..cffe200 100644 --- a/src/util/torInterpretor.py +++ b/src/util/torInterpretor.py @@ -148,8 +148,22 @@ class TorCommandOptions: self.commands.append("TAKEOWNERSHIP") self.commands.append("QUIT") # TODO: give a confirmation when the user does this? + def getMatches(self, text): + """ + Provides all options that match the given input. + + Arguments: + text - user input text to be matched against + """ + + return [cmd for cmd in self.commands if cmd.lower().startswith(text.lower())] + def complete(self, text, state): - # provides case insensetive autocompletion options based on self.commands + """ + Provides case insensetive autocompletion options, acting as a functor for + the readlines set_completer function. + """ + for cmd in self.commands: if cmd.lower().startswith(text.lower()): if not state: return cmd

1 0

[arm/release] Common prefix tab completion for interpretor panel
by atagar＠torproject.org 25 Sep '11

25 Sep '11

commit d6dca592931b529435d769fbf993659523cb08d6 Author: Damian Johnson <atagar(a)torproject.org> Date: Sun Aug 28 18:38:17 2011 -0700 Common prefix tab completion for interpretor panel Implementing common prefix autocompletion for the interpretor panel. Only thing left is displaying the matches... --- src/util/textInput.py | 17 ++++++++++++++--- 1 files changed, 14 insertions(+), 3 deletions(-) diff --git a/src/util/textInput.py b/src/util/textInput.py index 31a5305..c0f01ce 100644 --- a/src/util/textInput.py +++ b/src/util/textInput.py @@ -4,6 +4,7 @@ These can be chained together with the first matching validator taking precidence. """ +import os import curses PASS = -1 @@ -165,18 +166,28 @@ class TabCompleter(TextInputValidator): # Matches against the tab key. The ord('\t') is nine, though strangely none # of the curses.KEY_*TAB constants match this... if key == 9: - matches = self.completer(textbox.gather().strip()) + currentContents = textbox.gather().strip() + matches = self.completer(currentContents) + newInput = None if len(matches) == 1: # only a single match, fill it in newInput = matches[0] + elif len(matches) > 1: + # looks for a common prefix we can complete + commonPrefix = os.path.commonprefix(matches) # weird that this comes from path... + + if commonPrefix != currentContents: + newInput = commonPrefix + + # TODO: somehow display matches... this is not gonna be fun + + if newInput: y, _ = textbox.win.getyx() _, maxX = textbox.win.getmaxyx() textbox.win.clear() textbox.win.addstr(y, 0, newInput[:maxX - 1]) textbox.win.move(y, min(len(newInput), maxX - 1)) - elif len(matches) > 1: - pass # TODO: somehow display matches... this is not gonna be fun return None

1 0

[arm/release] Class and formatting interpretor refactoring
by atagar＠torproject.org 25 Sep '11

25 Sep '11

commit c8d21d593887bb537c144b71f15c7ed38f1880ed Author: Damian Johnson <atagar(a)torproject.org> Date: Mon Aug 29 09:50:15 2011 -0700 Class and formatting interpretor refactoring This moves around the interpretor code a bit to allow for arbitrary attribute drawing and introduce an interpretor class (needed for when implementing the '/write' option). --- src/cli/interpretorPanel.py | 41 +++++---- src/util/torInterpretor.py | 191 ++++++++++++++++++++++--------------------- 2 files changed, 121 insertions(+), 111 deletions(-) diff --git a/src/cli/interpretorPanel.py b/src/cli/interpretorPanel.py index 95866db..02868ce 100644 --- a/src/cli/interpretorPanel.py +++ b/src/cli/interpretorPanel.py @@ -8,7 +8,7 @@ import curses from util import panel, textInput, torInterpretor, uiTools USAGE_INFO = "to use this panel press enter" -PROMPT_LINE = [(torInterpretor.PROMPT, torInterpretor.Formats.PROMPT), (USAGE_INFO, torInterpretor.Formats.USAGE)] +PROMPT_LINE = [torInterpretor.PROMPT, (USAGE_INFO, torInterpretor.USAGE_FORMAT)] # limits used for cropping BACKLOG_LIMIT = 100 @@ -17,34 +17,37 @@ LINES_LIMIT = 2000 # lazy loaded curses formatting constants FORMATS = {} -def getFormat(format): +def getFormat(formatAttr): """ - Provides the curses drawing attributes for a torInterpretor.Formats enum. - This returns plain formatting if the entry doesn't exist. + Provides the curses drawing attributes for torInterpretor formatting + attributes. Arguments: - format - format enum to fetch + formatAttr - list of formatting attributes """ # initializes formats if they haven't yet been loaded if not FORMATS: - FORMATS[torInterpretor.Formats.PROMPT] = curses.A_BOLD | uiTools.getColor("green") - FORMATS[torInterpretor.Formats.INPUT] = uiTools.getColor("cyan") - FORMATS[torInterpretor.Formats.INPUT_INTERPRETOR] = curses.A_BOLD | uiTools.getColor("magenta") - FORMATS[torInterpretor.Formats.INPUT_CMD] = curses.A_BOLD | uiTools.getColor("green") - FORMATS[torInterpretor.Formats.INPUT_ARG] = curses.A_BOLD | uiTools.getColor("cyan") - FORMATS[torInterpretor.Formats.OUTPUT] = uiTools.getColor("blue") - FORMATS[torInterpretor.Formats.USAGE] = uiTools.getColor("cyan") - FORMATS[torInterpretor.Formats.HELP] = uiTools.getColor("magenta") - FORMATS[torInterpretor.Formats.ERROR] = curses.A_BOLD | uiTools.getColor("red") + for colorEnum in torInterpretor.Color.values(): + FORMATS[colorEnum] = uiTools.getColor(colorEnum.lower()) + + FORMATS[torInterpretor.Attr.BOLD] = curses.A_BOLD + FORMATS[torInterpretor.Attr.UNDERLINE] = curses.A_UNDERLINE + FORMATS[torInterpretor.Attr.HILIGHT] = curses.A_STANDOUT + + cursesFormatting = curses.A_NORMAL + + for attr in formatAttr: + cursesFormatting |= FORMATS.get(attr, curses.A_NORMAL) - return FORMATS.get(format, curses.A_NORMAL) + return cursesFormatting class InterpretorPanel(panel.Panel): def __init__(self, stdscr): panel.Panel.__init__(self, stdscr, "interpretor", 0) self.isInputMode = False self.scroll = 0 + self.interpretor = torInterpretor.ControlInterpretor() self.previousCommands = [] # user input, newest to oldest self.contents = [PROMPT_LINE] # (msg, format enum) tuples being displayed (oldest to newest) @@ -61,18 +64,18 @@ class InterpretorPanel(panel.Panel): self.redraw(True) # intercepts input so user can cycle through the history - torCommands = torInterpretor.TorCommandOptions() + torCommands = torInterpretor.TorControlCompleter() validator = textInput.BasicValidator() validator = textInput.HistoryValidator(self.previousCommands, validator) validator = textInput.TabCompleter(torCommands.getMatches, validator) - xOffset = len(torInterpretor.PROMPT) + xOffset = len(torInterpretor.PROMPT[0]) if len(self.contents) > self.maxY - 1: xOffset += 3 # offset for scrollbar inputLine = min(self.maxY - 1, len(self.contents)) - inputFormat = getFormat(torInterpretor.Formats.INPUT) + inputFormat = getFormat(torInterpretor.INPUT_FORMAT) input = self.getstr(inputLine, xOffset, "", inputFormat, validator = validator) input, isDone = input.strip(), False @@ -84,7 +87,7 @@ class InterpretorPanel(panel.Panel): self.previousCommands = self.previousCommands[:BACKLOG_LIMIT] try: - inputEntry, outputEntry = torInterpretor.handleQuery(input) + inputEntry, outputEntry = self.interpretor.handleQuery(input) except torInterpretor.InterpretorClosed: isDone = True diff --git a/src/util/torInterpretor.py b/src/util/torInterpretor.py index cffe200..c7bcebb 100644 --- a/src/util/torInterpretor.py +++ b/src/util/torInterpretor.py @@ -8,9 +8,6 @@ import readline # simply importing this provides history to raw_input from util import enum, torTools -PROMPT = ">>> " -Formats = enum.Enum("PROMPT", "INPUT", "INPUT_INTERPRETOR", "INPUT_CMD", "INPUT_ARG", "OUTPUT", "USAGE", "HELP", "ERROR") - TERM_COLORS = ("BLACK", "RED", "GREEN", "YELLOW", "BLUE", "MAGENTA", "CYAN", "WHITE") Color = enum.Enum(*TERM_COLORS) @@ -21,6 +18,16 @@ FG_ENCODING = dict([(Color.values()[i], str(30 + i)) for i in range(8)]) BG_ENCODING = dict([(BgColor.values()[i], str(40 + i)) for i in range(8)]) ATTR_ENCODING = {Attr.BOLD: "1", Attr.UNDERLINE: "4", Attr.HILIGHT: "7"} +PROMPT = (">>> ", (Attr.BOLD, Color.GREEN)) +INPUT_FORMAT = (Color.CYAN, ) +INPUT_INTERPRETOR_FORMAT = (Attr.BOLD, Color.MAGENTA) +INPUT_CMD_FORMAT = (Attr.BOLD, Color.GREEN) +INPUT_ARG_FORMAT = (Attr.BOLD, Color.CYAN) +OUTPUT_FORMAT = (Color.BLUE, ) +USAGE_FORMAT = (Color.CYAN, ) +HELP_FORMAT = (Color.MAGENTA, ) +ERROR_FORMAT = (Attr.BOLD, Color.RED) + CSI = "\x1B[%sm" RESET = CSI % "0" @@ -64,7 +71,7 @@ def format(msg, *attr): return (CSI % ";".join(encodings)) + msg + RESET else: return msg -class TorCommandOptions: +class TorControlCompleter: """ Command autocompleter, fetching the valid options from the attached Tor instance. @@ -169,12 +176,96 @@ class TorCommandOptions: if not state: return cmd else: state -= 1 +class ControlInterpretor: + """ + Interpretor that handles queries to the control port, providing usability + imporvements like irc style help optoins. This tracks input and responses. + """ + + def __init__(self): + self.queries = [] # requests made, newest to oldest + self.contents = [] # (msg, format list) tuples of both input and output (oldest to newest) + + def handleQuery(self, input): + """ + Processes the given input. Requests starting with a '/' are special + commands to the interpretor, and anything else is sent to the control port. + This returns an input/output tuple, each entry being a list of lines, each + line having a list of (msg, format) tuples for the content to be displayed. + This raises a InterpretorClosed if the interpretor should be shut down. + + Arguments: + input - user input to be processed + """ + + input = input.strip() + inputEntry, outputEntry = [PROMPT], [] + conn = torTools.getConn() + + # input falls into three general categories: + # - interpretor command which starts with a '/' + # - controller commands handled by torTools (this allows for caching, + # proper handling by the rest of arm, etc) + # - unrecognized controller command, this has the possability of confusing + # arm... + + if input.startswith("/"): + # interpretor command + inputEntry.append((input, INPUT_INTERPRETOR_FORMAT)) + outputEntry.append(("Not yet implemented...", ERROR_FORMAT)) # TODO: implement + + # TODO: add /help option + # TODO: add /write option + else: + # controller command + if " " in input: cmd, arg = input.split(" ", 1) + else: cmd, arg = input, "" + + # makes commands uppercase to match the spec + cmd = cmd.upper() + + inputEntry.append((cmd + " ", INPUT_CMD_FORMAT)) + if arg: inputEntry.append((arg, INPUT_ARG_FORMAT)) + + if cmd == "GETINFO": + try: + response = conn.getInfo(arg, suppressExc = False) + outputEntry.append((response, OUTPUT_FORMAT)) + except Exception, exc: + outputEntry.append((str(exc), ERROR_FORMAT)) + elif cmd == "SETCONF": + if "=" in arg: + param, value = arg.split("=", 1) + + try: + conn.setOption(param.strip(), value.strip()) + except Exception, exc: + outputEntry.append((str(exc), ERROR_FORMAT)) + else: + # TODO: resets the attribute + outputEntry.append(("Not yet implemented...", ERROR_FORMAT)) # TODO: implement + else: + try: + response = conn.getTorCtl().sendAndRecv("%s\r\n" % input) + + for entry in response: + # Response entries are tuples with the response code, body, and + # extra info. For instance: + # ('250', 'version=0.2.2.23-alpha (git-b85eb949b528f4d7)', None) + + if len(entry) == 3: + outputEntry.append((entry[1], OUTPUT_FORMAT)) + except Exception, exc: + outputEntry.append((str(exc), ERROR_FORMAT)) + + return (_splitOnNewlines(inputEntry), _splitOnNewlines(outputEntry)) + def prompt(): prompt = format(">>> ", Color.GREEN, Attr.BOLD) input = "" # sets up tab autocompetion - torCommands = TorCommandOptions() + torCommands = TorControlCompleter() readline.parse_and_bind("tab: complete") readline.set_completer(torCommands.complete) @@ -184,17 +275,7 @@ def prompt(): # command by itself. readline.set_completer_delims("\n") - - formatMap = {} # mapping of Format to Color and Attr enums - formatMap[Formats.PROMPT] = (Attr.BOLD, Color.GREEN) - formatMap[Formats.INPUT] = (Color.CYAN, ) - formatMap[Formats.INPUT_INTERPRETOR] = (Attr.BOLD, Color.MAGENTA) - formatMap[Formats.INPUT_CMD] = (Attr.BOLD, Color.GREEN) - formatMap[Formats.INPUT_ARG] = (Attr.BOLD, Color.CYAN) - formatMap[Formats.OUTPUT] = (Color.BLUE, ) - formatMap[Formats.USAGE] = (Color.CYAN, ) - formatMap[Formats.HELP] = (Color.MAGENTA, ) - formatMap[Formats.ERROR] = (Attr.BOLD, Color.RED) + interpretor = ControlInterpretor() while input != "/quit": try: @@ -205,90 +286,16 @@ def prompt(): print break - _, outputEntry = handleQuery(input) + _, outputEntry = interpretor.handleQuery(input) for line in outputEntry: outputLine = "" for msg, msgFormat in line: - outputLine += format(msg, *formatMap[msgFormat]) + outputLine += format(msg, *msgFormat) print outputLine -def handleQuery(input): - """ - Processes the given input. Requests starting with a '/' are special - commands to the interpretor, and anything else is sent to the control port. - This returns an input/output tuple, each entry being a list of lines, each - line having a list of (msg, format) tuples for the content to be displayed. - This raises a InterpretorClosed if the interpretor should be shut down. - - Arguments: - input - user input to be processed - """ - - input = input.strip() - inputEntry, outputEntry = [(PROMPT, Formats.PROMPT)], [] - conn = torTools.getConn() - - # input falls into three general categories: - # - interpretor command which starts with a '/' - # - controller commands handled by torTools (this allows for caching, - # proper handling by the rest of arm, etc) - # - unrecognized controller command, this has the possability of confusing - # arm... - - if input.startswith("/"): - # interpretor command - inputEntry.append((input, Formats.INPUT_INTERPRETOR)) - outputEntry.append(("Not yet implemented...", Formats.ERROR)) # TODO: implement - - # TODO: add /help option - # TODO: add /write option - else: - # controller command - if " " in input: cmd, arg = input.split(" ", 1) - else: cmd, arg = input, "" - - # makes commands uppercase to match the spec - cmd = cmd.upper() - - inputEntry.append((cmd + " ", Formats.INPUT_CMD)) - if arg: inputEntry.append((arg, Formats.INPUT_ARG)) - - if cmd == "GETINFO": - try: - response = conn.getInfo(arg, suppressExc = False) - outputEntry.append((response, Formats.OUTPUT)) - except Exception, exc: - outputEntry.append((str(exc), Formats.ERROR)) - elif cmd == "SETCONF": - if "=" in arg: - param, value = arg.split("=", 1) - - try: - conn.setOption(param.strip(), value.strip()) - except Exception, exc: - outputEntry.append((str(exc), Formats.ERROR)) - else: - # TODO: resets the attribute - outputEntry.append(("Not yet implemented...", Formats.ERROR)) # TODO: implement - else: - try: - response = conn.getTorCtl().sendAndRecv("%s\r\n" % input) - - for entry in response: - # Response entries are tuples with the response code, body, and - # extra info. For instance: - # ('250', 'version=0.2.2.23-alpha (git-b85eb949b528f4d7)', None) - - if len(entry) == 3: - outputEntry.append((entry[1], Formats.OUTPUT)) - except Exception, exc: - outputEntry.append((str(exc), Formats.ERROR)) - - return (_splitOnNewlines(inputEntry), _splitOnNewlines(outputEntry)) - def _splitOnNewlines(entry): """ Splits a list of (msg, format) tuples on newlines into a list of lines.

1 0

[arm/release] Moving content and backlog tracking to interpretor
by atagar＠torproject.org 25 Sep '11

25 Sep '11

commit 59b70998b162c461ec03780e9ca4cabdb7411af4 Author: Damian Johnson <atagar(a)torproject.org> Date: Tue Aug 30 09:41:53 2011 -0700 Moving content and backlog tracking to interpretor The interpretor class will be tracking state so moving this information to it from the panel. This will make a common saving function feasable. --- src/cli/interpretorPanel.py | 49 +++++++++++----------------------- src/util/torInterpretor.py | 60 +++++++++++++++++++++++++++++++++++-------- 2 files changed, 65 insertions(+), 44 deletions(-) diff --git a/src/cli/interpretorPanel.py b/src/cli/interpretorPanel.py index 02868ce..cc8b496 100644 --- a/src/cli/interpretorPanel.py +++ b/src/cli/interpretorPanel.py @@ -10,17 +10,12 @@ from util import panel, textInput, torInterpretor, uiTools USAGE_INFO = "to use this panel press enter" PROMPT_LINE = [torInterpretor.PROMPT, (USAGE_INFO, torInterpretor.USAGE_FORMAT)] -# limits used for cropping -BACKLOG_LIMIT = 100 -LINES_LIMIT = 2000 - -# lazy loaded curses formatting constants +# lazy loaded mapping of interpretor attributes to curses formatting constants FORMATS = {} def getFormat(formatAttr): """ - Provides the curses drawing attributes for torInterpretor formatting - attributes. + Provides the curses drawing attributes for torInterpretor formats. Arguments: formatAttr - list of formatting attributes @@ -45,11 +40,10 @@ def getFormat(formatAttr): class InterpretorPanel(panel.Panel): def __init__(self, stdscr): panel.Panel.__init__(self, stdscr, "interpretor", 0) + self.interpretor = torInterpretor.ControlInterpretor() + self.inputCompleter = torInterpretor.TorControlCompleter() self.isInputMode = False self.scroll = 0 - self.interpretor = torInterpretor.ControlInterpretor() - self.previousCommands = [] # user input, newest to oldest - self.contents = [PROMPT_LINE] # (msg, format enum) tuples being displayed (oldest to newest) def prompt(self): """ @@ -64,17 +58,16 @@ class InterpretorPanel(panel.Panel): self.redraw(True) # intercepts input so user can cycle through the history - torCommands = torInterpretor.TorControlCompleter() - validator = textInput.BasicValidator() - validator = textInput.HistoryValidator(self.previousCommands, validator) - validator = textInput.TabCompleter(torCommands.getMatches, validator) + validator = textInput.HistoryValidator(list(reversed(self.interpretor.getBacklog())), validator) + validator = textInput.TabCompleter(self.inputCompleter.getMatches, validator) xOffset = len(torInterpretor.PROMPT[0]) - if len(self.contents) > self.maxY - 1: + displayLength = len(self.interpretor.getDisplayContents(PROMPT_LINE)) + if displayLength > self.maxY - 1: xOffset += 3 # offset for scrollbar - inputLine = min(self.maxY - 1, len(self.contents)) + inputLine = min(self.maxY - 1, displayLength) inputFormat = getFormat(torInterpretor.INPUT_FORMAT) input = self.getstr(inputLine, xOffset, "", inputFormat, validator = validator) input, isDone = input.strip(), False @@ -83,22 +76,10 @@ class InterpretorPanel(panel.Panel): # terminate input when we get a blank line isDone = True else: - self.previousCommands.insert(0, input) - self.previousCommands = self.previousCommands[:BACKLOG_LIMIT] - try: inputEntry, outputEntry = self.interpretor.handleQuery(input) except torInterpretor.InterpretorClosed: isDone = True - - promptEntry = self.contents.pop() # removes old prompt entry - self.contents += inputEntry - self.contents += outputEntry - self.contents.append(promptEntry) - - # if too long then crop lines - cropLines = len(self.contents) - LINES_LIMIT - if cropLines > 0: self.contents = self.contents[cropLines:] if isDone: self.isInputMode = False @@ -112,7 +93,8 @@ class InterpretorPanel(panel.Panel): self.prompt() elif uiTools.isScrollKey(key) and not self.isInputMode: pageHeight = self.getPreferredSize()[0] - 1 - newScroll = uiTools.getScrollPosition(key, self.scroll, pageHeight, len(self.contents)) + displayLength = len(self.interpretor.getDisplayContents(PROMPT_LINE)) + newScroll = uiTools.getScrollPosition(key, self.scroll, pageHeight, displayLength) if self.scroll != newScroll: self.scroll = newScroll @@ -127,17 +109,18 @@ class InterpretorPanel(panel.Panel): self.addstr(0, 0, "Control Interpretor%s:" % usageMsg, curses.A_STANDOUT) xOffset = 0 - if len(self.contents) > height - 1: + displayContents = self.interpretor.getDisplayContents(PROMPT_LINE) + if len(displayContents) > height - 1: # if we're in input mode then make sure the last line is visible if self.isInputMode: - self.scroll = len(self.contents) - height + 1 + self.scroll = len(displayContents) - height + 1 xOffset = 3 - self.addScrollBar(self.scroll, self.scroll + height - 1, len(self.contents), 1) + self.addScrollBar(self.scroll, self.scroll + height - 1, len(displayContents), 1) # draws prior commands and output drawLine = 1 - for entry in self.contents[self.scroll:]: + for entry in displayContents[self.scroll:]: cursor = xOffset for msg, formatEntry in entry: diff --git a/src/util/torInterpretor.py b/src/util/torInterpretor.py index c7bcebb..e062532 100644 --- a/src/util/torInterpretor.py +++ b/src/util/torInterpretor.py @@ -31,6 +31,10 @@ ERROR_FORMAT = (Attr.BOLD, Color.RED) CSI = "\x1B[%sm" RESET = CSI % "0" +# limits used for cropping +BACKLOG_LIMIT = 100 +CONTENT_LIMIT = 2000 + class InterpretorClosed(Exception): """ Exception raised when the interpretor should be shut down. @@ -92,11 +96,10 @@ class TorControlCompleter: if line.startswith("config/*") or line.startswith("dir-usage"): continue - # strips off the ending asterisk if it accepts a value infoOpt = line.split(" ", 1)[0] - if infoOpt.endswith("*"): - infoOpt = infoOpt[:-1] + # strips off the ending asterisk if it accepts a value + if infoOpt.endswith("*"): infoOpt = infoOpt[:-1] self.commands.append("GETINFO %s" % infoOpt) else: self.commands.append("GETINFO ") @@ -157,7 +160,7 @@ class TorControlCompleter: def getMatches(self, text): """ - Provides all options that match the given input. + Provides all options that match the given input. This is case insensetive. Arguments: text - user input text to be matched against @@ -171,10 +174,9 @@ class TorControlCompleter: the readlines set_completer function. """ - for cmd in self.commands: - if cmd.lower().startswith(text.lower()): - if not state: return cmd - else: state -= 1 + for cmd in self.getMatches(text): + if not state: return cmd + else: state -= 1 class ControlInterpretor: """ @@ -183,8 +185,29 @@ class ControlInterpretor: """ def __init__(self): - self.queries = [] # requests made, newest to oldest - self.contents = [] # (msg, format list) tuples of both input and output (oldest to newest) + self.backlog = [] # prior requests the user has made + self.contents = [] # (msg, format list) tuples for what's been displayed + + def getBacklog(self): + """ + Provides the backlog of prior user input. + """ + + return self.backlog + + def getDisplayContents(self, appendPrompt = None): + """ + Provides a list of lines to be displayed, each being a list of (msg, + format) tuples for the content to be displayed. This is ordered as the + oldest to newest. + + Arguments: + appendPrompt - adds the given line to the end + """ + + if appendPrompt: + return self.contents + [appendPrompt] + else: return self.contents def handleQuery(self, input): """ @@ -199,6 +222,12 @@ class ControlInterpretor: """ input = input.strip() + + # appends new input, cropping if too long + self.backlog.append(input) + backlogCrop = len(self.backlog) - BACKLOG_LIMIT + if backlogCrop > 0: self.backlog = self.backlog[backlogCrop:] + inputEntry, outputEntry = [PROMPT], [] conn = torTools.getConn() @@ -258,7 +287,16 @@ class ControlInterpretor: except Exception, exc: outputEntry.append((str(exc), ERROR_FORMAT)) - return (_splitOnNewlines(inputEntry), _splitOnNewlines(outputEntry)) + # converts to lists split on newlines + inputLines = _splitOnNewlines(inputEntry) + outputLines = _splitOnNewlines(outputEntry) + + # appends new contents, cropping if too long + self.contents += inputLines + outputLines + cropLines = len(self.contents) - CONTENT_LIMIT + if cropLines > 0: self.contents = self.contents[cropLines:] + + return (inputLines, outputLines) def prompt(): prompt = format(">>> ", Color.GREEN, Attr.BOLD)

1 0