ji2p 0.0.1-jruby

data/lib/ji2p/control/tunnel_manager.rb

@@ -0,0 +1,62 @@
+require 'java'
+
+require 'java'
+require 'digest/sha1'
+
+module Ji2p::Control
+  class TunnelManager
+    @@tunnelctrl = nil
+    include_package 'net.i2p'
+    include_package 'net.i2p.i2ptunnel'
+    include_package 'net.i2p.client'
+
+    def self.context
+      I2PAppContext.getGlobalContext
+    end
+
+    def self.startTunnelWithConfig conf, createPrivKey = false
+      unless ['client','httpclient','server','httpserver','sockstunnel'].include? conf['type']
+        raise ArgumentError, 'Invalid i2p tunnel type!', caller
+      end
+      tctrl = TunnelController.new conf, '', createPrivKey
+      TunnelCtrl.new tctrl, conf
+    end
+
+    def self.createNewConfig hash = Hash.new
+      props = java.util.Properties.new
+      dfl = {
+        'option.maxPosts'=>'3',
+        'option.i2cp.destination.sigType'=>'EdDSA_SHA512_Ed25519',
+        'option.i2p.streaming.limitAction'=>'http',
+        'description'=>'jruby-tunnel',
+        'interface'=>'127.0.0.1',
+        'type'=>'httpserver',
+        'option.outbound.quantity'=>'4',
+        'option.inbound.quantity'=>'4',
+        'option.postBanTime'=>'1800',
+        'targetPort'=>'8000',
+        'option.postTotalBanTime'=>'600',
+        'i2cpHost'=>'127.0.0.1',
+        'option.postCheckTime'=>'300',
+        'option.i2p.streaming.maxConnsPerHour'=>'40',
+        'option.shouldBundleReplyInfo'=>'false',
+        'option.outbound.length'=>'1',
+        'targetHost'=>'127.0.0.1',
+        'option.inbound.length'=>'1',
+        'i2cpPort'=>'7654',
+        'persistentClientKey'=>'true',
+        'option.maxTotalPosts'=>'10',
+        'option.i2p.streaming.maxConnsPerDay'=>'100',
+        'option.i2p.streaming.maxTotalConnsPerMinute'=>'25',
+        'option.i2p.streaming.maxConnsPerMinute'=>'15',
+        'name'=>'jruby-tunnel',
+        'option.i2p.streaming.maxConcurrentStreams'=>'20',
+        'privKeyFile'=>'kake.dat',
+        'listenPort'=>'8000'
+      }
+      merged = dfl.merge(hash)
+      merged.keys.each { |k| props[k.to_s] = merged[k].to_s }
+      props
+    end
+  end
+end

data/lib/ji2p/control.rb

@@ -0,0 +1,14 @@
+require 'digest/sha1'
+
+module Ji2p
+  module Control
+    autoload :ClientManager, File.expand_path('control/client_manager.rb', __dir__)
+    autoload :Dest, File.expand_path('control/dest.rb', __dir__)
+    autoload :Keypair, File.expand_path('control/keypair.rb', __dir__)
+    autoload :TunnelManager, File.expand_path('control/tunnel_manager.rb', __dir__)
+
+    def self.unique_id
+      Digest::SHA1.hexdigest([Time.now, rand].join)
+    end
+  end
+end

data/lib/ji2p/server/api.rb

@@ -0,0 +1,15 @@
+require 'sinatra'
+require 'rack'
+require 'puma'
+require 'faye/websocket'
+
+module Ji2p::Server
+  class Api
+    def initialize
+      configure { set :server, :puma }
+
+      Faye::WebSocket.load_adapter('puma')
+      @puma = Rack::Handler.get('puma')
+    end
+  end
+end

data/lib/ji2p/server/database.rb

