pipe2me-client 0.2.8 → 0.2.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8968003f722e5a557b48c68a931a956df97cd349
-  data.tar.gz: d8092a7be2cfcb52ca99c93fb507aa4ffb3f41ce
+  metadata.gz: 8eceaa5c69187b15f7b43b0fe2cdbe1dd9b7281f
+  data.tar.gz: ca812510cb4937691876f1fc8b5642b50cea853d
 SHA512:
-  metadata.gz: fe87297cd767ce05ba03e4e37b63ae9eb4a90d24c9d7275a6cfc7744b5b262223e7a2f1f0b982eb1287e564854722d81cd92066483b54e2b1e056942282142e3
-  data.tar.gz: 9a48bf4a510a9bf8145492c52861e27619fbba879a934c5bab9a694e546b4dc7360894f18143da48e1a95cabf9cf4f182234aab3462bbe6052abdedacb3ff1d6
+  metadata.gz: ee65b0e72ff5c66bb7bca14a7c2724a0e7f1717b33696d0b9aaf1aa1f7a87b1a8ea78cffab3f4d08df416a6dcf17c1f72d13db195a3be7037da69194193dedfe
+  data.tar.gz: 7fa92f1490c22365e4a8ca87f0ed4480429923694ba24d6c2ac897db6f37162ca64b1fc7493b67698342951d881364386aa6761d67afcc97cd958f127247dd90

data/README.md

@@ -1,6 +1,6 @@
 # pipe2me client
 
