ji2p 0.0.4-universal-java-11

data/lib/ji2p/package/proxy_support.rb

@@ -0,0 +1,50 @@
+# encoding: utf-8
+require "uri"
+require "java"
+require "erb"
+
+module Ji2p
+  module Package
+    module ProxySupport
+      extend self
+
+      # Apply HTTP_PROXY and HTTPS_PROXY to the current environment
+      # this will be used by any JRUBY calls
+      def apply_env_proxy_settings(settings)
+        $stderr.puts("Using proxy #{settings}") if ENV["DEBUG"]
+        scheme = settings[:protocol].downcase
+        java.lang.System.setProperty("#{scheme}.proxyHost", settings[:host])
+        java.lang.System.setProperty("#{scheme}.proxyPort", settings[:port].to_s)
+        java.lang.System.setProperty("#{scheme}.proxyUsername", settings[:username].to_s)
+        java.lang.System.setProperty("#{scheme}.proxyPassword", settings[:password].to_s)
+      end
+
+      def extract_proxy_values_from_uri(proxy_uri)
+        {
+          :protocol => proxy_uri.scheme,
+          :host => proxy_uri.host,
+          :port => proxy_uri.port,
+          :username => proxy_uri.user,
+          :password => proxy_uri.password
+        }
+      end
+
+      def parse_proxy_string(proxy_string)
+        proxy_uri = URI.parse(proxy_string)
+        if proxy_uri.kind_of?(URI::HTTP) # URI::HTTPS is already a subclass of URI::HTTP
+          proxy_uri
+        else
+          raise "Invalid proxy `#{proxy_uri}`. The URI is not HTTP/HTTPS."
+        end
+      end
+
+      def get_proxy(key)
+        ENV[key.downcase] || ENV[key.upcase]
+      end
+
+      def proxy_string_exists?(proxy)
+        !proxy.nil? && !proxy.strip.empty?
+      end
+    end
+  end
+end

data/lib/ji2p/rspec.rb

@@ -0,0 +1,16 @@
+require_relative 'environment'
+Ji2p::Bundler.setup!({:without => [:build]})
+require 'ji2p'
+
+$LOAD_PATH.unshift(File.join(Ji2p::Environment::JI2P_CORE, "spec"))
+
+require 'rspec/core'
+require 'rspec'
+
+RSpec.world.reset # if multiple rspec runs occur in a single process, the RSpec "world" state needs to be reset.
+
+status = RSpec::Core::Runner.run(ARGV.empty? ? ($JUNIT_ARGV || ["spec"]) : ARGV).to_i
+if ENV["IS_JUNIT_RUN"]
+  return status
+end
+exit status if status != 0

data/lib/ji2p/server.rb

@@ -0,0 +1,10 @@
+module Ji2p
+  module Server
+    autoload :Api, File.expand_path('server/api.rb', __dir__)
+    autoload :Database, File.expand_path('server/database.rb', __dir__)
+    autoload :HTTP, File.expand_path('server/http.rb', __dir__)
+    autoload :HttpServer, File.expand_path('server/http_server.rb', __dir__)
+    autoload :Launcher, File.expand_path('server/launcher.rb', __dir__)
+    autoload :Models, File.expand_path('server/models.rb', __dir__)
+  end
+end

data/lib/ji2p/server/api.rb

@@ -0,0 +1,14 @@
+require 'sinatra'
+require 'rack'
+require 'puma'
+
+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::ContentType then env["CONTENT_TYPE"] = matches[:value]
+        when Rack::ContentLength 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/launcher.rb

@@ -0,0 +1,40 @@
+require 'rack'
+
+module Ji2p::Server
+  class Launcher
+
+    def initialize privateKeyData=nil
+      generate_keypair if privateKeyData.nil?
+      load_keypair privateKeyData unless privateKeyData.nil?
+    end
+
+    protected
+
+    def generate_keypair
+      @keypair = Ji2p::Control::Keypair.generate!
+    end
+
+    def load_keypair privateKeyData
+      @keypair = Ji2p::Control::Keypair.load_from_stream! StringIO.new(privateKeyData)
+    end
+
+  end
+
+  class RackConfigLauncher < Launcher
+
+    def initialize privateKeyData, rackfile
+      super(privateKeyData)
+      @rack_config = rackfile.dup
+    end
+
+    def rack_application
+      raw = File.read(@rack_config)
+      builder = <<~BUILDER
+      Rack::Builder.new do
+        #{raw}
+      end
+      BUILDER
+      eval(builder, nil, @rack_config)
+    end
+  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/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/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/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