@@ -0,0 +1,66 @@
+require 'active_record'
+
+module Ji2p::Server
+  module Database
+    @@connections = Hash.new
+    @@default_connection = nil
+
+    def self.connect! db=':memory:', db_type='sqlite3'
+      conn = ActiveRecord::Base.establish_connection(database: db, adapter: db_type)
+      key = "#{db}/#{db_type}/#{Ji2p::Control.unique_id.to_s}"
+      @@connections[key] = conn
+      @@default_connection = conn if @@default_connection.nil?
+      define_state_schema!
+      conn
+    end
+
+    def self.connect_with_local_path! name
+      java_import 'net.i2p.I2PAppContext'
+      ctx = Java::NetI2p::I2PAppContext.getGlobalContext
+      path = File.join ctx.getConfigDir.toString, name
+      connect! path
+    end
+
+    def self.flush
+      @@default_connection.flush
+    end
+
+    def self.default
+      @@default_connection
+    end
+
+    def self.is_connected?
+      get_connections.size > 0
+    end
+
+    def self.get_connections
+      @@connections
+    end
+
+    def self.define_state_schema! b_force=false
+      ActiveRecord::Schema.define do
+        create_table :keypairs, force: b_force do |t|
+          t.string   :strid
+          t.string   :name
+          t.text     :destination
+          t.string   :base32
+          t.text     :private_key_data
+          t.json     :metadata
+          t.timestamps
+        end unless ActiveRecord::Base.connection.table_exists? 'keypairs' or b_force
+        create_table :tunnels, force: b_force do |t|
+          t.string     :name
+          t.text       :description
+          t.json       :metadata
+          t.references :keypair
+          t.string     :tunnel_type
+          t.integer    :listen_port
+          t.integer    :target_port
+          t.string     :listen_interface
+          t.string     :target_host
+          t.timestamps
+        end unless ActiveRecord::Base.connection.table_exists? 'tunnels' or b_force
+      end
+    end
+  end
+end

data/lib/ji2p/server/http.rb

@@ -0,0 +1,69 @@
+require 'rack'
+
+module Ji2p::Server
+  class HTTP
+    VERSION = "HTTP/1.1" unless defined? VERSION
+    CRLF = "\r\n" unless defined? CRLF
+
+    def initialize(socket, application)
+      @socket = socket
+      @application = application
+    end
+
+    def parse
+      matches = /\A(?<method>\S+)\s+(?<uri>\S+)\s+(?<version>\S+)#{CRLF}\Z/.match(@socket.readline)
+      uri = URI.parse(matches[:uri])
+
+      env = {
+        "rack.errors" => $stderr,
+        "rack.version" => Rack::VERSION,
+        "rack.url_scheme" => uri.scheme || "http",
+        "REQUEST_METHOD" => matches[:method],
+        "REQUEST_URI" => matches[:uri],
+        "HTTP_VERSION" => matches[:version],
+        "QUERY_STRING" => uri.query || "",
+        "SERVER_PORT" => uri.port || 80,
+        "SERVER_NAME" => uri.host || "localhost",
+        "PATH_INFO" => uri.path || "",
+        "SCRIPT_NAME" => "",
+      }
+
+      while matches = /\A(?<key>[^:]+):\s*(?<value>.+)#{CRLF}\Z/.match(hl = @socket.readline)
+        case matches[:key]
+        when Rack::CONTENT_TYPE then env["CONTENT_TYPE"] = matches[:value]
+        when Rack::CONTENT_LENGTH then env["CONTENT_LENGTH"] = Integer(matches[:value])
+        else env["HTTP_" + matches[:key].tr("-", "_").upcase] ||= matches[:value]
+        end
+      end
+
+      env["rack.input"] = StringIO.new(@socket.read(env["CONTENT_LENGTH"] || 0))
+
+      return env #.map { |_,v| String.new v }
+    end
+
+    def handle
+      env = parse
+
+      status, headers, body = @application.call(env)
+
+      time = Time.now.httpdate
+
+      @socket.write "#{env['HTTP_VERSION']} #{status} #{Rack::Utils::HTTP_STATUS_CODES.fetch(status.to_i) { 'UNKNOWN' }}#{CRLF}"
+      @socket.write "Date: #{time}#{CRLF}"
+      @socket.write "Connection: close#{CRLF}"
+
+      headers.each do |key, value|
+        @socket.write "#{key}: #{value}#{CRLF}"
+      end
+
+      @socket.write(CRLF)
+
+      body.each do |chunk|
+        @socket.write(chunk)
+      end
+
+      Ji2p.logger.info("[#{time}] '#{env["REQUEST_METHOD"]} #{env["REQUEST_URI"]} #{env["HTTP_VERSION"]}' #{status}")
+    end
+
+  end
+end

