onion 0.1.1 → 0.1.2

data/{README.rdoc → License.txt}

@@ -1,22 +1,5 @@
-= Onion
-
-== Introduction
-
-Onion is a library for interacting with Tor. Onion is in an alpha state and is
-made availible for early adopters and contributors only.
-
-== Functionality
-
- * Parse router status entries per the directory protocol version 2.0.
-
-== Authors
-
-Onion was written by Tim Sally <poet@stack.io>. Please send bug reports and
-suggestions to the author.
-
-== License
-
-(The MIT License)
+LICENSE.txt
+===========
 
 Copyright (c) 2010 Tim Sally
 

data/README.txt

@@ -0,0 +1,34 @@
+README.txt
+==========
+
+Introduction
+------------
+
+Onion is a library for interacting with Tor. Onion is in an alpha state and is
+made available for early adopters and contributors only.
+
+Basic Concepts
+--------------
+
+Elements are pieces of the Tor network. Routers, circuits, and streams are 
+examples of elements. You don't care about how the library gets these, you 
+just want to be able to interact with them. Methods in the Control Client 
+return elements.
+
+Parsers take information received from Tor and turn the information into 
+elements. Parsers are used internally by the Control Client to create elements 
+to return to the user.
+
+The Control Client is what you can use in scripts to interact with Tor.
+
+Authors
+-------
+
+Onion was written by Tim Sally <poet@stack.io>. Please send bug reports and
+suggestions to the author.
+
+License
+-------
+
+Copyright (c) 2010 Tim Sally and provided under the MIT License. Please see 
+LICENSE.txt for details.

data/lib/onion.rb

@@ -1,8 +1,8 @@
 module Onion
-
+  require 'onion/control_client'
   require 'onion/elements'
 
-  parsers = %w[ router_lists ]
+  parsers = %w[ common circuit_lists router_statuses stream_lists ]
   parsers.each do |parser|
     begin
       # If there is a pre-compiled parser, load it.

data/lib/onion/control_client.rb

@@ -0,0 +1,87 @@
+require 'logger'
+require 'socket'
+
+module Onion
+  # Onion::ControlClient is a client to the Tor Control Protocol.
+  class ControlClient
+    attr_reader :host, :port
+    
+    def initialize(host="127.0.0.1", port=9051, log_level=Logger::ERROR)
+      @log  = Logger.new(STDOUT)
+      @log.level = log_level
+      
+      @host = host  # Host of the Tor process.
+      @port = port  # Port accepting the Tor Control Protocol.
+      @sock = TCPSocket.new(host, port)
+      
+      @log.info("[TOR CONTROL CLIENT ] Connected to #{host}:#{port}.")
+    end
+
+    def send(text)
+      @sock << "#{text}\r\n"
+      @log.debug("[TOR CONTROL CLIENT] #{text}")
+    end
+    
+    def authenticate(pass="\"\"")
+      send("authenticate #{pass}")
+      @log.debug("[TOR CONTROL CLIENT] #{@sock.gets}")
+    end
+    
+    def extend_circuit(specs, id=0)
+      send("extendcircuit #{id} #{specs.join(",")}")
+      response = @sock.gets
+      if response.split[1] == "EXTENDED"
+        @log.debug("[TOR CONTROL CLIENT] #{response}")
+        return response.split[2]
+      else
+        @log.warn("[TOR CONTROL CLIENT] Circuit (#{specs.join(",")}) was not extended.")
+        @log.warn("[TOR CONTROL CLIENT] #{response}.")
+        
+        return -1
+      end
+    end
+    
+    def attach_stream(stream_id, circuit_id)
+      send("attachstream #{stream_id} #{circuit_id}")
+      response = @sock.gets
+        if response.split[1] == "OK"
+          @log.info("[TOR CONTROL CLIENT] #{response}")
+        else
+          @log.warn("[TOR CONTROL CLIENT] Stream #{stream_id} was not attached to circuit #{circuit_id}.")
+          @log.warn("[TOR CONTROL CLIENT] #{response}.")
+        end
+    end
+    
+    def router_status_info(nicknames=nil,fingerprints=nil)
+      statuses = ""
+      
+      p "start!"
+      
+      if nicknames
+        nicknames.each do |name| 
+          send("getinfo ns/name/#{name}")
+          statuses << @sock.gets          
+        end        
+        while not @sock.eof?
+          statuses << @sock.gets
+        end
+      end
+      p "done!"
+      Onion::RouterList.new(statuses)
+    end
+    
+    def get_stream_status
+      send("getinfo stream-status")
+      result = []
+      line = @sock.gets
+      while line != "250 OK\r\n"
+        unless line == "250+stream-status=\r\n" or line == ".\r\n"
+          line = line.gsub("250-stream-status=", "")
+          result << line
+        end
+        line = @sock.gets
+      end
+      return result
+    end
+  end
+end

