simplessh-rb 1.0.0

data/ext/simplessh/extconf.rb

@@ -0,0 +1,8 @@
+require 'mkmf'
+
+# TODO: this check's not working
+abort "libssh2 is missing" unless have_library "ssh2", "libssh2_session_handshake", "libssh2.h"
+
+create_makefile "simplessh/simplessh"
+puts "running the Makefile"
+puts `cd ext/simplessh; make install`

data/ext/simplessh/simplessh.c

@@ -0,0 +1,360 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <arpa/inet.h>
+#include <sys/socket.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <netdb.h>
+
+#include <libssh2.h>
+#include <simplessh.h>
+
+#define returnError(either, err) { \
+  struct simplessh_either *tmp = (either); \
+  tmp->side    = LEFT; \
+  tmp->u.error = (err); \
+  return tmp; \
+}
+
+inline int min(int a, int b) {
+  return a < b ? a : b;
+}
+
+static int waitsocket(int socket_fd, LIBSSH2_SESSION *session) {
+  struct timeval timeout;
+  int rc;
+  fd_set fd;
+  fd_set *writefd = NULL;
+  fd_set *readfd = NULL;
+  int dir;
+
+  timeout.tv_sec = 10;
+  timeout.tv_usec = 0;
+
+  FD_ZERO(&fd);
+  FD_SET(socket_fd, &fd);
+
+  /* now make sure we wait in the correct direction */
+  dir = libssh2_session_block_directions(session);
+
+  if(dir & LIBSSH2_SESSION_BLOCK_INBOUND) readfd = &fd;
+  if(dir & LIBSSH2_SESSION_BLOCK_OUTBOUND) writefd = &fd;
+
+  rc = select(socket_fd + 1, readfd, writefd, NULL, &timeout);
+  return rc;
+}
+
+inline int get_socket(const char *hostname, uint16_t port) {
+  struct addrinfo hints;
+  memset(&hints, 0, sizeof(struct addrinfo));
+  hints.ai_family   = AF_UNSPEC;
+  hints.ai_socktype = SOCK_STREAM;
+  hints.ai_flags    = AI_NUMERICSERV;
+  hints.ai_protocol = 0;
+
+  struct addrinfo *res = NULL;
+  char service[6]; // enough to contain a port number
+  sprintf(service, "%i", port);
+  int rc = getaddrinfo(hostname, service, &hints, &res);
+  if(rc != 0) {
+    if(res) freeaddrinfo(res);
+    return -1;
+  }
+
+  struct addrinfo *current;
+  int sock;
+  for(current = res; current != NULL; current = current->ai_next) {
+    sock = socket(res->ai_family, res->ai_socktype, res->ai_protocol);
+    if(sock == -1) continue;
+
+    if(connect(sock, res->ai_addr, res->ai_addrlen) != -1) {
+      freeaddrinfo(res);
+      return sock;
+    }
+
+    close(sock);
+  }
+
+  freeaddrinfo(res);
+  return -1;
+}
+
+struct simplessh_either *simplessh_open_session(
+    const char *hostname,
+    uint16_t port,
+    const char *knownhosts_path) {
+  struct simplessh_either *either;
+  struct simplessh_session *session;
+  LIBSSH2_KNOWNHOSTS *knownhosts;
+  char *hostkey;
+  int hostkey_type, rc;
+  size_t hostkey_len;
+
+  #define returnLocalErrorSP(err) { \
+    simplessh_close_session(session); \
+    returnError(either, (err)); \
+  }
+
+  // Empty simplessh_session
+  session = malloc(sizeof(struct simplessh_session));
+  session->lsession = NULL;
+
+  // Empty simplessh_either
+  either = malloc(sizeof(struct simplessh_either));
+  either->side    = RIGHT;
+  either->u.value = session;
+
+  // Connection initialisation
+  session->sock = get_socket(hostname, port);
+  if(session->sock == -1) returnError(either, CONNECT);
+
+  session->lsession = libssh2_session_init();
+  if(!session) returnLocalErrorSP(INIT);
+
+  libssh2_session_set_blocking(session->lsession, 0);
+
+  while((rc = libssh2_session_handshake(session->lsession, session->sock)) == LIBSSH2_ERROR_EAGAIN);
+  if(rc) returnLocalErrorSP(HANDSHAKE);
+
+  // Check host in the knownhosts
+  knownhosts = libssh2_knownhost_init(session->lsession);
+  if(!knownhosts) returnLocalErrorSP(KNOWNHOSTS_INIT);
+
+  libssh2_knownhost_readfile(knownhosts, knownhosts_path, LIBSSH2_KNOWNHOST_FILE_OPENSSH);
+
+  hostkey = (char*)libssh2_session_hostkey(session->lsession, &hostkey_len, &hostkey_type);
+  if(hostkey) {
+    struct libssh2_knownhost *host;
+    int check = libssh2_knownhost_check(knownhosts, hostname, hostkey, hostkey_len,
+                                        LIBSSH2_KNOWNHOST_TYPE_PLAIN | LIBSSH2_KNOWNHOST_KEYENC_RAW,
+                                        &host);
+
+    if(check != 0) returnLocalErrorSP(KNOWNHOSTS_CHECK);
+    libssh2_knownhost_free(knownhosts);
+  } else {
+    libssh2_knownhost_free(knownhosts);
+    returnLocalErrorSP(KNOWNHOSTS_HOSTKEY);
+  }
+  // End of the knownhosts checking
+
+  return either;
+}
+
+struct simplessh_either *simplessh_authenticate_password(
+    struct simplessh_session *session,
+    const char *username,
+    const char *password) {
+  int rc;
+  struct simplessh_either *either = malloc(sizeof(struct simplessh_either));
+
+  while((rc = libssh2_userauth_password(session->lsession, username, password)) == LIBSSH2_ERROR_EAGAIN);
+  if(rc) {
+    either->side    = LEFT;
+    either->u.error = AUTHENTICATION;
+  } else {
+    either->side    = RIGHT;
+    either->u.value = session;
+  }
+
+  return either;
+}
+
+struct simplessh_either *simplessh_authenticate_key(
+    struct simplessh_session *session,
+    const char *username,
+    const char *public_key_path,
+    const char *private_key_path,
+    const char *passphrase) {
+  int rc;
+  struct simplessh_either *either = malloc(sizeof(struct simplessh_either));
+
+  while((rc = libssh2_userauth_publickey_fromfile(session->lsession, username, public_key_path, private_key_path, passphrase)) == LIBSSH2_ERROR_EAGAIN);
+  if(rc) {
+    either->side    = LEFT;
+    either->u.error = AUTHENTICATION;
+  } else {
+    either->side    = RIGHT;
+    either->u.value = session;
+  }
+
+  return either;
+}
+
+struct simplessh_either *simplessh_exec_command(
+    struct simplessh_session *session,
+    const char *command) {
+  struct simplessh_either *either;
+  struct simplessh_result *result;
+  LIBSSH2_CHANNEL *channel;
+  int rc, rc2;
+  char *out = NULL;
+  char *err = NULL;
+
+  // Empty result
+  result = malloc(sizeof(struct simplessh_result));
+  result->out = NULL;
+  result->err = NULL;
+  result->exit_code   = 127;
+  result->exit_signal = NULL;
+
+  // Empty either
+  either = malloc(sizeof(struct simplessh_either));
+  either->side    = RIGHT;
+  either->u.value = result;
+
+  #define returnLocalErrorC(error) { \
+    if(out != NULL) free(out); \
+    if(err != NULL) free(err); \
+    free(result); \
+    returnError(either, (error)); \
+  }
+
+  while((channel = libssh2_channel_open_session(session->lsession)) == NULL) {
+    if(libssh2_session_last_errno(session->lsession) == LIBSSH2_ERROR_EAGAIN)
+      waitsocket(session->sock, session->lsession);
+    else
+      returnLocalErrorC(CHANNEL_OPEN);
+  }
+
+  // Send the command
+  while((rc = libssh2_channel_exec(channel, command)) != 0) {
+    if(rc == LIBSSH2_ERROR_EAGAIN) {
+      waitsocket(session->sock, session->lsession);
+    } else {
+      returnLocalErrorC(CHANNEL_EXEC);
+    }
+  }
+
+  // Read result
+  int out_size = 128, out_position = 0, err_size = 128, err_position = 0;
+  out = malloc(out_size);
+  err = malloc(err_size);
+
+  for(;;) {
+    rc  = libssh2_channel_read(channel,
+                               out + out_position,
+                               out_size - out_position - 1);
+    rc2 = libssh2_channel_read_stderr(channel,
+                                      err + err_position,
+                                      err_size - err_position - 1);
+
+    if(rc == 0 && rc2 == 0) {
+      break;
+    } else if(rc == LIBSSH2_ERROR_EAGAIN && rc2 == LIBSSH2_ERROR_EAGAIN) {
+      waitsocket(session->sock, session->lsession);
+    } else if((rc < 0  && rc  != LIBSSH2_ERROR_EAGAIN) ||
+              (rc2 < 0 && rc2 != LIBSSH2_ERROR_EAGAIN)) {
+      returnLocalErrorC(READ);
+    } else {
+      if(rc > 0) {
+        out_position += rc;
+        if(out_size - out_position < 1024) {
+          out_size = min(out_size * 2, out_size + 65536);
+          out = realloc(out, out_size);
+        }
+      }
+      if(rc2 > 0) {
+        err_position += rc2;
+        if(err_size - err_position < 1024) {
+          err_size = min(err_size * 2, err_size + 65536);
+          err = realloc(err, err_size);
+        }
+      }
+    }
+  }
+  out[out_position] = '\0';
+  out = realloc(out, out_position + 1);
+  result->out = out;
+
+  err[err_position] = '\0';
+  err = realloc(err, err_position + 1);
+  result->err = err;
+
+  while((rc = libssh2_channel_close(channel)) == LIBSSH2_ERROR_EAGAIN)
+    waitsocket(session->sock, session->lsession);
+
+  if(rc == 0) {
+    result->exit_code = libssh2_channel_get_exit_status(channel);
+    libssh2_channel_get_exit_signal(channel,
+                                    &result->exit_signal, NULL,
+                                    NULL, NULL,
+                                    NULL, NULL);
+  }
+
+
+  libssh2_channel_free(channel);
+
+  return either;
+}
+
+struct simplessh_either *simplessh_send_file(
+    struct simplessh_session *session,
+    int mode,
+    const char *local_path,
+    const char *destination_path) {
+  struct simplessh_either *either;
+  LIBSSH2_CHANNEL *channel = NULL;
+  int rc;
+  int *transferred = malloc(sizeof(int));
+  *transferred = 0;
+
+  // Empty either
+  either = malloc(sizeof(struct simplessh_either));
+  either->side    = RIGHT;
+  either->u.value = transferred;
+
+  #define returnLocalErrorS(err) { \
+    if(f) fclose(f); \
+    if(channel) libssh2_channel_free(channel); \
+    either->side    = LEFT; \
+    either->u.error = err; \
+    return either; \
+  }
+
+  FILE *f = fopen(local_path, "r");
+  if(f == NULL) returnLocalErrorS(FILEOPEN);
+
+  size_t size;
+  struct stat *fileinfo = malloc(sizeof(struct stat));
+  stat(local_path, fileinfo);
+  size = fileinfo->st_size;
+  free(fileinfo);
+
+  while((channel = libssh2_scp_send(session->lsession, destination_path, mode & 0777, size)) == NULL) {
+    if(libssh2_session_last_errno(session->lsession) == LIBSSH2_ERROR_EAGAIN) {
+      waitsocket(session->sock, session->lsession);
+    } else {
+      returnLocalErrorS(CHANNEL_OPEN);
+    }
+  }
+
+  char buf[1024];
+  char *current;
+  while(!feof(f)) {
+    size_t n = fread(buf, 1, sizeof(buf), f);
+    current = buf;
+    // Ready to write n bytes to the channel
+    while(n > 0) {
+      rc = libssh2_channel_write(channel, current, n);
+      if(rc < 0) returnLocalErrorS(WRITE);
+      n -= rc;
+      current += rc;
+      *transferred += rc;
+    }
+  }
+
+  libssh2_channel_send_eof(channel);
+  libssh2_channel_wait_eof(channel);
+  libssh2_channel_wait_closed(channel);
+  libssh2_channel_free(channel);
+  fclose(f);
+  return either;
+}
+
+void simplessh_close_session(struct simplessh_session *session) {
+  libssh2_session_disconnect(session->lsession, "simplessh_close_session");
+  libssh2_session_free(session->lsession);
+  close(session->sock);
+  free(session);
+  libssh2_exit();
+}

