i2p 0.1.4

data/lib/i2p/data/key_pair.rb

@@ -0,0 +1,65 @@
+module I2P
+  ##
+  # **I2P key pair data structure.**
+  #
+  # @see   http://docs.i2p2.de/core/net/i2p/data/PrivateKeyFile.html
+  # @since 0.1.3
+  class KeyPair < Structure
+    BYTESIZE = 663 # minimum
+
+    ##
+    # Reads a key pair from the given `input` stream.
+    #
+    # @param  [IO, StringIO] input
+    # @return [KeyPair]
+    def self.read(input)
+      self.new(Destination.read(input), PrivateKey.read(input), SigningPrivateKey.read(input))
+    end
+
+    ##
+    # Initializes a new key pair instance.
+    #
+    # @param  [Destination]       destination
+    # @param  [PrivateKey]        private_key
+    # @param  [SigningPrivateKey] signing_key
+    def initialize(destination, private_key, signing_key)
+      @destination = destination
+      @private_key = private_key
+      @signing_key = signing_key
+    end
+
+    ##
+    # @return [Destination]
+    attr_accessor :destination
+
+    ##
+    # @return [PrivateKey]
+    attr_accessor :private_key
+
+    ##
+    # @return [SigningPrivateKey]
+    attr_accessor :signing_key
+
+    ##
+    # Returns the byte size of this key pair.
+    #
+    # @return [Integer]
+    def size
+      destination.size + private_key.size + signing_key.size
+    end
+    alias_method :bytesize, :size
+
+    ##
+    # Returns the binary string representation of this key pair.
+    #
+    # @return [String]
+    def to_s
+      StringIO.open do |buffer|
+        buffer.write(destination.to_s)
+        buffer.write(private_key.to_s)
+        buffer.write(signing_key.to_s)
+        buffer.string
+      end
+    end
+  end
+end

data/lib/i2p/data/private_key.rb

@@ -0,0 +1,14 @@
+module I2P
+  ##
+  # **I2P private key data structure.**
+  #
+  # An I2P private key is a 2048-bit (256-byte) integer. The private key
+  # represents only the exponent, not the primes, which are constant and
+  # defined in the crypto spec.
+  #
+  # @see   http://docs.i2p2.de/core/net/i2p/data/PrivateKey.html
+  # @since 0.1.3
+  class PrivateKey < Key
+    BYTESIZE = 256
+  end
+end

data/lib/i2p/data/public_key.rb

@@ -0,0 +1,14 @@
+module I2P
+  ##
+  # **I2P public key data structure.**
+  #
+  # An I2P public key is a 2048-bit (256-byte) integer. The public key
+  # represents only the exponent, not the primes, which are constant and
+  # defined in the crypto spec.
+  #
+  # @see   http://docs.i2p2.de/core/net/i2p/data/PublicKey.html
+  # @since 0.1.3
+  class PublicKey < Key
+    BYTESIZE = 256
+  end
+end

data/lib/i2p/data/signing_private_key.rb

@@ -0,0 +1,10 @@
+module I2P
+  ##
+  # **I2P signing private key data structure.**
+  #
+  # @see   http://docs.i2p2.de/core/net/i2p/data/SigningPrivateKey.html
+  # @since 0.1.3
+  class SigningPrivateKey < Key
+    BYTESIZE = 20
+  end
+end

data/lib/i2p/data/signing_public_key.rb

@@ -0,0 +1,10 @@
+module I2P
+  ##
+  # **I2P signing public key data structure.**
+  #
+  # @see   http://docs.i2p2.de/core/net/i2p/data/SigningPublicKey.html
+  # @since 0.1.3
+  class SigningPublicKey < Key
+    BYTESIZE = 128
+  end
+end

data/lib/i2p/data/structure.rb

