register_services (Net::SSH::Transport)

    # File lib/net/ssh/transport/services.rb, line 22
          def register_services( container )
            container.namespace_define :transport do |b|
              b.kex_names { Hash.new }
              b.compression_algorithms { Hash.new }
              b.decompression_algorithms { Hash.new }

              b.cipher_factories { Hash.new }
              b.hmac_factories { Hash.new }
              b.key_factories { Hash.new }
              b.buffer_factories { Hash.new }
              b.bn_factories { Hash.new }
              b.digest_factories { Hash.new }

              b.ciphers( :model => :prototype ) { |c,|
                c.cipher_factories.fetch( c.crypto_backend ) }

              b.hmacs( :model => :prototype ) { |c,|
                c.hmac_factories.fetch( c.crypto_backend ) }

              b.keys( :model => :prototype ) { |c,|
                c.key_factories.fetch( c.crypto_backend ) }

              b.buffers( :model => :prototype ) { |c,|
                c.buffer_factories.fetch( c.crypto_backend ) }

              b.bns( :model => :prototype ) { |c,|
                c.bn_factories.fetch( c.crypto_backend ) }

              b.digesters( :model => :prototype ) { |c,|
                c.digest_factories.fetch( c.crypto_backend ) }

              b.identity_cipher do
                require 'net/ssh/transport/identity-cipher'
                IdentityCipher.new
              end

              b.outgoing_packet_stream :model => :prototype_deferred do |c,|
                require 'net/ssh/transport/packet-stream'
                OutgoingPacketStream.new(
                  c.ciphers, c.hmacs, c.compression_algorithms )
              end

              b.incoming_packet_stream :model => :prototype_deferred do |c,point|
                require 'net/ssh/transport/packet-stream'
                stream = IncomingPacketStream.new(
                  c.ciphers, c.hmacs, c.decompression_algorithms )
                stream.buffers = c.buffers
                stream.log = c.log_for( point )
                stream
              end

              b.algorithms do
                Hash[
                  :host_key => [ "ssh-dss", "ssh-rsa" ],
                  :kex => [ "diffie-hellman-group-exchange-sha1",
                            "diffie-hellman-group1-sha1" ],
                  :encryption => [ "3des-cbc",
                                   "aes128-cbc",
                                   "blowfish-cbc",
                                   "aes256-cbc",
                                   "aes192-cbc",
                                   "idea-cbc",
                                   "none" ],
                  :hmac => [ "hmac-md5",
                             "hmac-sha1",
                             "hmac-md5-96",
                             "hmac-sha1-96",
                             "none" ],
                  :compression => [ "none", "zlib" ],
                  :languages => []
                ]
              end

              b.default_ssh_port { 22 }

              b.socket_factory do
                require 'socket'
                TCPSocket
              end

              b.version_negotiator do |c,point|
                require 'net/ssh/transport/version-negotiator'
                VersionNegotiator.new( c.log_for( point ) )
              end

              b.algorithm_negotiator do |c,point|
                require 'net/ssh/transport/algorithm-negotiator'
                AlgorithmNegotiator.new(
                  c.log_for( point ),
                  c.algorithms,
                  c.buffers )
              end

              b.session do |c,point|
                require 'net/ssh/transport/session'

                args = [ c[:transport_host] ]
                args << c[:transport_options] if c.knows_key?(:transport_options)

                Session.new( *args ) do |s|
                  s.logger               = c[:log_for, point]
                  s.default_port         = c[:default_ssh_port]
                  s.version_negotiator   = c[:version_negotiator]
                  s.algorithm_negotiator = c[:algorithm_negotiator]
                  s.socket_factory       = c[:socket_factory]
                  s.packet_sender        = c[:outgoing_packet_stream]
                  s.packet_receiver      = c[:incoming_packet_stream]
                  s.ciphers              = c[:ciphers]
                  s.hmacs                = c[:hmacs]
                  s.kexs                 = c[:kex_names]
                  s.compressors          = c[:compression_algorithms]
                  s.decompressors        = c[:decompression_algorithms]
                end
              end

              b.require 'net/ssh/transport/ossl/services', "#{self}::OSSL"
              b.require 'net/ssh/transport/compress/services', "#{self}::Compress"
              b.require 'net/ssh/transport/kex/services', "#{self}::Kex"
            end
          end