mechanize 0.1.0

data/lib/mechanize/net-overrides/net/https.rb

@@ -0,0 +1,171 @@
+=begin
+
+= $RCSfile: https.rb,v $ -- SSL/TLS enhancement for Net::HTTP.
+
+== Info
+  'OpenSSL for Ruby 2' project
+  Copyright (C) 2001 GOTOU Yuuzou <gotoyuzo@notwork.org>
+  All rights reserved.
+
+== Licence
+  This program is licenced under the same licence as Ruby.
+  (See the file 'LICENCE'.)
+
+== Requirements
+  This program requires Net 1.2.0 or higher version.
+  You can get it from RAA or Ruby's CVS repository.
+
+== Version
+  $Id: https.rb,v 1.3 2004/12/20 05:46:45 gotoyuzo Exp $
+  
+  2001-11-06: Contiributed to Ruby/OpenSSL project.
+  2004-03-06: Some code is merged in to net/http.
+
+== Example
+
+Here is a simple HTTP client:
+
+    require 'net/http'
+    require 'uri'
+
+    uri = URI.parse(ARGV[0] || 'http://localhost/')
+    http = Net::HTTP.new(uri.host, uri.port)
+    http.start {
+      http.request_get(uri.path) {|res|
+        print res.body
+      }
+    }
+
+It can be replaced by the following code:
+
+    require 'net/https'
+    require 'uri'
+
+    uri = URI.parse(ARGV[0] || 'https://localhost/')
+    http = Net::HTTP.new(uri.host, uri.port)
+    http.use_ssl = true if uri.scheme == "https"  # enable SSL/TLS
+    http.start {
+      http.request_get(uri.path) {|res|
+        print res.body
+      }
+    }
+
+== class Net::HTTP
+
+=== Instance Methods
+
+: use_ssl?
+    returns true if use SSL/TLS with HTTP.
+
+: use_ssl=((|true_or_false|))
+    sets use_ssl.
+
+: peer_cert
+    return the X.509 certificates the server presented.
+
+: key, key=((|key|))
+    Sets an OpenSSL::PKey::RSA or OpenSSL::PKey::DSA object.
+    (This method is appeared in Michal Rokos's OpenSSL extention.)
+
+: cert, cert=((|cert|))
+    Sets an OpenSSL::X509::Certificate object as client certificate
+    (This method is appeared in Michal Rokos's OpenSSL extention).
+
+: ca_file, ca_file=((|path|))
+    Sets path of a CA certification file in PEM format.
+    The file can contrain several CA certificats.
+
+: ca_path, ca_path=((|path|))
+    Sets path of a CA certification directory containing certifications
+    in PEM format.
+
+: verify_mode, verify_mode=((|mode|))
+    Sets the flags for server the certification verification at
+    begining of SSL/TLS session.
+    OpenSSL::SSL::VERIFY_NONE or OpenSSL::SSL::VERIFY_PEER is acceptable.
+
+: verify_callback, verify_callback=((|proc|))
+    Sets the verify callback for the server certification verification.
+
+: verify_depth, verify_depth=((|num|))
+    Sets the maximum depth for the certificate chain verification.
+
+: cert_store, cert_store=((|store|))
+    Sets the X509::Store to verify peer certificate.
+
+: ssl_timeout, ssl_timeout=((|sec|))
+    Sets the SSL timeout seconds.
+
+=end
+
+require 'net/http'
+require 'openssl'
+
+module Net
+
+  class HTTP
+    remove_method :use_ssl?
+    def use_ssl?
+      @use_ssl
+    end
+
+    alias use_ssl use_ssl?   # for backward compatibility
+
+    # Turn on/off SSL.
+    # This flag must be set before starting session.
+    # If you change use_ssl value after session started,
+    # a Net::HTTP object raises IOError.
+    def use_ssl=(flag)
+      flag = (flag ? true : false)
+      raise IOError, "use_ssl value changed, but session already started" \
+          if started? and @use_ssl != flag
+      if flag and not @ssl_context
+        @ssl_context = OpenSSL::SSL::SSLContext.new
+      end
+      @use_ssl = flag
+    end
+
+    def self.ssl_context_accessor(name)
+      module_eval(<<-End, __FILE__, __LINE__ + 1)
+        def #{name}
+          return nil unless @ssl_context
+          @ssl_context.#{name}
+        end
+
+        def #{name}=(val)
+          @ssl_context ||= OpenSSL::SSL::SSLContext.new
+          @ssl_context.#{name} = val
+        end
+      End
+    end
+
+    ssl_context_accessor :key
+    ssl_context_accessor :cert
+    ssl_context_accessor :ca_file
+    ssl_context_accessor :ca_path
+    ssl_context_accessor :verify_mode
+    ssl_context_accessor :verify_callback
+    ssl_context_accessor :verify_depth
+    ssl_context_accessor :cert_store
+
+    def ssl_timeout
+      return nil unless @ssl_context
+      @ssl_context.timeout
+    end
+
+    def ssl_timeout=(sec)
+      raise ArgumentError, 'Net::HTTP#ssl_timeout= called but use_ssl=false' \
+          unless use_ssl?
+      @ssl_context ||= OpenSSL::SSL::SSLContext.new
+      @ssl_context.timeout = sec
+    end
+
+    alias timeout= ssl_timeout=   # for backward compatibility
+
+    def peer_cert
+      return nil if not use_ssl? or not @socket
+      @socket.io.peer_cert
+    end
+  end
+
+end

data/lib/mechanize/net-overrides/net/protocol.rb

@@ -0,0 +1,380 @@
+#
+# = net/protocol.rb
+#
+#--
+# Copyright (c) 1999-2004 Yukihiro Matsumoto
+# Copyright (c) 1999-2004 Minero Aoki
+#
+# written and maintained by Minero Aoki <aamine@loveruby.net>
+#
+# This program is free software. You can re-distribute and/or
+# modify this program under the same terms as Ruby itself,
+# Ruby Distribute License or GNU General Public License.
+#
+# $Id: protocol.rb,v 1.78 2004/08/18 14:44:41 aamine Exp $
+#++
+#
+# WARNING: This file is going to remove.
+# Do not rely on the implementation written in this file.
+#
+
+require 'socket'
+require 'timeout'
+
+module Net # :nodoc:
+
+  class Protocol   #:nodoc: internal use only
+    private
+    def Protocol.protocol_param(name, val)
+      module_eval(<<-End, __FILE__, __LINE__ + 1)
+        def #{name}
+          #{val}
+        end
+      End
+    end
+  end
+
+
+  class ProtocolError          < StandardError; end
+  class ProtoSyntaxError       < ProtocolError; end
+  class ProtoFatalError        < ProtocolError; end
+  class ProtoUnknownError      < ProtocolError; end
+  class ProtoServerError       < ProtocolError; end
+  class ProtoAuthError         < ProtocolError; end
+  class ProtoCommandError      < ProtocolError; end
+  class ProtoRetriableError    < ProtocolError; end
+  ProtocRetryError = ProtoRetriableError
+
+
+  class BufferedIO   #:nodoc: internal use only
+    def initialize(io)
+      @io = io
+      @read_timeout = 60
+      @debug_output = nil
+      @rbuf = ''
+    end
+
+    attr_reader :io
+    attr_accessor :read_timeout
+    attr_accessor :debug_output
+
+    def inspect
+      "#<#{self.class} io=#{@io}>"
+    end
+
+    def closed?
+      @io.closed?
+    end
+
+    def close
+      @io.close
+    end
+
+    #
+    # Read
+    #
+
+    public
+
+    def read(len, dest = '', ignore_eof = false)
+      LOG "reading #{len} bytes..."
+      read_bytes = 0
+      begin
+        while read_bytes + @rbuf.size < len
+          dest << (s = rbuf_consume(@rbuf.size))
+          read_bytes += s.size
+          rbuf_fill
+        end
+        dest << (s = rbuf_consume(len - read_bytes))
+        read_bytes += s.size
+      rescue EOFError
+        raise unless ignore_eof
+      end
+      LOG "read #{read_bytes} bytes"
+      dest
+    end
+
+    def read_all(dest = '')
+      LOG 'reading all...'
+      read_bytes = 0
+      begin
+        while true
+          dest << (s = rbuf_consume(@rbuf.size))
+          read_bytes += s.size
+          rbuf_fill
+        end
+      rescue EOFError
+        ;
+      end
+      LOG "read #{read_bytes} bytes"
+      dest
+    end
+
+    def readuntil(terminator, ignore_eof = false)
+      begin
+        until idx = @rbuf.index(terminator)
+          rbuf_fill
+        end
+        return rbuf_consume(idx + terminator.size)
+      rescue EOFError
+        raise unless ignore_eof
+        return rbuf_consume(@rbuf.size)
+      end
+    end
+        
+    def readline
+      readuntil("\n").chop
+    end
+
+    private
+
+    def rbuf_fill
+      timeout(@read_timeout) {
+        @rbuf << @io.sysread(1024)
+      }
+    end
+
+    def rbuf_consume(len)
+      s = @rbuf.slice!(0, len)
+      @debug_output << %Q[-> #{s.dump}\n] if @debug_output
+      s
+    end
+
+    #
+    # Write
+    #
+
+    public
+
+    def write(str)
+      writing {
+        write0 str
+      }
+    end
+
+    def writeline(str)
+      writing {
+        write0 str + "\r\n"
+      }
+    end
+
+    private
+
+    def writing
+      @written_bytes = 0
+      @debug_output << '<- ' if @debug_output
+      yield
+      @debug_output << "\n" if @debug_output
+      bytes = @written_bytes
+      @written_bytes = nil
+      bytes
+    end
+
+    def write0(str)
+      @debug_output << str.dump if @debug_output
+      len = @io.write(str)
+      @written_bytes += len
+      len
+    end
+
+    #
+    # Logging
+    #
+
+    private
+
+    def LOG_off
+      @save_debug_out = @debug_output
+      @debug_output = nil
+    end
+
+    def LOG_on
+      @debug_output = @save_debug_out
+    end
+
+    def LOG(msg)
+      return unless @debug_output
+      @debug_output << msg + "\n"
+    end
+  end
+
+
+  class InternetMessageIO < BufferedIO   #:nodoc: internal use only
+    def initialize(io)
+      super
+      @wbuf = nil
+    end
+
+    #
+    # Read
+    #
+
+    def each_message_chunk
+      LOG 'reading message...'
+      LOG_off()
+      read_bytes = 0
+      while (line = readuntil("\r\n")) != ".\r\n"
+        read_bytes += line.size
+        yield line.sub(/\A\./, '')
+      end
+      LOG_on()
+      LOG "read message (#{read_bytes} bytes)"
+    end
+  
+    # *library private* (cannot handle 'break')
+    def each_list_item
+      while (str = readuntil("\r\n")) != ".\r\n"
+        yield str.chop
+      end
+    end
+
+    def write_message_0(src)
+      prev = @written_bytes
+      each_crlf_line(src) do |line|
+        write0 line.sub(/\A\./, '..')
+      end
+      @written_bytes - prev
+    end
+
+    #
+    # Write
+    #
+
+    def write_message(src)
+      LOG "writing message from #{src.class}"
+      LOG_off()
+      len = writing {
+        using_each_crlf_line {
+          write_message_0 src
+        }
+      }
+      LOG_on()
+      LOG "wrote #{len} bytes"
+      len
+    end
+
+    def write_message_by_block(&block)
+      LOG 'writing message from block'
+      LOG_off()
+      len = writing {
+        using_each_crlf_line {
+          begin
+            block.call(WriteAdapter.new(self, :write_message_0))
+          rescue LocalJumpError
+            # allow `break' from writer block
+          end
+        }
+      }
+      LOG_on()
+      LOG "wrote #{len} bytes"
+      len
+    end
+
+    private
+
+    def using_each_crlf_line
+      @wbuf = ''
+      yield
+      if not @wbuf.empty?   # unterminated last line
+        write0 @wbuf.chomp + "\r\n"
+      elsif @written_bytes == 0   # empty src
+        write0 "\r\n"
+      end
+      write0 ".\r\n"
+      @wbuf = nil
+    end
+
+    def each_crlf_line(src)
+      buffer_filling(@wbuf, src) do
+        while line = @wbuf.slice!(/\A.*(?:\n|\r\n|\r(?!\z))/n)
+          yield line.chomp("\n") + "\r\n"
+        end
+      end
+    end
+
+    def buffer_filling(buf, src)
+      case src
+      when String    # for speeding up.
+        0.step(src.size - 1, 1024) do |i|
+          buf << src[i, 1024]
+          yield
+        end
+      when File    # for speeding up.
+        while s = src.read(1024)
+          buf << s
+          yield
+        end
+      else    # generic reader
+        src.each do |s|
+          buf << s
+          yield if buf.size > 1024
+        end
+        yield unless buf.empty?
+      end
+    end
+  end
+
+
+  #
+  # The writer adapter class
+  #
+  class WriteAdapter
+    def initialize(socket, method)
+      @socket = socket
+      @method_id = method
+    end
+
+    def inspect
+      "#<#{self.class} socket=#{@socket.inspect}>"
+    end
+
+    def write(str)
+      @socket.__send__(@method_id, str)
+    end
+
+    alias print write
+
+    def <<(str)
+      write str
+      self
+    end
+
+    def puts(str = '')
+      write str.chomp("\n") + "\n"
+    end
+
+    def printf(*args)
+      write sprintf(*args)
+    end
+  end
+
+
+  class ReadAdapter   #:nodoc: internal use only
+    def initialize(block)
+      @block = block
+    end
+
+    def inspect
+      "#<#{self.class}>"
+    end
+
+    def <<(str)
+      call_block(str, &@block) if @block
+    end
+
+    private
+
+    # This method is needed because @block must be called by yield,
+    # not Proc#call.  You can see difference when using `break' in
+    # the block.
+    def call_block(str)
+      yield str
+    end
+  end
+
+
+  module NetPrivate   #:nodoc: obsolete
+    Socket = ::Net::InternetMessageIO
+  end
+
+end   # module Net