@@ -0,0 +1,84 @@
+module I2P
+  ##
+  # **I2P data structure.**
+  #
+  # Defines a base class for I2P data structures.
+  #
+  # @see   http://docs.i2p2.de/core/net/i2p/data/DataStructure.html
+  # @see   http://docs.i2p2.de/core/net/i2p/data/DataStructureImpl.html
+  # @since 0.1.3
+  class Structure
+    ##
+    # Parses a data structure from the given `base64` string.
+    #
+    # @param  [String, #to_s] base64
+    # @return [Structure]
+    def self.parse(base64)
+      base64 = base64.dup
+      base64.gsub!('~', '/')
+      base64.gsub!('-', '+')
+      self.read(StringIO.new(base64.unpack('m').first))
+    end
+
+    ##
+    # Reads a data structure from the given `input` stream.
+    #
+    # @param  [IO, StringIO] input
+    # @return [Structure]
+    def self.read(input)
+      raise NotImplementedError.new("#{self}.read")
+    end
+
+    ##
+    # Returns the byte size of this data structure.
+    #
+    # @return [Integer]
+    def size
+      if self.class.const_defined?(:BYTESIZE)
+        self.class.const_get(:BYTESIZE)
+      else
+        raise NotImplementedError.new("#{self.class}#size")
+      end
+    end
+    alias_method :bytesize, :size
+
+    ##
+    # Returns `true` if `other == self` and `other` has the same class as
+    # this data structure.
+    #
+    # @param  [Object] other
+    # @return [Boolean]
+    def eql?(other)
+      other.is_a?(self.class) && self == other
+    end
+
+    ##
+    # Returns `true` if `other` has the same binary string representation as
+    # this data structure.
+    #
+    # @param  [Object] other
+    # @return [Boolean]
+    def ==(other)
+      to_s == other.to_s
+    end
+
+    ##
+    # Returns the Base64-encoded representation of this data structure.
+    #
+    # @return [String]
+    def to_base64
+      base64 = [to_s].pack('m').delete("\n")
+      base64.gsub!('/', '~')
+      base64.gsub!('+', '-')
+      base64
+    end
+
+    ##
+    # Returns the binary string representation of this data structure.
+    #
+    # @return [String]
+    def to_s
+      raise NotImplementedError.new("#{self.class}#to_s")
+    end
+  end
+end

data/lib/i2p/hosts.rb