-This is the ruby client for the pipe2me server package. 
+This is the ruby client for the pipe2me server package.
 The pipe2me client lets you publish local services to the public internet
 with the help and orchestration of a pipe2me server. For more details
 see [pipe2me](https://github.com/kinko/pipe2me)
@@ -15,7 +15,7 @@ To install it run
     sudo cp doc/pipe2me.1 /usr/local/share/man/man1
 
 If you are managing a box with a system-wide ruby installation you must install
-it via 
+it via
 
     sudo gem install pipe2me-client
 
@@ -25,13 +25,13 @@ Verify the installation with
 
 ## Usage
 
-Mini-example: This registers two tunnels with a single hostname for 
-two services on localhost (http on port 9090, https on port 9091). 
+Mini-example: This registers two tunnels with a single hostname for
+two services on localhost (http on port 9090, https on port 9091).
 
 <pre>
 # Setup tunnels. This responds with the domain name
 &gt; <b>pipe2me setup --protocols http,https \
-       --server http://test.pipe2.me:8080 \
+       --server http://test.pipe2.me \
        --token review@pipe2me --ports 9090,9091</b>
 pretty-ivory-horse.test.pipe2.me
 
@@ -44,31 +44,31 @@ PIPE2ME_URLS_1=https://pretty-ivory-horse.test.pipe2.me:10004
 &gt; <b>pipe2me start</b>
 </pre>
 
-See also the [example session](http://test.pipe2.me/example_session.html) 
+See also the [example session](http://test.pipe2.me/example_session.html)
 and the [man page](http://test.pipe2.me/pipe2me.1.html).
 
 ## Testing
 
-Tests are implemented using 
-[roundup](https://github.com/bmizerany/roundup/blob/master/INSTALLING#files).
-To install roundup on OSX, run `brew install roundup`. Other systems are 
-supported as well, compare roundup's documentation for details.
+Tests are implemented using roundup.
+To install roundup on OSX, run `brew install roundup`. Other systems are
+supported as well, [compare roundup's documentation](https://github.com/bmizerany/roundup/blob/master/INSTALLING#files)
+for details.
 
-The implemented tests are *integration tests* in the sense, that they test the 
-behaviour of the *pipe2me-client* package in connection to an external pipe2me 
-server. That means you should run a pipe2me server on your local machine. Note 
+The implemented tests are *integration tests* in the sense, that they test the
+behaviour of the *pipe2me-client* package in connection to an external pipe2me
+server. That means you should run a pipe2me server on your local machine. Note
 that the server must be configured to support test mode. (In test mode a pipe2me
-server accepts test auth tokens, that create short lived tunnels 
-with self-signed certificates.) 
+server accepts test auth tokens, that create short lived tunnels
+with self-signed certificates.)
 
 To run the tests against a locally installed test server run `rake`. Note that
 the local test server is expected at "pipe2.dev:8080". You might have to adjust
-the `/etc/hosts` file to add an entry 
+the `/etc/hosts` file to add an entry
 
     127.0.0.1    pipe2.dev
 
-Before submitting a pull request you should also run a test against the 
-test.pipe2.me instance, which is available most of the time for that purpose. 
+Before submitting a pull request you should also run a test against the
+test.pipe2.me instance, which is available most of the time for that purpose.
 To do that, run `rake test:release`.
 
 ## Tunnel tokens
@@ -76,9 +76,9 @@ To do that, run `rake test:release`.
 As ports and domain names are sparse resources the pipe2me server API
 requires the use of authorization tokens when requesting a tunnel. A
 token is similar to a 'currency' in that it describes which tunnels are
-supported. A token could limit the number of ports that can be tunnelled, 
-the amount of traffic for those ports, whether or not a certificate is 
-self-signed or signed by a regular CA, etc. 
+supported. A token could limit the number of ports that can be tunnelled,
+the amount of traffic for those ports, whether or not a certificate is
+self-signed or signed by a regular CA, etc.
 
 
 The features of a token are not defined within this protocol. However,
@@ -87,24 +87,24 @@ to know more.
 
 A freshly installed pipe2me server comes with a number of preconfigured tokens.
 Of course, a server admin should (and probably would) change those tokens.
-However, as a test target, the pipe2me test server at http://test.pipe2.me:8080
-supports these tokens: 
+However, as a test target, the pipe2me test server at http://test.pipe2.me
+supports these tokens:
 
 - `test@pipe2me`: this builds tunnels that are available for 5 minutes.
   The test token is intended for use with automated test scenarios.
-- `review@pipe2me`: this builds tunnels that are available for up to 
+- `review@pipe2me`: this builds tunnels that are available for up to
   one day. A review token should help you get a feel for the pipe2me
-  package. 
+  package.
 
-If you need a longer lived token for development, review and/or test 
-feel free to contact us at contact@kinko.me. 
+If you need a longer lived token for development, review and/or test
+feel free to contact us at contact@kinko.me.
 
 ## Licensing
 
-**The pipe2me client software** is (c) The Kinko Team, 2014 and released to you 
+**The pipe2me client software** is (c) The Kinko Team, 2014 and released to you
 under the terms of the MIT License (MIT), see COPYING.MIT for details.
 
 The subdirectory lib/vendor contains third-party code, which is subject to its own copyrights.
 Please see the respective source files for copyright information.
- 
+
 (c) The kinko team, 2014

data/lib/pipe2me/bin/natpmpc

@@ -0,0 +1,337 @@
+#!/usr/bin/env jit cc -g -Werror -Wall -lnatpmp --
+
+/* $Id: natpmpc.c,v 1.13 2012/08/21 17:23:38 nanard Exp $ */
+/* libnatpmp
+Copyright (c) 2007-2011, Thomas BERNARD
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright notice,
+      this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright notice,
+      this list of conditions and the following disclaimer in the documentation
+      and/or other materials provided with the distribution.
+    * The name of the author may not be used to endorse or promote products
+	  derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.
+*/
+#include <stdio.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <string.h>
+#if defined(_MSC_VER)
+#if _MSC_VER >= 1400
+#define strcasecmp _stricmp
+#else
+#define strcasecmp stricmp
+#endif
+#else
+#include <unistd.h>
+#endif
+#ifdef WIN32
+#include <winsock2.h>
+#else
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#endif
+
+// #define ENABLE_STRNATPMPERR
+
+#include "natpmp.h"
+
+static const char * argv0;
+static FILE* debug;
+
+static void usage()
+{
+	fprintf(stderr, "Usage :\n");
+	fprintf(stderr, "  %s [options]\n", argv0);
+	fprintf(stderr, "\tdisplay the public IP address.\n");
+	fprintf(stderr, "  %s [options] [protcol:]<public port>[:<private port>] <public port>[:<private port>] ... \n", argv0);
+	fprintf(stderr, "\tadd map one or more ports. protocol is 'tcp' or 'udp'.\n");
+	fprintf(stderr, "\nOption available :\n");
+	fprintf(stderr, "  -g ipv4address\n\tforce the gateway to be used as destination for NAT-PMP commands.\n");
+	fprintf(stderr, "  -l lifetime\n\tset lifetime for port mapping.\n");
+	fprintf(stderr, "  -v\n\tbe verbose.\n");
+	fprintf(stderr, "\n  In order to remove a mapping, set it with a lifetime of 0 seconds.\n");
+	fprintf(stderr, "  To remove all mappings for your machine, use 0 as private port and lifetime.\n");
+
+	exit(1);
+}
+
+#define NO		0
+#define YES		1
+
+typedef struct {
+	int protocol;
+	uint16_t privateport;
+	uint16_t publicport;
+	uint32_t lifetime;
+} port_mapping_t;
+
+#define MAX_PORT_MAPPINGS 32
+
+typedef struct {
+	int verbose;
+	int gateway;
+	port_mapping_t port_mappings[MAX_PORT_MAPPINGS];
+	unsigned port_mappings_count;
+} arguments_t;
+
+/*
+ * == Argument parsing ========================================================
+ */
+
+static void parse_port_mapping(const char* s, port_mapping_t* p_port_mapping) {
+	p_port_mapping->publicport = 0;
+	p_port_mapping->privateport = 0;
+	p_port_mapping->protocol = NATPMP_PROTOCOL_TCP;
+
+	if(0 == strncasecmp(s, "tcp:", 4)) {
+		s += 4;
+	}
+	else if(0 == strncasecmp(s, "udp:", 4)) {
+		p_port_mapping->protocol = NATPMP_PROTOCOL_UDP;
+		s += 4;
+	}
+
+	if(2 == sscanf(s, "%hu:%hu", &p_port_mapping->publicport, &p_port_mapping->privateport)) {
+		return;
+	}
+
+	if(1 == sscanf(s, "%hu", &p_port_mapping->publicport)) {
+		p_port_mapping->privateport = p_port_mapping->publicport;
+		return;
+	}
+
+	fprintf(stderr, "Cannot parse port mapping '%s'\n", s);
+	exit(1);
+}
+
+static void parse_args(const char** argv, arguments_t* args) {
+	in_addr_t lifetime = 3600;
+
+	args->verbose = NO;
+	args->gateway = 0;
+	args->port_mappings_count = 0;
+
+	/* argument parsing */
+	while(*++argv) {
+		if(*argv[0] == '-') {
+			switch((*argv)[1]) {
+			case 'g':
+				if(!*++argv) usage();
+				args->gateway = inet_addr(*argv);
+				break;
+			case 'l':
+				if(!*++argv) usage();
+				lifetime = (unsigned)strtoul(*argv, (char **)NULL, 10);
+				break;
+			case 'v':
+				args->verbose = YES;
+				break;
+			default:
+				usage();
+			};
+			continue;
+		}
+
+		if(args->port_mappings_count == MAX_PORT_MAPPINGS) {
+			fprintf(stderr, "Cannot map more than %d ports at once.\n", MAX_PORT_MAPPINGS);
+			exit(1);
+		}
+
+		port_mapping_t* port_mapping = args->port_mappings + args->port_mappings_count;
+		parse_port_mapping(*argv, port_mapping);
+		port_mapping->lifetime = lifetime;
+		args->port_mappings_count++;
+	}
+}
+
+#define MAX_TRIES 6
+
+/*
+ * == NAT-PMP high level interface ============================================
+ */
+
+static int natpmp_init(natpmp_t* natpmp, arguments_t* args)
+{
+	int r = initnatpmp(natpmp, args->gateway != 0, args->gateway);
+	fprintf(debug, "initnatpmp() returned %d (%s)\n", r, r?"FAILED":"SUCCESS");
+	if(r < 0) return NO;
+
+	/* log gateway */
+	struct in_addr gateway_in_use;
+	gateway_in_use.s_addr = natpmp->gateway;
+	fprintf(debug, "using NAT-PMP gateway : %s\n", inet_ntoa(gateway_in_use));
+
+	return YES;
+}
+
+static void natpmp_close(natpmp_t* natpmp)
+{
+	int r = closenatpmp(natpmp);
+	fprintf(debug, "closenatpmp() returned %d (%s)\n", r, r==0?"SUCCESS":"FAILED");
+}
+
+static natpmpresp_t* natpmp_wait_for_success_response(natpmp_t* natpmp, natpmpresp_t* response) {
+	int remaining_tries = MAX_TRIES;
+
+	while(remaining_tries > 0) {
+		fd_set fds;
+		struct timeval timeout;
+
+		FD_ZERO(&fds);
+		FD_SET(natpmp->s, &fds);
+		getnatpmprequesttimeout(natpmp, &timeout);
+
+		if(0 > select(FD_SETSIZE, &fds, NULL, NULL, &timeout)) {
+			perror("select()");
+			return 0;
+		}
+
+		int r = readnatpmpresponseorretry(natpmp, response);
+		int sav_errno = errno;
+		fprintf(debug, "readnatpmpresponseorretry returned %d (%s)\n", r, r==0?"OK":(r==NATPMP_TRYAGAIN?"TRY AGAIN":"FAILED"));
+		if(r == 0) {
+			fprintf(debug, "epoch = %u\n", response->epoch);
+			return response;
+		}
+
+		if(r != NATPMP_TRYAGAIN) {
+#ifdef ENABLE_STRNATPMPERR
+			fprintf(debug, "readnatpmpresponseorretry() failed : %s\n", strnatpmperr(r));
+#endif
+			fprintf(debug, "  errno=%d '%s'\n", sav_errno, strerror(sav_errno));
+			return 0;
+		}
+	}
+
+	fprintf(stderr, "Giving up after %d tries.\n", MAX_TRIES);
+	return 0;
+}
+
+static const char* natpmp_public_address(natpmp_t* natpmp, char* publicaddress)
+{
+	int r = sendpublicaddressrequest(natpmp);
+	fprintf(debug, "sendpublicaddressrequest returned %d (%s)\n", r, r==2?"SUCCESS":"FAILED");
+	if(r<0) return 0;
+
+	natpmpresp_t response_buf;
+	natpmpresp_t *response = natpmp_wait_for_success_response(natpmp, &response_buf);
+	if(!response)
+		return 0;
+
+	/* TODO : check that response.type == 0 */
+	fprintf(debug, "Public IP address : %s\n", inet_ntoa(response->pnu.publicaddress.addr));
+	sprintf(publicaddress, "%s", inet_ntoa(response->pnu.publicaddress.addr));
+
+	return publicaddress;
+}
+
+static int natpmp_map_port(natpmp_t* natpmp, port_mapping_t* port_mapping, unsigned* lifetime) {
+	int r = sendnewportmappingrequest(natpmp, port_mapping->protocol,
+				port_mapping->privateport, port_mapping->publicport,
+				port_mapping->lifetime);
+	fprintf(debug, "sendnewportmappingrequest returned %d (%s)\n",
+	       r, r==12?"SUCCESS":"FAILED");
+	if(r < 0)
+		return NO;
+
+	natpmpresp_t response_buf;
+	natpmpresp_t *response = natpmp_wait_for_success_response(natpmp, &response_buf);
+	if(!response) return NO;
+
+	*lifetime = response->pnu.newportmapping.lifetime;
+	return YES;
+}
+
+/*
+ * == main ====================================================================
+ */
+
+int main(int argc, const char ** argv)
+{
+
+#ifdef WIN32
+	WSADATA wsaData;
+	int nResult = WSAStartup(MAKEWORD(2,2), &wsaData);
+	if(nResult != NO_ERROR)
+	{
+		fprintf(stderr, "WSAStartup() failed.\n");
+		return -1;
+	}
+#endif
+
+	argv0 = argv[0];
+	arguments_t args;
+
+	parse_args(argv, &args);
+
+	debug = args.verbose ? stderr : fopen("/dev/null", "w");
+
+	// if(args.verbose) {
+	// 	unsigned i = 0;
+	// 	for(i = 0; i<args.port_mappings_count; ++i) {
+	// 		port_mapping_t* mapping = args.port_mappings + i;
+	//
+	// 		const char* protocol = mapping->protocol == NATPMP_PROTOCOL_UDP ? "udp" : "tcp";
+	// 		fprintf(stderr, "%s: public:%hu -> localhost:%hu: pending (lifetime %u)\n", 
+	// 			protocol, mapping->publicport, mapping->privateport, mapping->lifetime);
+	// 	}
+	// }
+
+	/*
+	 * Try to get NAT-PMP public IP. We use that to decide whether we are
+	 * going NAT-PMP or UPnP.
+	 */
+
+	natpmp_t natpmp;
+
+	if(!natpmp_init(&natpmp, &args)) {
+		fprintf(stderr, "Cannot initialize NAT-PMP.\n");
+		return 1;
+	}
+
+	char publicaddress_buf[32];
+	const char* publicaddress = natpmp_public_address(&natpmp, publicaddress_buf);
+	if(!publicaddress) {
+		fprintf(stderr, "NAT-PMP: Cannot find public IP address. NAT-PMP is not available.\n");
+	}
+
+	if(publicaddress) {
+		if(args.port_mappings_count == 0)
+			printf("%s\n", publicaddress);
+
+		unsigned i = 0;
+		for(i = 0; i<args.port_mappings_count; ++i) {
+			port_mapping_t* mapping = args.port_mappings + i;
+
+			unsigned lifetime = 0;
+			int r = natpmp_map_port(&natpmp, mapping, &lifetime);
+
+			const char* protocol = mapping->protocol == NATPMP_PROTOCOL_UDP ? "udp" : "tcp";
+			fprintf(stderr, "NAT-PMP: %s: %s:%hu -> localhost:%hu: %s (lifetime %u)\n", 
+				protocol, publicaddress, mapping->publicport, mapping->privateport, (r ? "OK" : "FAIL"), lifetime);
+
+			if(!r) break;
+		}
+	}
+
+	natpmp_close(&natpmp);
+	return 0;
+}
+

data/lib/pipe2me/cli-foreman.rb

@@ -3,16 +3,20 @@ class Pipe2me::CLI < Thor
   option :echo, :type => :boolean, :banner => "Also run echo servers"
   def start
     handle_global_options
-    
+
     procfile = options[:echo] ? "pipe2me.procfile.echo" : "pipe2me.procfile"
 
     File.open procfile, "w" do |io|
       Pipe2me::Tunnel.tunnel_commands.each do |name, cmd|
         io.write "#{name}: #{cmd}\n"
       end
-      
+
+      # Pipe2me::Tunnel.mapping_commands.each do |name, cmd|
+      #   io.write "#{name}: #{cmd}\n"
+      # end
+
       next unless options[:echo]
-        
+
       Pipe2me::Tunnel.echo_commands.each do |name, cmd|
         io.write "#{name}: #{cmd}\n"
       end

data/lib/pipe2me/cli-monit.rb

@@ -4,32 +4,37 @@ class Pipe2me::CLI < Thor
   option :echo, :type => :boolean, :banner => "Also run echo servers"
   def monit(*args)
     handle_global_options
-    
+
     monitrc_file = create_monitrc
-    
+
     UI.warn "Running: monit -c #{monitrc_file} #{args.join(" ")}"
     Kernel.exec "monit", "-c", monitrc_file, *args
   end
-  
+
   desc "monitrc", "Create monitrc file"
   option :port, :default => 5555, :banner => "control port"
   option :echo, :type => :boolean, :banner => "Also run echo servers"
   def monitrc
     handle_global_options
-    
+
     monitrc_file = create_monitrc
     Kernel.exec "monit", "-c", monitrc_file, "-t"
   end
 
   private
-  
+
+  def which!(cmd)
+    path = `which #{cmd}`.chomp
+    raise "Cannot find #{cmd} in your $PATH. Is it installed?" if path == ""
+    path
+  end
+
   def create_monitrc
     path = options[:echo] ? "pipe2me.monitrc.echo" : "pipe2me.monitrc"
 
     # The daemon binary
-    daemon_bin = `which daemon`.chomp 
-    daemon = "#{daemon_bin} -D #{File.expand_path(Dir.getwd)}"
-    
+    daemon = "#{which! :daemon} -D #{File.expand_path(Dir.getwd)}"
+
     port = options[:port]
 
     logfile = File.expand_path "pipe2me.monit.log"
@@ -37,22 +42,23 @@ class Pipe2me::CLI < Thor
     FileUtils.mkdir_p piddir
 
     commands = Pipe2me::Tunnel.tunnel_commands
+    # commands += Pipe2me::Tunnel.mapping_commands
     commands += Pipe2me::Tunnel.echo_commands if options[:echo]
-    
+
     File.open path, "w", 0600 do |io|
       require "erb"
 
       erb = ERB.new MONITRC_ERB
       io.write erb.result(self.send(:binding))
     end
-    
+
     UI.success "Created #{path}"
-    
+
     path
   end
 
 MONITRC_ERB =  %q{
-set daemon 10 
+set daemon 10
 set httpd port <%= port %> and use address localhost allow localhost
 
 <% commands.each do |name, cmd| %>

data/lib/pipe2me/cli.rb

@@ -2,12 +2,12 @@ require "thor"
 
 class Pipe2me::CLI < Thor
   class_option :dir, :type => :string
-  class_option :verbose, :type => :boolean, :aliases => :v
-  class_option :quiet, :type => :boolean, :aliases => :q
+  class_option :verbose, :type => :boolean, :aliases => "-v"
+  class_option :quiet, :type => :boolean, :aliases => "-q"
   class_option :silent, :type => :boolean
-  
+
   private
-  
+
   def handle_global_options
     UI.verbosity = 2
     if options[:verbose]
@@ -25,24 +25,24 @@ class Pipe2me::CLI < Thor
   end
 
   public
-  
+
   def self.exit_on_failure?; true; end
-  
+
   desc "version", "print version information"
   def version
     handle_global_options
-    
+
     puts Pipe2me::VERSION
   end
 
   desc "setup", "fetch a new tunnel setup"
-  option :server, :aliases => :s, :default => "http://test.pipe2.me:8080"
+  option :server, :aliases => "-s", :default => "http://test.pipe2.me"
   option :token, :required => true                    # "tunnel token"
   option :protocols, :default => "https"              # "protocol names, e.g. 'http,https,imap'"
   option :ports, :type => :string                     # "local ports, one per protocol"
   def setup
     handle_global_options
-    
+
     Pipe2me::Config.server = options[:server]
     server_info = Pipe2me::Tunnel.setup options
 
@@ -53,7 +53,7 @@ class Pipe2me::CLI < Thor
   desc "env", "show tunnel configuration"
   def env(*args)
     handle_global_options
-    
+
     puts File.read("pipe2me.local.inc")
     puts File.read("pipe2me.info.inc")
   end
@@ -61,21 +61,21 @@ class Pipe2me::CLI < Thor
   desc "verify", "Verify the tunnel"
   def verify
     handle_global_options
-    
+
     Pipe2me::Tunnel.verify
   end
 
   desc "update", "Updates configuration"
   def update
     handle_global_options
-    
+
     Pipe2me::Tunnel.update
   end
-  
+
   desc "check", "check online status"
   def check
     handle_global_options
-    
+
     Pipe2me::Tunnel.check
   end
 end

data/lib/pipe2me/config.rb

@@ -2,6 +2,6 @@ require "tmpdir"
 
 module Pipe2me::Config
   extend self
-  
+
   attr :server, true
 end

data/lib/pipe2me/ext/http.rb

@@ -21,10 +21,10 @@ module Pipe2me::HTTP
     end
 
     extend Forwardable
-    delegate [ :code, :url ] => :@response 
+    delegate [ :code, :url ] => :@response
 
     def message #:nodoc:
-      "#{url}: #{code} #{@response[0..120]} (#{@response.response.class})" 
+      "#{url}: #{code} #{@response[0..120]} (#{@response.response.class})"
     end
   end
 

data/lib/pipe2me/ext/sys.rb

@@ -2,14 +2,14 @@ require "shellwords"
 
 module Pipe2me::Sys
   extend self
-  
+
   class ExitError < RuntimeError; end
-  
+
   def sys(*args)
     cmd, stdout = _sys(*args)
     return stdout if $?.exitstatus == 0
   end
-  
+
   def sys!(*args)
     cmd, stdout = _sys(*args)
     return stdout if $?.exitstatus == 0
@@ -19,18 +19,18 @@ module Pipe2me::Sys
   def sh(*args)
     sys "sh", "-c", *args
   end
-  
+
   def sh!(*args)
     sys! "sh", "-c", *args
   end
-  
+
   private
-  
+
   def _sys(*args)
     cmd = args.
       map { |arg| Shellwords.escape arg.to_s }.
       join(" ")
-    
+
     UI.debug cmd
     stdout = IO.popen(cmd, &:read)
     [ cmd, stdout ]

data/lib/pipe2me/tunnel/commands.rb

@@ -7,7 +7,7 @@ module Pipe2me::Tunnel::Commands
   def tunnels
     @tunnels ||= begin
       urls, ports = config.urls, config.ports.to_s.split(",")
-    
+
       urls.zip(ports).map do |url, local_port|
         uri = URI.parse(url)
         [ uri.scheme, uri.port, local_port || uri.port ]
@@ -16,17 +16,25 @@ module Pipe2me::Tunnel::Commands
   end
 
   public
-  
+
   # return an arry [ [name, command ], [name, command ], .. ]
   def tunnel_commands
     tunnel_uri = URI.parse config.tunnel
-    
+
     tunnels.map do |protocol, remote_port, local_port|
       next unless cmd = port_tunnel_command(tunnel_uri, protocol, remote_port, local_port)
       [ "#{protocol}_#{remote_port}", cmd ]
     end.compact
   end
-  
+
+  # def mapping_commands
+  #   natpmpc = File.expand_path "#{File.dirname(__FILE__)}/../bin/natpmpc"
+  #   mappings = tunnels.map do |_, remote_port, local_port|
+  #     "tcp:#{remote_port}:#{local_port}"
+  #   end
+  #   [ [ "natpmpc", "#{natpmpc} #{mappings.join(" ")} && sleep 10000" ] ]
+  # end
+
   def echo_commands
     tunnels.map do |protocol, remote_port, local_port|
       next unless cmd = echo_server_command(protocol, local_port)
@@ -41,10 +49,10 @@ module Pipe2me::Tunnel::Commands
     raise "Cannot find #{cmd} in your $PATH. Is it installed?" if path == ""
     path
   end
-  
+
   def port_tunnel_command(tunnel_uri, protocol, remote_port, local_port)
     autossh = which! :autossh
-    
+
     cmd = <<-SHELL
       env AUTOSSH_GATETIME=0                                # comments work here..
       #{autossh}
@@ -55,12 +63,13 @@ module Pipe2me::Tunnel::Commands
       -i #{T::SSH_PRIVKEY}
       -o StrictHostKeyChecking=no
       -o UserKnownHostsFile=pipe2me.known_hosts
+      -o PasswordAuthentication=no
       -N
     SHELL
-    
+
     # remove comments and newlines from commands
     cmd.gsub(/( *#.*|\s+)/, " ").gsub(/(^ )|( $)/, "")
-  end  
+  end
 
   def echo_server_command(protocol, port)
     binary = File.dirname(__FILE__) + "/echo/#{protocol}"

data/lib/pipe2me/tunnel/echo/http

@@ -44,7 +44,7 @@ require "webrick/https"
 
 RACK_SERVER_OPTIONS = {
   :app => Application,
-  :BindAddress => "localhost",
+  # :BindAddress => "localhost",
   :Port => ENV["PORT"] || 8080,
   :server => "webrick",
   :Logger => WEBrick::BasicLog.new($stderr, WEBrick::BasicLog::WARN)

data/lib/pipe2me/tunnel.rb

@@ -73,7 +73,7 @@ module Pipe2me::Tunnel
     r = HTTP.get! "#{url}/check"
     puts r
   end
-  
+
   def update
     unless File.exists?(SSH_PRIVKEY)
       ssh_keygen

data/lib/pipe2me/version.rb

@@ -1,4 +1,4 @@
 module Pipe2me
-  VERSION = "0.2.8"
-  BANNER = "pipe2me command line client V#{Pipe2me::VERSION}; (c) The kink team, 2013, 2014."
+  VERSION = "0.2.9"
+  BANNER = "pipe2me command line client V#{Pipe2me::VERSION}; (c) The kinko team, 2013, 2014."
 end

data/test/env-test.sh

@@ -9,7 +9,7 @@ it_start_a_tunnel() {
   echo "== env is ============="
   cat env
   echo "== env done ============="
-  
+
   cat env | grep PIPE2ME_SERVER
   cat env | grep PIPE2ME_ID
   cat env | grep PIPE2ME_FQDN

data/test/monitrc-test.sh

@@ -17,7 +17,7 @@ it_creates_a_monitrc_file() {
 
   $pipe2me monitrc
   [ -e pipe2me.monitrc ]
-  
+
   # The file is 0600
   ls -l pipe2me.monitrc | grep -e "-rw-------"
 }

data/test/opensslkey-test.sh

@@ -7,7 +7,7 @@ describe "openssl tests"
 it_sets_up_openssl_certs() {
   fqdn=$($pipe2me setup --server $pipe2me_server --token $pipe2me_token)
   test -f pipe2me.openssl.priv
-  cat pipe2me.openssl.priv | grep "BEGIN RSA PRIVATE KEY"
+  cat pipe2me.openssl.priv | grep -E "BEGIN.*PRIVATE KEY"
 
   test -f pipe2me.openssl.cert
   cat pipe2me.openssl.cert | grep "BEGIN CERTIFICATE"

data/test/redirection-test.sh

@@ -1,5 +1,5 @@
 #!/usr/bin/env roundup
-describe 'a HTTP(s) connection to subdomain.$pipe2me_server redirects to subdomain.$pipe2me_server:port'  
+describe 'a HTTP(s) connection to subdomain.$pipe2me_server redirects to subdomain.$pipe2me_server:port'
 
 . $(dirname $1)/testhelper.inc
 

data/test/setup-test.sh

@@ -6,12 +6,14 @@ describe "tunnel setup"
 # setup a tunnel
 it_sets_up_tunnels() {
   fqdn=$($pipe2me setup --server $pipe2me_server --token $pipe2me_token --ports 8100,8101 --protocols http,https)
-  
+
+  test "$fqdn" != ""
+
   # pipe2me setup --server $pipe2me_server returns the fqdn of the subdomain and nothing else
-  test 1 -eq $(echo $fqdn | wc -l)  
+  test 1 -eq $(echo $fqdn | wc -l)
 
   # The subdomain is actually a subdomain.
-  echo $fqdn | grep \.pipe2\.dev
+  echo $fqdn | grep \.pipe2\.
 
   # Cannot setup a second tunnel in the same directory.
   ! $pipe2me setup --server $pipe2me_server --token $pipe2me_token

data/test/sshkey-test.sh

@@ -7,7 +7,7 @@ it_sets_up_ssh_identity() {
   fqdn=$($pipe2me setup --server $pipe2me_server --token $pipe2me_token)
   test -f pipe2me.id_rsa.pub
   test -f pipe2me.id_rsa
-  
+
   # identity must contain $fqdn
   cat pipe2me.id_rsa.pub | grep $fqdn
 }

data/test/testhelper.inc

@@ -1,6 +1,6 @@
 # The pipe2me binary to test
 pipe2me=$(cd $(dirname $1)/../bin && pwd)/pipe2me
-# pipe2me_server=http://test.pipe2.me:8080
+# pipe2me_server=http://test.pipe2.me
 
 # Load test scenario settings
 echo "Load $TEST_ENV test settings"

data/test/testhelper.release

@@ -1,2 +1,2 @@
-pipe2me_server=http://pipe2.dev:8080
+pipe2me_server=http://test.pipe2.me
 pipe2me_token=test@pipe2me

data/test/verify-test.sh

@@ -8,11 +8,11 @@ it_sets_up_tunnels_and_verifies() {
   fqdn=$($pipe2me setup --server $pipe2me_server --token short@pipe2me)
 
   # pipe2me setup --server $pipe2me_server returns the fqdn of the subdomain and nothing else
-  test 1 -eq $(echo $fqdn | wc -l)  
+  test 1 -eq $(echo $fqdn | wc -l)
 
   verified=$($pipe2me verify)
-  test "$fqdn" == "$verified"
-  
+  test "$fqdn" = "$verified"
+
   # sleep 4 seconds. The tunnel lives for 3 seconds
   sleep 4
   ! $pipe2me verify

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pipe2me-client
 version: !ruby/object:Gem::Version
-  version: 0.2.8
+  version: 0.2.9
 platform: ruby
 authors:
 - radiospiel
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-01-23 00:00:00.000000000 Z
+date: 2014-02-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -66,7 +66,7 @@ dependencies:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
-description: pipe2me command line client V0.2.8; (c) The kink team, 2013, 2014.
+description: pipe2me command line client V0.2.9; (c) The kinko team, 2013, 2014.
 email: contact@kinko.me
 executables:
 - pipe2me
@@ -77,6 +77,7 @@ files:
 - bin/pipe2me
 - bin/pipe2med
 - lib/pipe2me.rb
+- lib/pipe2me/bin/natpmpc
 - lib/pipe2me/cli-foreman.rb
 - lib/pipe2me/cli-monit.rb
 - lib/pipe2me/cli.rb
@@ -131,5 +132,5 @@ rubyforge_project:
 rubygems_version: 2.2.1
 signing_key: 
 specification_version: 4
-summary: pipe2me command line client V0.2.8; (c) The kink team, 2013, 2014.
+summary: pipe2me command line client V0.2.9; (c) The kinko team, 2013, 2014.
 test_files: []