data/lib/ji2p/server/http_server.rb

@@ -0,0 +1,37 @@
+require_relative 'http.rb'
+
+module Ji2p::Server
+  class HttpServer
+
+    def initialize(application, socket)
+      @application = application
+      @socket = socket
+    end
+
+    def run
+      loop do
+        begin
+          monitor
+        rescue Interrupt
+          Ji2p.logger.log("INTERRUPTED")
+          return
+        end
+      end
+    end
+
+    def monitor
+      #selections, = IO.select(@sockets)
+      #io, = selections
+      io = @socket
+
+      begin
+        socket = io.accept
+        http = Ji2p::Server::HTTP::new(socket, @application)
+        http.handle
+      ensure
+        socket.close
+      end
+    end
+
+  end
+end

data/lib/ji2p/server/initializer.rb

@@ -0,0 +1,4 @@
+module Ji2p::Server
+  module Initializer
+  end
+end

data/lib/ji2p/server/models/base_record.rb

@@ -0,0 +1,7 @@
+require 'active_record'
+
+module Ji2p::Server::Models
+  class BaseRecord < ActiveRecord::Base
+    self.abstract_class = true
+  end
+end

data/lib/ji2p/server/models/keypair.rb

@@ -0,0 +1,32 @@
+require 'active_record'
+require 'base64'
+
+module Ji2p::Server::Models
+  Ji2p::Control::Keypair.class_eval do
+    def to_activerecord
+      row = Ji2p::Server::Models::Keypair.new
+      row.destination = @dest.base64
+      row.base32 = @dest.base32
+      row.private_key_data = Base64.encode64(@data)
+      row
+    end
+
+    private
+
+    def write_dummy_stream obj
+      s = StringIO.new
+      obj.writeBytes(s.to_outputstream)
+      Base64.encode64 s.string
+    end
+  end
+  class Keypair < BaseRecord
+
+    def pk_data
+      Base64.decode64(private_key_data)
+    end
+
+    def getKeypairInstance
+      Ji2p::Control::Keypair.load_from_stream! StringIO.new(pk_data)
+    end
+  end
+end

data/lib/ji2p/server/models/tunnel.rb

@@ -0,0 +1,4 @@
+module Ji2p::Server::Models
+  class Tunnel < BaseRecord
+  end
+end

data/lib/ji2p/server/models.rb

@@ -0,0 +1,9 @@
+require 'active_record'
+
+module Ji2p::Server
+  module Models
+    autoload :BaseRecord, File.expand_path('models/base_record.rb', __dir__)
+    autoload :Keypair, File.expand_path('models/keypair.rb', __dir__)
+    autoload :Tunnel, File.expand_path('models/tunnel.rb', __dir__)
+  end
+end

data/lib/ji2p/server.rb

@@ -0,0 +1,6 @@
+module Ji2p
+  module Server
+    autoload :Api, File.expand_path('server/api.rb', __dir__)
+    autoload :Database, File.expand_path('server/database.rb', __dir__)
+  end
+end

data/lib/ji2p/startup/bootstrap.rb