data/lib/onion/elements.rb

@@ -1,4 +1,8 @@
 module Onion
+  autoload :Circuit, 'onion/elements/circuit'
+  autoload :CircuitList, 'onion/elements/circuit_list'
   autoload :Router, 'onion/elements/router'
   autoload :RouterList, 'onion/elements/router_list'
+  autoload :Stream, 'onion/elements/stream'
+  autoload :StreamList, 'onion/elements/stream_list'
 end

data/lib/onion/elements/circuit.rb

@@ -0,0 +1,11 @@
+module Onion
+  # Onion::Circuit is an object representing a Tor circuit.
+  class Circuit
+    attr_reader :id, :routers
+    
+    def initialize(id, routers)
+      @id       = id         
+      @routers  = routers 
+    end
+  end
+end

data/lib/onion/elements/circuit_list.rb

@@ -0,0 +1,18 @@
+module Onion
+  # Onion::CircuitList is a list of Onion::Circuit objects.
+  class CircuitList
+    attr_reader :circuits
+    def initialize(text)
+      if text.blank?
+        @circuits = []
+        return self
+      end
+      parser = Onion::CircuitListsParser.new
+      if nodes  = parser.parse(text)
+        @circuits = nodes.circuits
+      else
+        raise Exception, "Couldn't parse #{text} b/c #{parser.failure_reason}."
+      end
+    end
+  end
+end

data/lib/onion/elements/router.rb

@@ -1,10 +1,10 @@
 module Onion
   # Onion::Router is a Ruby object representing a Tor router.
   class Router
-    attr_reader :nick, :id_key_hash, :status_flags
-    def initialize(nick, id_key_hash, status_flags)
+    attr_reader :nick, :fingerprint, :status_flags
+    def initialize(nick, fingerprint, status_flags)
       @nick         = nick         # Nickname of the router.
-      @id_key_hash  = id_key_hash  # Hash of the router identity key.
+      @fingerprint  = fingerprint  # Fingerprint of the router.
       @status_flags = status_flags # Array of strings with status flags.
     end
 

data/lib/onion/elements/router_list.rb

@@ -1,7 +1,5 @@
 module Onion
-  # Onion::RouterList is a list of Onion::Router objects. On initialization,
-  # the text given is parsed with Onion::RouterListParser. The text should be
-  # in the router status format specified by the directory protocol 2.0 spec.
+  # Onion::RouterList is a list of Onion::Router objects. 
   class RouterList
     attr_reader :routers
     def initialize(text)
@@ -9,11 +7,11 @@ module Onion
         @routers = []
         return self
       end
-      parser = Onion::RouterListsParser.new
+      parser = Onion::RouterStatusesParser.new
       if nodes  = parser.parse(text)
         @routers = nodes.routers
       else
-        raise Exception "Couldn't parse #{text} b/c #{parser.failure_reason}."
+        raise Exception, "Couldn't parse #{text} b/c #{parser.failure_reason}."
       end
     end
 
@@ -29,7 +27,7 @@ module Onion
 
     # Returns the routers that are neither guard or exit routers.
     def middlemen