data/ext/simplessh/simplessh.h

@@ -0,0 +1,37 @@
+#ifndef __simplessh_header
+#define __simplessh_header 1
+
+#include <stdint.h>
+
+#include <simplessh_types.h>
+
+struct simplessh_either *simplessh_open_session(
+  const char*,
+  uint16_t,
+  const char*);
+
+struct simplessh_either *simplessh_authenticate_password(
+  struct simplessh_session*,
+  const char *username,
+  const char *password);
+
+struct simplessh_either *simplessh_authenticate_key(
+  struct simplessh_session*,
+  const char*,
+  const char*,
+  const char*,
+  const char*);
+
+struct simplessh_either *simplessh_exec_command(
+  struct simplessh_session*,
+  const char *);
+
+struct simplessh_either *simplessh_send_file(
+  struct simplessh_session*,
+  int,
+  const char*,
+  const char*);
+
+void simplessh_close_session(struct simplessh_session*);
+
+#endif

data/ext/simplessh/simplessh_types.c

@@ -0,0 +1,68 @@
+#include <stdlib.h>
+#include <stdio.h>
+
+#include <simplessh_types.h>
+
+int simplessh_is_left(struct simplessh_either *either) {
+  return either->side == LEFT;
+}
+
+int simplessh_get_error(struct simplessh_either *either) {
+  if(either->side != LEFT) {
+    fprintf(stderr, "Error: simplessh_get_error: trying to get the error of a Right element\n");
+    abort();
+  }
+  return either->u.error;
+}
+
+void *simplessh_get_value(struct simplessh_either *either) {
+  if(either->side != RIGHT) {
+    fprintf(stderr, "Error: simplessh_get_value: trying to get the value of a Left element\n");
+    abort();
+  } else if(either->u.value == NULL) {
+    fprintf(stderr, "Error: simplessh_get_value: element is Right but value has not been set\n");
+    abort();
+  }
+  return either->u.value;
+}
+
+void simplessh_free_either_result(struct simplessh_either *either) {
+  struct simplessh_result *result = either->u.value;
+  if(either->side == RIGHT && result != NULL) {
+    if(result->out != NULL) free(result->out);
+    if(result->err != NULL) free(result->err);
+    if(result->exit_signal != NULL) free(result->exit_signal);
+    free(result);
+  }
+  free(either);
+}
+
+void simplessh_free_either_count(struct simplessh_either *either) {
+  if(either->side == RIGHT && either->u.value != NULL) free(either->u.value);
+  free(either);
+}
+
+char *simplessh_get_out(struct simplessh_result *result) {
+  return result->out;
+}
+
+char *simplessh_get_err(struct simplessh_result *result) {
+  return result->err;
+}
+
+int simplessh_get_exit_code(struct simplessh_result *result) {
+  return result->exit_code;
+}
+
+char *simplessh_get_exit_signal(struct simplessh_result *result) {
+  return result->exit_signal;
+}
+
+int simplessh_get_count(int *ptr) {
+  return *ptr;
+}
+
+// Just to make FFI shut up
+void simplessh_free(void *ptr) {
+  free(ptr);
+}

data/ext/simplessh/simplessh_types.h

@@ -0,0 +1,62 @@
+#ifndef __SIMPLESSH_TYPES_HEADER
+#define __SIMPLESSH_TYPES_HEADER 1
+
+#include <libssh2.h>
+
+enum simplessh_left_right {
+  LEFT,
+  RIGHT
+};
+
+enum simplessh_error {
+  CONNECT            = 1,
+  INIT               = 2,
+  HANDSHAKE          = 3,
+  KNOWNHOSTS_INIT    = 4,
+  KNOWNHOSTS_HOSTKEY = 5,
+  KNOWNHOSTS_CHECK   = 6,
+  AUTHENTICATION     = 7,
+  CHANNEL_OPEN       = 8,
+  CHANNEL_EXEC       = 9,
+  READ               = 10,
+  FILEOPEN           = 11,
+  WRITE              = 12
+};
+
+struct simplessh_either {
+  enum simplessh_left_right side;
+  union {
+    enum simplessh_error error;
+    void *value;
+  } u;
+};
+
+struct simplessh_session {
+  LIBSSH2_SESSION *lsession;
+  int sock;
+};
+
+struct simplessh_result {
+  char *out;
+  char *err;
+  int exit_code;
+  char *exit_signal;
+};
+
+int simplessh_is_left(struct simplessh_either*);
+int simplessh_get_error(struct simplessh_either*);
+void *simplessh_get_value(struct simplessh_either*);
+
+void simplessh_free_either_result(struct simplessh_either*);
+void simplessh_free_either_count(struct simplessh_either*);
+
+char *simplessh_get_out(struct simplessh_result*);
+char *simplessh_get_err(struct simplessh_result*);
+int simplessh_get_exit_code(struct simplessh_result*);
+char *simplessh_get_exit_signal(struct simplessh_result*);
+
+int simplessh_get_count(int*);
+
+void simplessh_free(void*);
+
+#endif

data/lib/simplessh/either.rb

@@ -0,0 +1,81 @@
+module SimpleSSH
+  class Either
+    attr_reader :val
+
+    def self.return(val)
+      Right.new val
+    end
+
+    def initialize(val)
+      @val = val
+    end
+
+    def self.from_pointer(pointer, &block)
+      if SimpleSSH::Foreign.is_left(pointer) == 0
+        value_pointer = SimpleSSH::Foreign.value pointer
+        value = block.call(value_pointer)
+        Right.new value
+      else
+        error_code = SimpleSSH::Foreign.error(pointer)
+        Left.from_code(error_code)
+      end
+    end
+
+    def self.from_pointer!(pointer, &block)
+      result = self.from_pointer(pointer, &block)
+      SimpleSSH::Foreign.free pointer
+      result
+    end
+
+    def flat_map(&block)
+      raise NotImplementedError
+    end
+
+    def left?
+      raise NotImplementedError
+    end
+
+    def right?
+      not left?
+    end
+
+    class Left < Either
+      def self.from_code(code)
+        err = case code
+                when 1 then :connect
+                when 2 then :libssh2_initialisation
+                when 3 then :handshake
+                when 4 then :known_hosts_initialisation
+                when 5 then :known_hosts_hostkey
+                when 6 then :known_hosts_check
+                when 7 then :authentication
+                when 8 then :channel_open
+                when 9 then :channel_execution
+                when 10 then :read
+                when 11 then :file_open
+                when 12 then :write
+                else :unknown_error
+              end
+        self.new err
+      end
+
+      def flat_map
+        self
+      end
+
+      def left?
+        true
+      end
+    end
+
+    class Right < Either
+      def flat_map(&block)
+        block.call val
+      end
+
+      def left?
+        false
+      end
+    end
+  end
+end

data/lib/simplessh/foreign.rb

@@ -0,0 +1,30 @@
+require 'ffi'
+
+module SimpleSSH
+  module Foreign
+    extend FFI::Library
+    extension = FFI::Platform.mac? ? "bundle" : "so"
+    ffi_lib File.join(File.dirname(__FILE__), "..", "..", "ext", "simplessh", "simplessh.#{extension}")
+    ffi_convention :stdcall
+
+    attach_function :open_session, :simplessh_open_session, [:string, :int, :string], :pointer
+    attach_function :authenticate_with_password, :simplessh_authenticate_password, [:pointer, :string, :string], :pointer
+    attach_function :authenticate_with_key, :simplessh_authenticate_key, [:pointer, :string, :string, :string, :string], :pointer
+    attach_function :exec_command, :simplessh_exec_command, [:pointer, :string], :pointer
+    attach_function :send_file, :simplessh_send_file, [:pointer, :int, :string, :string], :pointer
+    attach_function :close_session, :simplessh_close_session, [:pointer], :void
+
+    attach_function :is_left, :simplessh_is_left, [:pointer], :int
+    attach_function :error, :simplessh_get_error, [:pointer], :int
+    attach_function :value, :simplessh_get_value, [:pointer], :pointer
+    attach_function :free_either_result, :simplessh_free_either_result, [:pointer], :void
+    attach_function :free_either_count, :simplessh_free_either_count, [:pointer], :void
+    attach_function :out, :simplessh_get_out, [:pointer], :string
+    attach_function :err, :simplessh_get_err, [:pointer], :string
+    attach_function :exit_code, :simplessh_get_exit_code, [:pointer], :int
+    attach_function :exit_signal, :simplessh_get_exit_signal, [:pointer], :string
+    attach_function :count, :simplessh_get_count, [:pointer], :int
+
+    attach_function :free, :simplessh_free, [:pointer], :void
+  end
+end

data/lib/simplessh/helpers.rb

@@ -0,0 +1,7 @@
+module SimpleSSH
+  module Helpers
+    def file_mode(path)
+      File.stat(path).mode % 01000
+    end
+  end
+end

data/lib/simplessh/result.rb

@@ -0,0 +1,36 @@
+module SimpleSSH
+  class Result
+    # The pointer is freed after this call in SimpleSSH::Session#exec_command
+    def self.from_pointer(pointer)
+      exit_code   = SimpleSSH::Foreign.exit_code   pointer
+      exit_signal = SimpleSSH::Foreign.exit_signal pointer
+      out         = SimpleSSH::Foreign.out         pointer
+      err         = SimpleSSH::Foreign.err         pointer
+      self.new(exit_code, exit_signal, out, err)
+    end
+
+    def initialize(code, sig, out, err)
+      @code, @sig, @out, @err = code, sig, out, err
+    end
+
+    def success?
+      not signal? && @exit_code == 0
+    end
+
+    def signal?
+      not @sig.nil?
+    end
+
+    def stdout
+      @out
+    end
+
+    def stderr
+      @err
+    end
+
+    def exit
+      signal? ? @sig : @code
+    end
+  end
+end

data/lib/simplessh/session.rb

@@ -0,0 +1,71 @@
+module SimpleSSH
+  class Session
+    include SimpleSSH::Helpers
+
+    def self.from_pointer(pointer)
+      self.new(pointer)
+    end
+
+    def initialize(pointer)
+      @session_pointer = pointer
+    end
+
+    def authenticate_with_password(username, password)
+      either_pointer = SimpleSSH::Foreign.authenticate_with_password(@session_pointer, username, password)
+      SimpleSSH::Either.from_pointer!(either_pointer) do |session_pointer|
+        SimpleSSH::Session.from_pointer(session_pointer)
+      end
+    end
+
+    def authenticate_with_key(username, public_key, private_key, passphrase)
+      either_pointer = SimpleSSH::Foreign.authenticate_with_key(@session_pointer, username, public_key, private_key, passphrase)
+      SimpleSSH::Either.from_pointer!(either_pointer) do |session_pointer|
+        SimpleSSH::Session.from_pointer(session_pointer)
+      end
+    end
+
+    def exec_command(cmd)
+      either_pointer = SimpleSSH::Foreign.exec_command(@session_pointer, cmd)
+      either_result = SimpleSSH::Either.from_pointer(either_pointer) do |result_pointer|
+        SimpleSSH::Result.from_pointer(result_pointer)
+      end
+      SimpleSSH::Foreign.free_either_result(either_pointer)
+      either_result
+    end
+
+    def send_file(mode, source, target)
+      either_pointer = SimpleSSH::Foreign.send_file(@session_pointer, mode, source, target)
+      either_count = SimpleSSH::Either.from_pointer(either_pointer) do |count_pointer|
+        SimpleSSH::Foreign.count(count_pointer)
+      end
+      SimpleSSH::Foreign.free_either_count(either_pointer)
+      either_count
+    end
+
+    def send_directory(source, target)
+      exec_command("mkdir -m #{file_mode(source).to_s(8)} #{target}").flat_map do |dir_creation_res|
+        if dir_creation_res.success?
+          Dir.open(source).reject { |p| p == '.' || p == '..' }.reduce(SimpleSSH::Either.return(nil)) do |prev, name|
+            local_path  = File.join(source, name)
+            remote_path = "#{target}/#{name}"
+            if File.file? local_path
+              prev.flat_map { |_| send_file(file_mode(local_path), local_path, remote_path) }
+            else
+              prev.flat_map { |_| send_directory(local_path, remote_path) }
+            end
+          end
+        else
+          SimpleSSH::Either::Left.new :could_not_create_directory
+        end
+      end.flat_map { |_| SimpleSSH::Either.return nil }
+    end
+
+    def close
+      SimpleSSH::Foreign.close_session @session_pointer
+    end
+
+    def finalize
+      close
+    end
+  end
+end

data/lib/simplessh.rb

@@ -0,0 +1,50 @@
+require 'simplessh/helpers'
+require 'simplessh/foreign'
+require 'simplessh/either'
+require 'simplessh/session'
+require 'simplessh/result'
+
+module SimpleSSH
+  def self.open_session(hostname, port, known_hosts)
+    either_pointer = SimpleSSH::Foreign.open_session(hostname, port, known_hosts)
+
+    SimpleSSH::Either.from_pointer!(either_pointer) do |sess_pointer|
+      SimpleSSH::Session.from_pointer(sess_pointer)
+    end
+  end
+
+  def self.with_session_password(hostname, username, password, opts = {}, &block)
+    port        = opts[:port] || 22
+    known_hosts = opts[:known_hosts] || File.join(Dir.home, ".ssh", "known_hosts")
+
+    sess = self.open_session(hostname, port, known_hosts).flat_map do |s|
+      s.authenticate_with_password(username, password)
+    end
+
+    res = sess.flat_map do |s|
+      block.call s
+    end
+
+    sess.flat_map { |s| s.close }
+    res
+  end
+
+  def self.with_session_key(hostname, username, opts = {}, &block)
+    port        = opts[:port] || 22
+    passphrase  = opts[:passphrase]  || ""
+    public_key  = opts[:public_key]  || File.join(Dir.home, ".ssh", "id_rsa.pub")
+    private_key = opts[:private_key] || File.join(Dir.home, ".ssh", "id_rsa")
+    known_hosts = opts[:known_hosts] || File.join(Dir.home, ".ssh", "known_hosts")
+
+    sess = self.open_session(hostname, port, known_hosts).flat_map do |s|
+      s.authenticate_with_key(username, public_key, private_key, passphrase)
+    end
+
+    res = sess.flat_map do |s|
+      block.call s
+    end
+
+    sess.flat_map { |s| s.close }
+    res
+  end
+end

metadata

@@ -0,0 +1,73 @@
+--- !ruby/object:Gem::Specification
+name: simplessh-rb
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Tom Feron
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-11-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ffi
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Simple wrapper around libssh2 allowing to send commands and files, supports
+  stdout/stderr, exit codes and signals.
+email: tho.feron@gmail.com
+executables: []
+extensions:
+- ext/simplessh/extconf.rb
+extra_rdoc_files: []
+files:
+- lib/simplessh.rb
+- lib/simplessh/foreign.rb
+- lib/simplessh/session.rb
+- lib/simplessh/either.rb
+- lib/simplessh/result.rb
+- lib/simplessh/helpers.rb
+- ext/simplessh/simplessh.c
+- ext/simplessh/simplessh.h
+- ext/simplessh/simplessh_types.c
+- ext/simplessh/simplessh_types.h
+- ext/simplessh/extconf.rb
+homepage: https://github.com/thoferon/simplessh-rb
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Ruby version of SimpleSSH
+test_files: []