@@ -0,0 +1,60 @@
+require 'java'
+
+module Ji2p::Startup
+  java_import java.lang.ClassLoader
+  java_import java.lang.System
+
+  class Bootstrap
+    def initialize defaults={'i2p.dir.config' => TMPDIR}
+      @defaults = defaults
+    end
+
+    def set_system_property key, value
+      System.setProperty key.to_s, value.to_s
+    end
+
+    def get_system_property value
+      System.getProperty[value.to_s]
+    end
+
+    def load_jars
+      java_import java.lang.Thread
+      java_import java.net.URL
+      cl = Thread.currentThread.getContextClassLoader
+      dirname = System.getProperties['i2p.dir.base']
+      Dir["#{dirname}/lib/**.jar"].each do |jar|
+        u = Java::JavaNet::URL.new "file://#{jar}"
+        cl.addURL u
+      end
+    end
+
+    def i2p_loaded?
+      java_import java.lang.Thread
+      cl = Thread.currentThread.getContextClassLoader
+      cl.getURLs.select { |item| item.to_s.include? 'i2p.jar' }.size > 0
+    end
+
+    def check_and_set_props!
+      if System.getProperties['i2p.dir.base'].nil?
+        unless ENV['I2PDIR'].nil?
+          System.setProperty 'i2p.dir.base', ENV['I2PDIR'].to_s
+        else
+          raise ArgumentError, 'The system property i2p.dir.base is missing!', caller if @defaults['i2p.dir.base'].nil?
+        end
+      end
+      if System.getProperties['i2p.dir.config'].nil?
+        raise ArgumentError, 'The system property i2p.dir.config is missing!', caller if @defaults['i2p.dir.config'].nil?
+        System.setProperty 'i2p.dir.config', @defaults['i2p.dir.config']
+      end
+      System.setProperty 'java.awt.headless', 'true' if System.getProperties['java.awt.headless'].nil?
+      System.setProperty 'java.library.path', "#{System.getProperties['i2p.dir.base']}/lib" if System.getProperties['java.library.path'].nil?
+    end
+
+    def boot!
+      check_and_set_props!
+      load_jars unless i2p_loaded?
+      RouterManager.start_router!
+      RouterManager.router_context
+    end
+  end
+end

data/lib/ji2p/startup/router_manager.rb

@@ -0,0 +1,21 @@
+require 'java'
+
+module Ji2p::Startup
+  class RouterManager
+    @@router = nil
+    include_package 'net.i2p.router'
+
+    def self.start_router!
+      @@router = RouterLaunch.main ARGV if @@router.nil?
+    end
+
+    def self.router_context
+      RouterContext.getCurrentContext
+    end
+
+    def self.get_leases
+      ctx = RouterManager.router_context
+      ctx.netDb.get_leases.to_a
+    end
+  end
+end

data/lib/ji2p/startup.rb

@@ -0,0 +1,12 @@
+module Ji2p
+  module Startup
+    autoload :Bootstrap, File.expand_path('startup/bootstrap.rb', __dir__)
+    autoload :RouterManager, File.expand_path('startup/router_manager.rb', __dir__)
+
+    TMPDIR = File.expand_path('../../tmp', __dir__) unless defined? TMPDIR
+
+    def self.tmp_dir
+      TMPDIR
+    end
+  end
+end

data/lib/ji2p/version.rb

@@ -0,0 +1,3 @@
+module Ji2p
+  VERSION = '0.0.1'.freeze unless defined? VERSION
+end

data/lib/ji2p.rb

@@ -0,0 +1,19 @@
+require 'active_support/dependencies'
+require 'logger'
+
+module Ji2p
+  require_relative 'ji2p/version.rb'
+  autoload :Cluster, File.expand_path('ji2p/cluster.rb', __dir__)
+  autoload :Control, File.expand_path('ji2p/control.rb', __dir__)
+  autoload :Server,  File.expand_path('ji2p/server.rb', __dir__)
+  autoload :Startup, File.expand_path('ji2p/startup.rb', __dir__)
+  ActiveSupport::Dependencies.autoload_paths << __dir__
+  Dir.glob('**/').each do |dir|
+    ActiveSupport::Dependencies.autoload_paths << File.expand_path(dir, __dir__)
+  end
+
+  def self.logger
+    @logger ||= Logger.new(STDOUT)
+  end
+
+end