-      @routers.filter { |r| r.guard? or r.exit? }
+      @routers.reject { |r| r.guard? or r.exit? }
     end
   end
 end

data/lib/onion/elements/stream.rb

@@ -0,0 +1,12 @@
+module Onion
+  # Onion::Circuit is an object representing a Tor stream.
+  class Stream
+    attr_reader :stream_id, :circuit_id
+    
+    def initialize(stream_id, circuit_id)
+      @stream_id  = stream_id         
+      @circuit_id = circuit_id 
+    end
+    
+  end
+end

data/lib/onion/elements/stream_list.rb

@@ -0,0 +1,20 @@
+module Onion
+  # Onion::StreamList is a list of Onion::Stream objects.
+  class StreamList
+    attr_reader :streams
+    def initialize(text)
+      if text.blank?
+        @streams = []
+        return self
+      end
+      
+      parser = Onion::StreamListsParser.new
+      if nodes  = parser.parse(text)
+        @streams = nodes.streams
+      else
+        raise Exception, "Couldn't parse #{text} b/c #{parser.failure_reason}."
+      end
+      
+    end
+  end
+end

data/lib/onion/parsers/circuit_lists.rb

@@ -0,0 +1,491 @@
+# Autogenerated from a Treetop grammar. Edits may be lost.
+
+
+module Onion
+  module CircuitLists
+    include Treetop::Runtime
+
+    def root
+      @root ||= :circuit_list
+    end
+
+    include Common
+
+    module CircuitList0
+      def circuits
+        circuits = []
+        self.elements.each do |circuit|
+						if circuit.respond_to? :p
+							to_process = [circuit.p.first] 
+							counter = 1
+							circuit.p.rest.elements.each do |e|
+								to_process << e.LongName
+							end
+							routers = []
+							to_process.each do |router|
+								if router.respond_to? :n
+							    routers << Router.new(router.n.text_value.strip, router.f.text_value.strip, nil)
+							  else
+							    routers << Router.new(nil, nil, nil)
+							  end
+							end
+							circuits << Circuit.new(circuit.id.text_value.strip, routers)
+						else
+							circuits << Circuit.new(circuit.id.text_value.strip, [])
+						end
+        end
+        return circuits
+      end
+    end
+
+    def _nt_circuit_list
+      start_index = index
+      if node_cache[:circuit_list].has_key?(index)
+        cached = node_cache[:circuit_list][index]
+        if cached
+          cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+          @index = cached.interval.end
+        end
+        return cached
+      end
+
+      s0, i0 = [], index
+      loop do
+        r1 = _nt_circuit_list_entry
+        if r1
+          s0 << r1
+        else
+          break
+        end
+      end
+      if s0.empty?
+        @index = i0
+        r0 = nil
+      else
+        r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+        r0.extend(CircuitList0)
+      end
+
+      node_cache[:circuit_list][start_index] = r0
+
+      r0
+    end
+
+    module CircuitListEntry0
+      def id
+        elements[0]
+      end
+
+      def SP1
+        elements[1]
+      end
+
+      def s
+        elements[2]
+      end
+
+      def SP2
+        elements[3]
+      end
+
+      def p
+        elements[4]
+      end
+
+      def SP3
+        elements[5]
+      end
+
+      def purp
+        elements[7]
+      end
+
+    end
+
+    module CircuitListEntry1
+      def id
+        elements[0]
+      end
+
+      def SP1
+        elements[1]
+      end
+
+      def s
+        elements[2]
+      end
+
+      def SP2
+        elements[3]
+      end
+
+      def p
+        elements[4]
+      end
+
+    end
+
+    module CircuitListEntry2
+      def id
+        elements[0]
+      end
+
+      def SP
+        elements[1]
+      end
+
+      def s
+        elements[2]
+      end
+
+    end
+
+    def _nt_circuit_list_entry
+      start_index = index
+      if node_cache[:circuit_list_entry].has_key?(index)
+        cached = node_cache[:circuit_list_entry][index]
+        if cached
+          cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+          @index = cached.interval.end
+        end
+        return cached
+      end
+
+      i0 = index
+      i1, s1 = index, []
+      r2 = _nt_CircuitID
+      s1 << r2
+      if r2
+        r3 = _nt_SP
+        s1 << r3
+        if r3
+          r4 = _nt_CircStatus
+          s1 << r4
+          if r4
+            r5 = _nt_SP
+            s1 << r5
+            if r5
+              r6 = _nt_Path
+              s1 << r6
+              if r6
+                r7 = _nt_SP
+                s1 << r7
+                if r7
+                  if has_terminal?("PURPOSE=", false, index)
+                    r8 = instantiate_node(SyntaxNode,input, index...(index + 8))
+                    @index += 8
+                  else
+                    terminal_parse_failure("PURPOSE=")
+                    r8 = nil
+                  end
+                  s1 << r8
+                  if r8
+                    r9 = _nt_Purpose
+                    s1 << r9
+                    if r9
+                      if has_terminal?("\n", false, index)
+                        r10 = instantiate_node(SyntaxNode,input, index...(index + 1))
+                        @index += 1
+                      else
+                        terminal_parse_failure("\n")
+                        r10 = nil
+                      end
+                      s1 << r10
+                    end
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+      if s1.last
+        r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
+        r1.extend(CircuitListEntry0)
+      else
+        @index = i1
+        r1 = nil
+      end
+      if r1
+        r0 = r1
+      else
+        i11, s11 = index, []
+        r12 = _nt_CircuitID
+        s11 << r12
+        if r12
+          r13 = _nt_SP
+          s11 << r13
+          if r13
+            r14 = _nt_CircStatus
+            s11 << r14
+            if r14
+              r15 = _nt_SP
+              s11 << r15
+              if r15
+                r16 = _nt_Path
+                s11 << r16
+                if r16
+                  if has_terminal?("\n", false, index)
+                    r17 = instantiate_node(SyntaxNode,input, index...(index + 1))
+                    @index += 1
+                  else
+                    terminal_parse_failure("\n")
+                    r17 = nil
+                  end
+                  s11 << r17
+                end
+              end
+            end
+          end
+        end
+        if s11.last
+          r11 = instantiate_node(SyntaxNode,input, i11...index, s11)
+          r11.extend(CircuitListEntry1)
+        else
+          @index = i11
+          r11 = nil
+        end
+        if r11
+          r0 = r11
+        else
+          i18, s18 = index, []
+          r19 = _nt_CircuitID
+          s18 << r19
+          if r19
+            r20 = _nt_SP
+            s18 << r20
+            if r20
+              r21 = _nt_CircStatus
+              s18 << r21
+              if r21
+                if has_terminal?("\n", false, index)
+                  r22 = instantiate_node(SyntaxNode,input, index...(index + 1))
+                  @index += 1
+                else
+                  terminal_parse_failure("\n")
+                  r22 = nil
+                end
+                s18 << r22
+              end
+            end
+          end
+          if s18.last
+            r18 = instantiate_node(SyntaxNode,input, i18...index, s18)
+            r18.extend(CircuitListEntry2)
+          else
+            @index = i18
+            r18 = nil
+          end
+          if r18
+            r0 = r18
+          else
+            @index = i0
+            r0 = nil
+          end
+        end
+      end
+
+      node_cache[:circuit_list_entry][start_index] = r0
+
+      r0
+    end
+
+    module Path0
+      def LongName
+        elements[1]
+      end
+    end
+
+    module Path1
+      def first
+        elements[0]
+      end
+
+      def rest
+        elements[1]
+      end
+    end
+
+    def _nt_Path
+      start_index = index
+      if node_cache[:Path].has_key?(index)
+        cached = node_cache[:Path][index]
+        if cached
+          cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+          @index = cached.interval.end
+        end
+        return cached
+      end
+
+      i0, s0 = index, []
+      r1 = _nt_LongName
+      s0 << r1
+      if r1
+        s2, i2 = [], index
+        loop do
+          i3, s3 = index, []
+          if has_terminal?(",", false, index)
+            r4 = instantiate_node(SyntaxNode,input, index...(index + 1))
+            @index += 1
+          else
+            terminal_parse_failure(",")
+            r4 = nil
+          end
+          s3 << r4
+          if r4
+            r5 = _nt_LongName
+            s3 << r5
+          end
+          if s3.last
+            r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
+            r3.extend(Path0)
+          else
+            @index = i3
+            r3 = nil
+          end
+          if r3
+            s2 << r3
+          else
+            break
+          end
+        end
+        r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
+        s0 << r2
+      end
+      if s0.last
+        r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+        r0.extend(Path1)
+      else
+        @index = i0
+        r0 = nil
+      end
+
+      node_cache[:Path][start_index] = r0
+
+      r0
+    end
+
+    def _nt_CircStatus
+      start_index = index
+      if node_cache[:CircStatus].has_key?(index)
+        cached = node_cache[:CircStatus][index]
+        if cached
+          cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+          @index = cached.interval.end
+        end
+        return cached
+      end
+
+      i0 = index
+      if has_terminal?("LAUNCHED", false, index)
+        r1 = instantiate_node(SyntaxNode,input, index...(index + 8))
+        @index += 8
+      else
+        terminal_parse_failure("LAUNCHED")
+        r1 = nil
+      end
+      if r1
+        r0 = r1
+      else
+        if has_terminal?("BUILT", false, index)
+          r2 = instantiate_node(SyntaxNode,input, index...(index + 5))
+          @index += 5
+        else
+          terminal_parse_failure("BUILT")
+          r2 = nil
+        end
+        if r2
+          r0 = r2
+        else
+          if has_terminal?("EXTENDED", false, index)
+            r3 = instantiate_node(SyntaxNode,input, index...(index + 8))
+            @index += 8
+          else
+            terminal_parse_failure("EXTENDED")
+            r3 = nil
+          end
+          if r3
+            r0 = r3
+          else
+            if has_terminal?("FAILED", false, index)
+              r4 = instantiate_node(SyntaxNode,input, index...(index + 6))
+              @index += 6
+            else
+              terminal_parse_failure("FAILED")
+              r4 = nil
+            end
+            if r4
+              r0 = r4
+            else
+              if has_terminal?("CLOSED", false, index)
+                r5 = instantiate_node(SyntaxNode,input, index...(index + 6))
+                @index += 6
+              else
+                terminal_parse_failure("CLOSED")
+                r5 = nil
+              end
+              if r5
+                r0 = r5
+              else
+                @index = i0
+                r0 = nil
+              end
+            end
+          end
+        end
+      end
+
+      node_cache[:CircStatus][start_index] = r0
+
+      r0
+    end
+
+    def _nt_Purpose
+      start_index = index
+      if node_cache[:Purpose].has_key?(index)
+        cached = node_cache[:Purpose][index]
+        if cached
+          cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+          @index = cached.interval.end
+        end
+        return cached
+      end
+
+      i0 = index
+      if has_terminal?("GENERAL", false, index)
+        r1 = instantiate_node(SyntaxNode,input, index...(index + 7))
+        @index += 7
+      else
+        terminal_parse_failure("GENERAL")
+        r1 = nil
+      end
+      if r1
+        r0 = r1
+      else
+        if has_terminal?("CONTROLER", false, index)
+          r2 = instantiate_node(SyntaxNode,input, index...(index + 9))
+          @index += 9
+        else
+          terminal_parse_failure("CONTROLER")
+          r2 = nil
+        end
+        if r2
+          r0 = r2
+        else
+          @index = i0
+          r0 = nil
+        end
+      end
+
+      node_cache[:Purpose][start_index] = r0
+
+      r0
+    end
+
+  end
+
+  class CircuitListsParser < Treetop::Runtime::CompiledParser
+    include CircuitLists
+  end
+
+end