There's no documentation for this item.

Source Code

# File net/ssh/userauth/services.rb, line 21
def register_services( container )
  container.namespace_define :userauth do |b|

    b.require 'net/ssh/userauth/methods/services', "#{self}::Methods"

    b.agent_socket_factory do
      if File::ALT_SEPARATOR
        require 'net/ssh/userauth/pageant'
        Pageant::Socket
      else
        require 'socket'
        defined?( UNIXSocket ) ? UNIXSocket : nil
      end
    end

    b.default_agent_socket_name { ENV['SSH_AUTH_SOCK'] }

    b.default_agent_version { 2 }

    b.agent( :model => :prototype ) do |c,p|
      socket_factory = c[:agent_socket_factory]
      socket_name = c[:default_agent_socket_name]

      if (File::ALT_SEPARATOR || socket_name) && socket_factory
        require 'net/ssh/userauth/agent'
        require 'net/ssh/transport/services'

        agent = Agent.new
        agent.socket_factory = socket_factory
        agent.socket_name = socket_name
        agent.version = c[:default_agent_version]
        agent.buffers = c[:transport][:buffers]
        agent.keys = c[:transport][:keys]

        begin
          agent.connect!
        rescue Net::SSH::Exception
          # if there was an error connecting to the agent, swallow the
          # error and move on, without the agent
          agent = nil
        end
      end

      agent
    end

    b.agent_factory do |c,p|
      factory = Object.new
      klass = class << factory; self; end
      klass.send( :define_method, :open ) { c[:agent] }
      factory
    end

    b.default_user_key_locations do
      [ "#{ENV['HOME']}/.ssh/id_dsa",
        "#{ENV['HOME']}/.ssh2/id_dsa",
        "#{ENV['HOME']}/.ssh/id_rsa",
        "#{ENV['HOME']}/.ssh2/id_rsa" ]
    end

    b.default_host_key_locations do
      [ "/etc/ssh/ssh_host_dsa_key",
        "/etc/ssh/ssh_host_rsa_key" ]
    end

    b.key_existence_tester { File }

    b.user_keys do |c,p|
      require 'net/ssh/userauth/userkeys'

      userkeys = UserKeyManager.new
      userkeys.agent_factory = c[:agent_factory]
      userkeys.keys = c[:transport][:keys]
      userkeys.buffers = c[:transport][:buffers]
      userkeys.log = c[:log_for, p]
      userkeys.key_existence_tester = b.key_existence_tester

      b.default_user_key_locations.each { |f| userkeys.add f }
      b.default_host_key_locations.each { |f| userkeys.add_host_key f }

      userkeys
    end

    b.authentication_method_order do
      [ "publickey",
        "hostbased",
        "password",
        "keyboard-interactive" ]
    end

    b.driver do |c,p|
      require 'net/ssh/userauth/driver'

      driver = Driver.new( c[:log_for, p],
                           c[:transport][:buffers],
                           c[:methods],
                           c[:authentication_method_order] )

      driver.key_manager = c[:user_keys]
      driver.session = c[:transport][:session]

      if c.knows_key?(:userauth_keys) && c[:userauth_keys]
        driver.set_key_files c[:userauth_keys]
      end
      if c.knows_key?(:userauth_host_keys) && c[:userauth_host_keys]
        driver.set_host_key_files c[:userauth_host_keys]
      end
      if c.knows_key?(:userauth_method_order) && c[:userauth_method_order]
        driver.set_auth_method_order(*c[:userauth_method_order])
      end

      driver
    end

  end
end