multitunnels 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5f6ffdbbf77a056e8f65856cb0cadf28981a6603
+  data.tar.gz: 13552a5f830d8b620d59192b98568c62a04a4057
+SHA512:
+  metadata.gz: 59ec67f3950c913fd4ea360a1ff072bf1d883a21073b9f9420ea6388ce07c15f252772db3919ef644d17d0efa7d4252df84a311d4ab724f255d1c66de3bd34ff
+  data.tar.gz: 7068d4edd06ca66d1444c7e5ba9cb14473b19ee5e0bfd77521fc2967cf8e9299a9773a2eb3666303a8dba7cfc0b3f2363de59bca0f16d12453ae9903acd8fd09

data/.gitignore

@@ -0,0 +1,5 @@
+Gemfile.lock
+pkg/
+*~
+*.swp
+*.tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in tunnels.gemspec
+gemspec

data/README.md

@@ -0,0 +1,62 @@
+Tunnels
+=======
+
+![image](http://i.imgur.com/Ej5dz.png)
+
+Tunnels is a proxy to http/https from http/https.
+
+You can run the [Pow](http://pow.cx/) over SSL!
+
+Installation
+------------
+
+    $ gem install multitunnels
+
+Run
+---
+
+    $ sudo multitunnels
+
+If you are using rvm:
+
+    $ rvmsudo multitunnels
+
+By default, proxy to 80 port from 443 port.
+
+specify "http" port and "https" port:
+
+    $ sudo multitunnels 443 3000
+
+or
+
+    $ sudo multitunnels 127.0.0.1:443 127.0.0.1:3000
+or
+
+    $ sudo multitunnels https://127.0.0.1:443 http://127.0.0.1:3000
+
+You can also proxy to 443 port from 80 port.
+
+    $ sudo multitunnels http://127.0.0.1:80 https://127.0.0.1:443
+
+If hostname is '127.0.0.1' or 'localhost', you can choose to omit them.
+
+    $ sudo multitunnels http://:80 https://:443
+
+You can proxy to other host, then you can `curl http://localhost:3000` to visit Google Hongkong
+
+    $ multitunnels http://:3000 https://www.google.com.hk:443
+
+You can proxy from Baidu to Google :) someone might be confused (do not forget to add entry `127.0.0.1 www.baidu.com` to /etc/hosts)
+
+    $ sudo multitunnels http://www.baidu.com https://www.google.com.hk
+
+As the name implies, you can create lots of proxies in one command (but do not forget to add entry `127.0.0.1 www.baidu.com www.samsung.com` to /etc/hosts)
+
+    $ sudo multitunnels http://www.baidu.com https://www.google.com.hk http://www.samsung.com http://www.apple.com 443 80 8000 3000
+
+This command creates four proxies.
+
+Copyright
+---------
+
+Copyright (c) 2012 jugyo, released under the MIT license.

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bin/multitunnels

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+require 'tunnels'
+unless ARGV.size.even?
+  STDERR.puts Tunnels.help
+  exit!
+end
+
+begin
+  Tunnels.run!(ARGV)
+rescue ArgumentError
+  STDERR.puts Tunnels.help
+  exit!
+end

data/lib/tunnels.rb

@@ -0,0 +1,232 @@
+require 'tunnels/version'
+require 'uri'
+require 'eventmachine'
+
+# most of code is from [thin-glazed](https://github.com/freelancing-god/thin-glazed).
+# Copyright © 2012, Thin::Glazed was a Rails Camp New Zealand project, and is developed and maintained by Pat Allan. It is released under the open MIT Licence.
+
+class ClientError < StandardError; end
+
+module Tunnels
+  def self.run!(params)
+    maps = parse_params params
+
+    maps.each do |from, to|
+      puts "#{from[0]}://#{from[1]}:#{from[2]} --(--)--> #{to[0]}://#{to[1]}:#{to[2]}"
+    end
+
+    maps = group_params maps
+
+    EventMachine.run do
+      servers = {}
+      maps.each do |from, map|
+        scheme, port = from
+        servers[from] ||= case scheme
+                          when :https
+                            EventMachine.start_server('127.0.0.1', port, HttpsProxy, map)
+                          when :http
+                            EventMachine.start_server('127.0.0.1', port, HttpProxy, map)
+                          end
+      end
+      puts "Ready :)"
+    end
+  rescue RuntimeError => e
+    STDERR.puts e.message
+    STDERR.puts "Maybe you should run on `sudo`"
+  rescue ClientError => e
+    STDERR.puts e.message
+  end
+
+  def self.help
+    <<-HELP
+Usage:
+    tunnels [from to] [from2 to2] ...
+
+Examples:
+    tunnels 443 3000
+    tunnels localhost:443 localhost:3000
+    tunnels https://:443 http://:3000
+    tunnels https://localhost:443 http://localhost:3000
+
+    HELP
+  end
+
+  private
+    def self.parse_params params = []
+      params = ['443', '80'] if params.empty?
+      maps = split_params params
+      maps.inject({}) do |h, (from, to)|
+        h.merge parse_host_str(from) => parse_host_str(to)
+      end
+    end
+
+    def self.group_params params = {}
+      params.inject({}) do |h, (from, to)|
+        h[[from[0], from[2]]] ||= {}
+        h[[from[0], from[2]]].merge! from => to
+        h
+      end
+    end
+
+    def self.split_params params = []
+      Hash[*params]
+    end
+
+    def self.parse_host_str str
+      raise ArgumentError if str.empty?
+      if str =~ /^:?(\d+)$/
+        [get_scheme($1), '127.0.0.1', $1.to_i]
+      elsif str =~ /^(\w+):\/\/:(\d+)$/
+        [$1.to_sym, '127.0.0.1', $2.to_i]
+      elsif str =~ /:\/\//
+        uri = URI str
+        [uri.scheme.to_sym, uri.host, uri.port]
+      else
+        parts = str.split(':')
+        raise ArgumentError if parts.size != 2
+        [get_scheme(parts[1]), parts[0], parts[1].to_i]
+      end
+    end
+
+    def self.get_scheme port
+      port.to_i == 443 ? :https : :http
+    end
+
+  class HttpClient < EventMachine::Connection
+    attr_reader :proxy, :to_host, :to_port
+
+    def initialize(proxy, from_host, from_port, to_host, to_port)
+      @proxy     = proxy
+      @connected = EventMachine::DefaultDeferrable.new
+      @from_host, @from_port, @to_host, @to_port = from_host, from_port, to_host, to_port
+    end
+
+    def connection_completed
+      @connected.succeed
+    end
+
+    def receive_data(data)
+      proxy.relay_from_client(data)
+    end
+
+    def send(data)
+      @connected.callback { send_data data }
+    end
+
+    def unbind
+      proxy.unbind_client @from_host, @from_port
+    end
+  end
+
+  class HttpsClient < HttpClient
+    def post_init
+      start_tls
+    end
+  end
+
+  class HttpProxy < EventMachine::Connection
+    def initialize(map)
+      map.each do |from, to|
+        make_client from[1], from[2], to[0], to[1], to[2]
+      end
+    end
+
+    def receive_data(data)
+      unless data.nil?
+        client = nil
+        data.sub! /\r\nHost:\s*(.+?)\s*\r\n/i do
+          host, port = $1.split(':') if $1
+          client = client host, port
+          "\r\nHost: #{client.to_host}:#{client.to_port}\r\n"
+        end
+
+        client.send_data data
+      end
+    end
+
+    def relay_from_client(data)
+      send_data data unless data.nil?
+    end
+
+    def unbind
+      close_all_connections
+      clear_clients
+    end
+
+    def unbind_client host, port
+      close_connection_after_writing
+      clear_client host, port.to_i
+    end
+
+    private
+      def make_client from_host, from_port, to_scheme, to_host, to_port
+        from_port, to_port = from_port.to_i, to_port.to_i
+        @clients ||= Hash.new {|h, k| h[k] = {} }
+        @clients[from_host][from_port] =  case to_scheme
+                                          when :http
+                                            EventMachine.connect to_host, to_port, HttpClient, self, from_host, from_port, to_host, to_port
+                                          when :https
+                                            EventMachine.connect to_host, to_port, HttpsClient, self, from_host, from_port, to_host, to_port
+                                          else
+                                            raise ClientError.new "Cannot support scheme: #{to_scheme}"
+                                          end
+      end
+
+      def client host, port
+        port = port.to_i
+        search_client_by_host_and_port(host, port) ||
+        search_client_by_host(host) ||
+        raise(ClientError.new "Cannot find a client for #{host}:#{port}")
+      end
+
+      def search_client_by_host_and_port host, port
+        @clients[host][port] ||
+        @clients['localhost'][port] ||
+        @clients['127.0.0.1'][port] ||
+        @clients['0.0.0.0'][port]
+      end
+
+      def search_client_by_host host
+        @clients[host].values.first ||
+        @clients['localhost'].values.first ||
+        @clients['127.0.0.1'].values.first ||
+        @clients['0.0.0.0'].values.first
+      end
+
+      def clear_client host, port
+        @clients[host].delete port.to_i
+      end
+
+      def close_all_connections
+        @clients.each do |_, host|
+          host.each do |_, client|
+            client.close_connection
+          end
+        end
+      end
+
+      def clear_clients
+        @clients.clear
+      end
+  end
+
+  class HttpsProxy < HttpProxy
+    def post_init
+      start_tls
+    end
+
+    def relay_from_client(data)
+      super
+      @x_forwarded_proto_header_inserted = false
+    end
+
+    def receive_data(data)
+      if !@x_forwarded_proto_header_inserted && data =~ /\r\n\r\n/
+        super data.gsub(/\r\n\r\n/, "\r\nX_FORWARDED_PROTO: https\r\n\r\n")
+        @x_forwarded_proto_header_inserted = true
+      else
+        super
+      end
+    end
+  end
+end

data/lib/tunnels/version.rb

@@ -0,0 +1,3 @@
+module Tunnels
+  VERSION = "1.0.0"
+end

data/spec/spec_helper.rb

@@ -0,0 +1,6 @@
+require 'rspec'
+require 'tunnels'
+
+RSpec.configure do |config|
+  config.mock_with :rr
+end

data/spec/tunnels_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+# to stub
+def EventMachine.run(&block)
+  block.call
+end
+
+describe Tunnels do
+  describe '.run!' do
+    context 'with no args' do
+      it 'works' do
+        mock(EventMachine).start_server('127.0.0.1', 443, Tunnels::HttpsProxy, 80)
+        Tunnels.run!
+      end
+    end
+
+    context 'with args' do
+      it 'works' do
+        mock(EventMachine).start_server('127.0.0.1', 443, Tunnels::HttpsProxy, 80)
+        Tunnels.run!('127.0.0.1:443', '127.0.0.1:80')
+      end
+    end
+  end
+end

data/tunnels.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path('../lib', __FILE__)
+require 'tunnels/version'
+
+Gem::Specification.new do |s|
+  s.name        = 'multitunnels'
+  s.version     = Tunnels::VERSION
+  s.authors     = ['jugyo', 'bachue']
+  s.email       = ['jugyo.org@gmail.com', 'bachue.shu@gmail.com']
+  s.homepage    = "https://github.com/bachue/tunnels"
+  s.summary     = %q{https/http --(--)--> https/http}
+  s.description = %q{This tunnels http/https to http/https.}
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ['lib']
+
+  # specify any dependencies here; for example:
+  # s.add_development_dependency "rspec"
+  s.add_development_dependency 'rspec'
+  s.add_development_dependency 'rr'
+  s.add_runtime_dependency 'eventmachine'
+end

metadata

@@ -0,0 +1,101 @@
+--- !ruby/object:Gem::Specification
+name: multitunnels
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- jugyo
+- bachue
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-06-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rr
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: eventmachine
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: This tunnels http/https to http/https.
+email:
+- jugyo.org@gmail.com
+- bachue.shu@gmail.com
+executables:
+- multitunnels
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- README.md
+- Rakefile
+- bin/multitunnels
+- lib/tunnels.rb
+- lib/tunnels/version.rb
+- spec/spec_helper.rb
+- spec/tunnels_spec.rb
+- tunnels.gemspec
+homepage: https://github.com/bachue/tunnels
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: https/http --(--)--> https/http
+test_files:
+- spec/spec_helper.rb
+- spec/tunnels_spec.rb
+has_rdoc: