libssh 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 7be9ae9a286b0ce4ae93064adb441780d087d3b8
+  data.tar.gz: 16f67e922fe6a5079b4f1548b815496b5151664b
+SHA512:
+  metadata.gz: fb7c02285aba9f22d8c5c60ed386d2b8e1e167032ebd044d804bbc747ceeb6f740d76643312cf3910c6a04c18385e160cda2f9efdfc48db32a0385edadcafcd6
+  data.tar.gz: af5ed17903b463d777f6b7eee70a2fc8347a66d16eab1cad402bb8ffd272c509d4b741547505226ff40324193726dd1a90764e51a60c0f4ba3ee841bc420b3c3

data/.clang-format

@@ -0,0 +1,3 @@
+Language: Cpp
+BasedOnStyle: Google
+Standard: C++11

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/.rubocop.yml

@@ -0,0 +1,30 @@
+inherit_from: .rubocop_todo.yml
+
+AllCops:
+  DisplayCopNames: true
+
+Metrics/AbcSize:
+  Enabled: false
+Metrics/CyclomaticComplexity:
+  Enabled: false
+Metrics/LineLength:
+  Enabled: false
+Metrics/MethodLength:
+  Enabled: false
+
+Style/GlobalVars:
+  Exclude:
+    - 'ext/libssh_ruby/extconf.rb'
+Style/HashSyntax:
+  Exclude:
+    - 'Rakefile'
+Style/IfUnlessModifier:
+  Enabled: false
+Style/Next:
+  Enabled: false
+Style/NumericLiterals:
+  Enabled: false
+Style/PercentLiteralDelimiters:
+  Enabled: false
+Style/SignalException:
+  EnforcedStyle: only_raise

data/.rubocop_todo.yml

@@ -0,0 +1,7 @@
+Style/Documentation:
+  Exclude:
+    - 'spec/**/*'
+    - 'test/**/*'
+    - 'lib/libssh.rb'
+    - 'lib/libssh/key.rb'
+    - 'lib/sshkit/backends/libssh.rb'

data/.travis.yml

@@ -0,0 +1,16 @@
+language: ruby
+sudo: required
+dist: trusty  # Require libssh >= 0.6.0
+addons:
+  apt:
+    packages:
+      - libssh-dev
+rvm:
+  - 2.2
+  - 2.3.0
+  - ruby-head
+before_install:
+  - gem install --no-rdoc --no-ri bundler
+matrix:
+  allow_failures:
+    - rvm: ruby-head

data/CHANGELOG.md