@@ -0,0 +1,207 @@
+module I2P
+  ##
+  # I2P address book parser.
+  #
+  # @example Opening the default hosts.txt file
+  #   I2P::Hosts.open do |hosts|
+  #     ...
+  #   end
+  #
+  # @example Opening the given hosts.txt file
+  #   I2P::Hosts.open("/path/to/hosts.txt") do |hosts|
+  #     ...
+  #   end
+  #
+  # @since 0.1.2
+  class Hosts
+    include Enumerable
+
+    DEFAULT_FILE = '~/.i2p/hosts.txt' # Unix only
+
+    ##
+    # Looks up the I2P destination for `hostname`.
+    #
+    # @example
+    #   I2P::Hosts["forum.i2p"]
+    #
+    # @param  [String, #to_s] hostname
+    # @return [Destination]
+    def self.[](hostname)
+      self.open { |hosts| hosts[hostname] }
+    end
+
+    ##
+    # Opens a `hosts.txt` file for reading.
+    #
+    # @example Opening the default hosts.txt file
+    #   I2P::Hosts.open do |hosts|
+    #     ...
+    #   end
+    #
+    # @example Opening the given hosts.txt file
+    #   I2P::Hosts.open("/path/to/hosts.txt") do |hosts|
+    #     ...
+    #   end
+    #
+    # @param  [String, #to_s] filename
+    # @param  [Hash{Symbol => Object}] options
+    # @yield  [hosts]
+    # @yieldparam [Hosts] hosts
+    # @return [Hosts]
+    def self.open(filename = DEFAULT_FILE, options = {}, &block)
+      hosts = self.new(filename, options)
+      block_given? ? block.call(hosts) : hosts
+    end
+
+    # @return [Hash]
+    attr_reader :options
+
+    # @return [Hash]
+    attr_reader :cache
+
+    # @return [String]
+    attr_reader :filename
+
+    ##
+    # @param  [String, #to_s]          filename
+    # @param  [Hash{Symbol => Object}] options
+    # @yield  [hosts]
+    # @yieldparam [Hosts] hosts
+    def initialize(filename = DEFAULT_FILE, options = {}, &block)
+      @cache    = {}
+      @filename = File.expand_path(filename.to_s)
+      @options  = options.dup
+      block.call(self) if block_given?
+    end
+
+    ##
+    # Returns `true` if `hosts.txt` doesn't contain any hostnames.
+    #
+    # @example
+    #   hosts.empty?
+    #
+    # @return [Boolean]
+    def empty?
+      count.zero?
+    end
+
+    ##
+    # Returns the number of hostnames in `hosts.txt`.
+    #
+    # @example
+    #   hosts.count
+    #
+    # @return [Integer]
+    def count
+      each.count
+    end
+
+    ##
+    # Returns `true` if `hosts.txt` includes `value`. The `value` can be
+    # either a hostname or an I2P destination.
+    #
+    # @example
+    #   hosts.include?("forum.i2p")
+    #
+    # @param  [Destination, Regexp, #to_s] value
+    # @return [Boolean]
+    def include?(value)
+      case value
+        when Destination then each.any? { |k, v| value.eql?(v) }
+        when Regexp      then each.any? { |k, v| value === k }
+        else each.any? { |k, v| value.to_s.eql?(k) }
+      end
+    end
+
+    ##
+    # Returns the I2P destination for `hostname`.
+    #
+    # @example
+    #   hosts["forum.i2p"]
+    #
+    # @param  [String, #to_s] hostname
+    # @return [Destination]
+    def [](hostname)
+      @cache[hostname.to_s] ||= each_line.find do |line|
+        k, v = parse_line(line)
+        break Destination.parse(v) if hostname === k
+      end
+    end
+
+    ##
+    # Enumerates the hostnames and I2P destinations in `hosts.txt`.
+    #
+    # @example
+    #   hosts.each do |hostname, destination|
+    #     ...
+    #   end
+    #
+    # @yield  [hostname, destination]
+    # @yieldparam [String]      hostname
+    # @yieldparam [Destination] destination
+    # @return [Enumerator]
+    def each(&block)
+      if block_given?
+        each_line do |line|
+          k, v = parse_line(line)
+          block.call(k, Destination.parse(v))
+        end
+      end
+      enum_for(:each)
+    end
+
+    ##
+    # Returns all hostname mappings as an array.
+    #
+    # @return [Array]
+    def to_a
+      each.inject([]) { |result, kv| result.push(kv) }
+    end
+
+    ##
+    # Returns all hostname mappings as a hash.
+    #
+    # @return [Hash]
+    def to_hash
+      each.inject({}) { |result, (k, v)| result.merge!(k => v) }
+    end
+
+    ##
+    # Returns all hostname mappings as a string.
+    #
+    # @return [String]
+    def to_s
+      each.inject([]) { |result, (k, v)| result.push([k, v.to_base64].join('=')) }.push('').join($/)
+    end
+
+  protected
+
+    ##
+    # Enumerates each line in the `hosts.txt` file.
+    #
+    # @yield  [line]
+    # @yieldparam [String] line
+    # @return [Enumerator]
+    def each_line(&block)
+      if block_given?
+        File.open(@filename, 'rb') do |file|
+          file.each_line do |line|
+            line, = line.split('#', 2) if line.include?(?#)
+            line.chomp!.strip!
+            block.call(line) unless line.empty?
+          end
+        end
+      end
+      enum_for(:each_line)
+    end
+
+    ##
+    # Parses a hostname mapping line from `hosts.txt`.
+    #
+    # @param  [String]
+    # @return [Array(String, String)]
+    def parse_line(line)
+      line.chomp.split('=', 2).map(&:strip)
+    end
+  end
+end

data/lib/i2p/sam.rb

@@ -0,0 +1,40 @@
+module I2P
+  ##
+  # **I2P Simple Anonymous Messaging (SAM) protocol.**
+  #
+  # This is an implementation of the SAM V3 protocol, available since I2P
+  # release [0.7.3](http://www.i2p2.de/release-0.7.3.html).
+  #
+  # Note that for security reasons, the SAM application bridge is not
+  # enabled by default in new I2P installations. To use `I2P::SAM`,
+  # you must first manually enable SAM in the router console's
+  # [client configuration](http://localhost:7657/configclients.jsp).
+  #
+  # Note also that I2P by default doesn't bring up the SAM bridge until 120
+  # seconds after router startup. This delay can be changed by editing the
+  # `~/.i2p/clients.config` configuration file.
+  #
+  # @see http://www.i2p2.de/applications.html
+  # @see http://www.i2p2.de/samv3.html
+  module SAM
+    PROTOCOL_VERSION = 3.0
+    DEFAULT_HOST     = (ENV['I2P_SAM_HOST'] || '127.0.0.1').to_s
+    DEFAULT_PORT     = (ENV['I2P_SAM_PORT'] || 7656).to_i
+
+    autoload :Client, 'i2p/sam/client'
+
+    ##
+    # **I2P Simple Anonymous Messaging (SAM) protocol error conditions.**
+    class Error < StandardError                  # I2P_ERROR
+      class ProtocolNotSupported < Error; end    # NOVERSION
+      class SessionIDNotValid < Error; end       # INVALID_ID
+      class SessionIDAlreadyUsed < Error; end    # DUPLICATED_ID
+      class DestinationAlreadyUsed < Error; end  # DUPLICATED_DEST
+      class KeyNotValid < Error; end             # INVALID_KEY
+      class KeyNotFound < Error; end             # KEY_NOT_FOUND
+      class PeerNotReachable < Error; end        # CANT_REACH_PEER
+      class PeerNotFound < Error; end            # PEER_NOT_FOUND
+      class Timeout < Error; end                 # TIMEOUT
+    end
+  end
+end