@@ -0,0 +1,2 @@
+## 0.1.0 (2016-01-24)
+- Initial release

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Kohei Suzuki
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,60 @@
+# LibSSH
+[![Build Status](https://travis-ci.org/eagletmt/libssh-ruby.svg?branch=master)](https://travis-ci.org/eagletmt/libssh-ruby)
+
+Ruby binding for [libssh](https://www.libssh.org/) .
+
+## Stability
+
+Under development
+
+## Requirement
+
+- libssh >= 0.6.0
+    - ed25519 keys support is available from [libssh 0.7.0](https://www.libssh.org/2015/05/11/libssh-0-7-0/).
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'libssh'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install libssh
+
+## Usage
+
+See [example/exec.rb](example/exec.rb) and [example/write.rb](example/write.rb).
+
+### With SSHKit
+
+See [example/sshkit.rb](example/sshkit.rb) .
+
+### With Capistrano
+
+```ruby
+require 'sshkit/backends/libssh'
+set :sshkit_backend, SSHKit::Backend::Libssh
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/eagletmt/libssh-ruby.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+

data/Rakefile

@@ -0,0 +1,10 @@
+require 'bundler/gem_tasks'
+require 'rake/extensiontask'
+
+task :build => :compile
+
+Rake::ExtensionTask.new('libssh_ruby') do |ext|
+  ext.lib_dir = 'lib/libssh'
+end
+
+task :default => [:clobber, :compile]

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'libssh'
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require 'irb'
+IRB.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/example/exec.rb

@@ -0,0 +1,52 @@
+#!/usr/bin/env ruby
+require 'libssh'
+
+GC.stress = true
+session = LibSSH::Session.new
+# session.log_verbosity = :debug
+session.host = 'barkhorn'
+session.parse_config
+session.add_identity('%d/id_ed25519')
+
+session.connect
+if session.server_known == LibSSH::SERVER_NOT_KNOWN
+  pubkey = session.get_publickey
+  print "Connect to #{pubkey.type_str} #{pubkey.sha1_hex} ? (y/N) "
+  $stdout.flush
+  yesno = $stdin.gets.chomp
+  if yesno != 'y'
+    raise
+  end
+  session.write_knownhost
+  puts 'Wrote known_hosts'
+elsif session.server_known != LibSSH::SERVER_KNOWN_OK
+  raise
+end
+
+session.userauth_none
+list = session.userauth_list
+unless list.include?(:publickey)
+  raise "publickey is unsupported: #{list}"
+end
+
+if session.userauth_publickey_auto != LibSSH::AUTH_SUCCESS
+  raise 'authorization failed'
+end
+
+bufsiz = 16384
+
+channel = LibSSH::Channel.new(session)
+channel.open_session do
+  channel.request_exec('ps auxf')
+  until channel.eof?
+    stdout_avail = channel.poll(timeout: 1)
+    if stdout_avail && stdout_avail > 0
+      $stdout.write(channel.read(bufsiz))
+    end
+
+    stderr_avail = channel.poll(stderr: true, timeout: 1)
+    if stderr_avail && stderr_avail > 0
+      $stderr.write(channel.read(bufsiz, stderr: true))
+    end
+  end
+end

data/example/sshkit.rb

@@ -0,0 +1,22 @@
+#!/usr/bin/env ruby
+require 'shellwords'
+require 'sshkit'
+require 'sshkit/backends/libssh'
+require 'sshkit/dsl'
+
+SSHKit.config.backend = SSHKit::Backend::Libssh
+SSHKit.config.backend.configure do |backend|
+  backend.pty = ENV.key?('REQUEST_PTY')
+end
+SSHKit.config.output = SSHKit::Formatter::Pretty.new($stdout)
+SSHKit.config.output_verbosity = :debug
+
+on %w[barkhorn rossmann], in: :parallel do |host|
+  date = capture(:date)
+  puts "#{host}: #{date}"
+end
+
+on %w[barkhorn rossmann], in: :parallel do
+  execute :ruby, '-e', Shellwords.escape('puts "stdout"; $stderr.puts "stderr"')
+  execute :false, raise_on_non_zero_exit: false
+end

data/example/write.rb

@@ -0,0 +1,54 @@
+#!/usr/bin/env ruby
+require 'libssh'
+
+GC.stress = true
+session = LibSSH::Session.new
+# session.log_verbosity = :debug
+session.host = 'barkhorn'
+session.parse_config
+session.add_identity('%d/id_ed25519')
+
+session.connect
+if session.server_known == LibSSH::SERVER_NOT_KNOWN
+  pubkey = session.get_publickey
+  print "Connect to #{pubkey.type_str} #{pubkey.sha1_hex} ? (y/N) "
+  $stdout.flush
+  yesno = $stdin.gets.chomp
+  if yesno != 'y'
+    raise
+  end
+  session.write_knownhost
+  puts 'Wrote known_hosts'
+elsif session.server_known != LibSSH::SERVER_KNOWN_OK
+  raise
+end
+
+session.userauth_none
+list = session.userauth_list
+unless list.include?(:publickey)
+  raise "publickey is unsupported: #{list}"
+end
+
+if session.userauth_publickey_auto != LibSSH::AUTH_SUCCESS
+  raise 'authorization failed'
+end
+
+bufsiz = 16384
+
+channel = LibSSH::Channel.new(session)
+channel.open_session do
+  channel.request_exec('sed -e s/foo/bar/')
+  channel.write("foobarbaz\n")
+  channel.send_eof
+  until channel.eof?
+    stdout_avail = channel.poll(timeout: 1)
+    if stdout_avail && stdout_avail > 0
+      $stdout.write(channel.read(bufsiz))
+    end
+
+    stderr_avail = channel.poll(stderr: true, timeout: 1)
+    if stderr_avail && stderr_avail > 0
+      $stderr.write(channel.read(bufsiz, stderr: true))
+    end
+  end
+end

data/ext/libssh_ruby/channel.c

@@ -0,0 +1,350 @@
+#include "libssh_ruby.h"
+#include <ruby/thread.h>
+
+#define RAISE_IF_ERROR(rc) \
+  if ((rc) == SSH_ERROR)   \
+  libssh_ruby_raise(ssh_channel_get_session(holder->channel))
+
+VALUE rb_cLibSSHChannel;
+
+static ID id_stderr, id_timeout;
+
+static void channel_mark(void *);
+static void channel_free(void *);
+static size_t channel_memsize(const void *);
+
+struct ChannelHolderStruct {
+  ssh_channel channel;
+  VALUE session;
+};
+typedef struct ChannelHolderStruct ChannelHolder;
+
+static const rb_data_type_t channel_type = {
+    "ssh_channel",
+    {channel_mark, channel_free, channel_memsize, {NULL, NULL}},
+    NULL,
+    NULL,
+    RUBY_TYPED_WB_PROTECTED | RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
+static VALUE channel_alloc(VALUE klass) {
+  ChannelHolder *holder = ALLOC(ChannelHolder);
+  holder->channel = NULL;
+  holder->session = Qundef;
+  return TypedData_Wrap_Struct(klass, &channel_type, holder);
+}
+
+static void channel_mark(void *arg) {
+  ChannelHolder *holder = arg;
+  if (holder->channel != NULL) {
+    rb_gc_mark(holder->session);
+  }
+}
+
+static void channel_free(void *arg) {
+  ChannelHolder *holder = arg;
+
+  if (holder->channel != NULL) {
+    /* XXX: ssh_channel is freed by ssh_session */
+    /* ssh_channel_free(holder->channel); */
+    holder->channel = NULL;
+  }
+
+  ruby_xfree(holder);
+}
+
+static size_t channel_memsize(RB_UNUSED_VAR(const void *arg)) {
+  return sizeof(ChannelHolder);
+}
+
+static VALUE m_initialize(VALUE self, VALUE session) {
+  ChannelHolder *holder;
+  SessionHolder *session_holder;
+
+  TypedData_Get_Struct(self, ChannelHolder, &channel_type, holder);
+  session_holder = libssh_ruby_session_holder(session);
+  holder->channel = ssh_channel_new(session_holder->session);
+  holder->session = session;
+
+  return self;
+}
+
+struct nogvl_channel_args {
+  ssh_channel channel;
+  int rc;
+};
+
+static void *nogvl_close(void *ptr) {
+  struct nogvl_channel_args *args = ptr;
+  args->rc = ssh_channel_close(args->channel);
+  return NULL;
+}
+
+static VALUE m_close(VALUE self) {
+  ChannelHolder *holder;
+  struct nogvl_channel_args args;
+
+  TypedData_Get_Struct(self, ChannelHolder, &channel_type, holder);
+  args.channel = holder->channel;
+  rb_thread_call_without_gvl(nogvl_close, &args, RUBY_UBF_IO, NULL);
+  RAISE_IF_ERROR(args.rc);
+
+  return Qnil;
+}
+
+static void *nogvl_open_session(void *ptr) {
+  struct nogvl_channel_args *args = ptr;
+  args->rc = ssh_channel_open_session(args->channel);
+  return NULL;
+}
+
+static VALUE m_open_session(VALUE self) {
+  ChannelHolder *holder;
+  struct nogvl_channel_args args;
+
+  TypedData_Get_Struct(self, ChannelHolder, &channel_type, holder);
+  args.channel = holder->channel;
+  rb_thread_call_without_gvl(nogvl_open_session, &args, RUBY_UBF_IO, NULL);
+  RAISE_IF_ERROR(args.rc);
+
+  if (rb_block_given_p()) {
+    return rb_ensure(rb_yield, Qnil, m_close, self);
+  } else {
+    return Qnil;
+  }
+}
+
+struct nogvl_request_exec_args {
+  ssh_channel channel;
+  char *cmd;
+  int rc;
+};
+
+static void *nogvl_request_exec(void *ptr) {
+  struct nogvl_request_exec_args *args = ptr;
+  args->rc = ssh_channel_request_exec(args->channel, args->cmd);
+
+  return NULL;
+}
+
+static VALUE m_request_exec(VALUE self, VALUE cmd) {
+  ChannelHolder *holder;
+  struct nogvl_request_exec_args args;
+
+  TypedData_Get_Struct(self, ChannelHolder, &channel_type, holder);
+  args.channel = holder->channel;
+  args.cmd = StringValueCStr(cmd);
+  rb_thread_call_without_gvl(nogvl_request_exec, &args, RUBY_UBF_IO, NULL);
+  RAISE_IF_ERROR(args.rc);
+  return Qnil;
+}
+
+static void *nogvl_request_pty(void *ptr) {
+  struct nogvl_channel_args *args = ptr;
+  args->rc = ssh_channel_request_pty(args->channel);
+  return NULL;
+}
+
+static VALUE m_request_pty(VALUE self) {
+  ChannelHolder *holder;
+  struct nogvl_channel_args args;
+
+  TypedData_Get_Struct(self, ChannelHolder, &channel_type, holder);
+  args.channel = holder->channel;
+  rb_thread_call_without_gvl(nogvl_request_pty, &args, RUBY_UBF_IO, NULL);
+  RAISE_IF_ERROR(args.rc);
+  return Qnil;
+}
+
+struct nogvl_read_args {
+  ssh_channel channel;
+  char *buf;
+  uint32_t count;
+  int is_stderr;
+  int timeout;
+  int rc;
+};
+
+static void *nogvl_read(void *ptr) {
+  struct nogvl_read_args *args = ptr;
+  args->rc = ssh_channel_read_timeout(args->channel, args->buf, args->count,
+                                      args->is_stderr, args->timeout);
+  return NULL;
+}
+
+static VALUE m_read(int argc, VALUE *argv, VALUE self) {
+  ChannelHolder *holder;
+  VALUE count, opts;
+  const ID table[] = {id_stderr, id_timeout};
+  VALUE kwvals[sizeof(table) / sizeof(*table)];
+  struct nogvl_read_args args;
+  VALUE ret;
+
+  TypedData_Get_Struct(self, ChannelHolder, &channel_type, holder);
+  rb_scan_args(argc, argv, "10:", &count, &opts);
+  Check_Type(count, T_FIXNUM);
+  rb_get_kwargs(opts, table, 0, 2, kwvals);
+  if (kwvals[0] == Qundef) {
+    args.is_stderr = 0;
+  } else {
+    args.is_stderr = RTEST(kwvals[0]) ? 1 : 0;
+  }
+  if (kwvals[1] == Qundef) {
+    args.timeout = -1;
+  } else {
+    Check_Type(kwvals[1], T_FIXNUM);
+    args.timeout = FIX2INT(kwvals[1]);
+  }
+  args.channel = holder->channel;
+  args.count = FIX2UINT(count);
+  args.buf = ALLOC_N(char, args.count);
+  rb_thread_call_without_gvl(nogvl_read, &args, RUBY_UBF_IO, NULL);
+
+  ret = rb_utf8_str_new(args.buf, args.rc);
+  ruby_xfree(args.buf);
+  return ret;
+}
+
+static VALUE m_eof_p(VALUE self) {
+  ChannelHolder *holder;
+
+  TypedData_Get_Struct(self, ChannelHolder, &channel_type, holder);
+  return ssh_channel_is_eof(holder->channel) ? Qtrue : Qfalse;
+}
+
+struct nogvl_poll_args {
+  ssh_channel channel;
+  int timeout;
+  int is_stderr;
+  int rc;
+};
+
+static void *nogvl_poll(void *ptr) {
+  struct nogvl_poll_args *args = ptr;
+  args->rc =
+      ssh_channel_poll_timeout(args->channel, args->timeout, args->is_stderr);
+  return NULL;
+}
+
+static VALUE m_poll(int argc, VALUE *argv, VALUE self) {
+  ChannelHolder *holder;
+  VALUE opts;
+  const ID table[] = {id_stderr, id_timeout};
+  VALUE kwvals[sizeof(table) / sizeof(*table)];
+  struct nogvl_poll_args args;
+
+  TypedData_Get_Struct(self, ChannelHolder, &channel_type, holder);
+  rb_scan_args(argc, argv, "00:", &opts);
+  rb_get_kwargs(opts, table, 0, 2, kwvals);
+  if (kwvals[0] == Qundef) {
+    args.is_stderr = 0;
+  } else {
+    args.is_stderr = RTEST(kwvals[0]) ? 1 : 0;
+  }
+  if (kwvals[1] == Qundef) {
+    args.timeout = -1;
+  } else {
+    Check_Type(kwvals[1], T_FIXNUM);
+    args.timeout = FIX2INT(kwvals[1]);
+  }
+
+  args.channel = holder->channel;
+  rb_thread_call_without_gvl(nogvl_poll, &args, RUBY_UBF_IO, NULL);
+  RAISE_IF_ERROR(args.rc);
+
+  if (args.rc == SSH_EOF) {
+    return Qnil;
+  } else {
+    return INT2FIX(args.rc);
+  }
+}
+
+static void *nogvl_get_exit_status(void *ptr) {
+  struct nogvl_channel_args *args = ptr;
+  args->rc = ssh_channel_get_exit_status(args->channel);
+  return NULL;
+}
+
+static VALUE m_get_exit_status(VALUE self) {
+  ChannelHolder *holder;
+  struct nogvl_channel_args args;
+
+  TypedData_Get_Struct(self, ChannelHolder, &channel_type, holder);
+  args.channel = holder->channel;
+  rb_thread_call_without_gvl(nogvl_get_exit_status, &args, RUBY_UBF_IO, NULL);
+  if (args.rc == -1) {
+    return Qnil;
+  } else {
+    return INT2FIX(args.rc);
+  }
+}
+
+struct nogvl_write_args {
+  ssh_channel channel;
+  const void *data;
+  uint32_t len;
+  int rc;
+};
+
+static void *nogvl_write(void *ptr) {
+  struct nogvl_write_args *args = ptr;
+  args->rc = ssh_channel_write(args->channel, args->data, args->len);
+  return NULL;
+}
+
+static VALUE m_write(VALUE self, VALUE data) {
+  ChannelHolder *holder;
+  struct nogvl_write_args args;
+
+  Check_Type(data, T_STRING);
+  TypedData_Get_Struct(self, ChannelHolder, &channel_type, holder);
+  args.channel = holder->channel;
+  args.data = RSTRING_PTR(data);
+  args.len = RSTRING_LEN(data);
+  rb_thread_call_without_gvl(nogvl_write, &args, RUBY_UBF_IO, NULL);
+  RAISE_IF_ERROR(args.rc);
+  return INT2FIX(args.rc);
+}
+
+static void *nogvl_send_eof(void *ptr) {
+  struct nogvl_channel_args *args = ptr;
+  args->rc = ssh_channel_send_eof(args->channel);
+  return NULL;
+}
+
+static VALUE m_send_eof(VALUE self) {
+  ChannelHolder *holder;
+  struct nogvl_channel_args args;
+
+  TypedData_Get_Struct(self, ChannelHolder, &channel_type, holder);
+  args.channel = holder->channel;
+  rb_thread_call_without_gvl(nogvl_send_eof, &args, RUBY_UBF_IO, NULL);
+  RAISE_IF_ERROR(args.rc);
+  return Qnil;
+}
+
+void Init_libssh_channel(void) {
+  rb_cLibSSHChannel = rb_define_class_under(rb_mLibSSH, "Channel", rb_cObject);
+  rb_define_alloc_func(rb_cLibSSHChannel, channel_alloc);
+
+  rb_define_method(rb_cLibSSHChannel, "initialize",
+                   RUBY_METHOD_FUNC(m_initialize), 1);
+  rb_define_method(rb_cLibSSHChannel, "open_session",
+                   RUBY_METHOD_FUNC(m_open_session), 0);
+  rb_define_method(rb_cLibSSHChannel, "close", RUBY_METHOD_FUNC(m_close), 0);
+  rb_define_method(rb_cLibSSHChannel, "request_exec",
+                   RUBY_METHOD_FUNC(m_request_exec), 1);
+  rb_define_method(rb_cLibSSHChannel, "request_pty",
+                   RUBY_METHOD_FUNC(m_request_pty), 0);
+  rb_define_method(rb_cLibSSHChannel, "read", RUBY_METHOD_FUNC(m_read), -1);
+  rb_define_method(rb_cLibSSHChannel, "poll", RUBY_METHOD_FUNC(m_poll), -1);
+  rb_define_method(rb_cLibSSHChannel, "eof?", RUBY_METHOD_FUNC(m_eof_p), 0);
+  rb_define_method(rb_cLibSSHChannel, "get_exit_status",
+                   RUBY_METHOD_FUNC(m_get_exit_status), 0);
+  rb_define_method(rb_cLibSSHChannel, "write", RUBY_METHOD_FUNC(m_write), 1);
+  rb_define_method(rb_cLibSSHChannel, "send_eof", RUBY_METHOD_FUNC(m_send_eof),
+                   0);
+
+  id_stderr = rb_intern("stderr");
+  id_timeout = rb_intern("timeout");
+}