rubysl-openssl 1.0.2 → 2.0.0

data/ext/rubysl/openssl/ruby_missing.h

@@ -1,5 +1,5 @@
 /*
- * $Id: ruby_missing.h 12496 2007-06-08 15:02:04Z technorama $
+ * $Id$
  * 'OpenSSL for Ruby' project
  * Copyright (C) 2001-2003  Michal Rokos <m.rokos@sh.cvut.cz>
  * All rights reserved.
@@ -12,11 +12,11 @@
 #define _OSSL_RUBY_MISSING_H_
 
 #define rb_define_copy_func(klass, func) \
-	rb_define_method(klass, "initialize_copy", func, 1)
+	rb_define_method((klass), "initialize_copy", (func), 1)
 
 
 #ifndef GetReadFile
-#define FPTR_TO_FD(fptr) (fptr->fd)
+#define FPTR_TO_FD(fptr) ((fptr)->fd)
 #else
 #define FPTR_TO_FD(fptr) (fileno(GetReadFile(fptr)))
 #endif
@@ -25,17 +25,4 @@
 #define rb_io_t OpenFile
 #endif
 
-#ifndef HAVE_RB_STR_SET_LEN
-/* these methods should probably be backported to 1.8 */
-#define rb_str_set_len(str, length) do {	\
-	RSTRING(str)->ptr[length] = 0;		\
-	RSTRING(str)->len = length;		\
-} while(0)
-#endif /* ! HAVE_RB_STR_SET_LEN */
-
-#ifndef HAVE_RB_BLOCK_CALL
-/* the openssl module doesn't use arg[3-4] and arg2 is always rb_each */
-#define rb_block_call(arg1, arg2, arg3, arg4, arg5, arg6) rb_iterate(rb_each, arg1, arg5, arg6)
-#endif /* ! HAVE_RB_BLOCK_CALL */
-
 #endif /* _OSSL_RUBY_MISSING_H_ */

data/lib/openssl/bn.rb

@@ -1,22 +1,22 @@
-=begin
-= $RCSfile$ -- Ruby-space definitions that completes C-space funcs for BN
-
-= Info
-  'OpenSSL for Ruby 2' project
-  Copyright (C) 2002  Michal Rokos <m.rokos@sh.cvut.cz>
-  All rights reserved.
-
-= Licence
-  This program is licenced under the same licence as Ruby.
-  (See the file 'LICENCE'.)
-
-= Version
-  $Id: bn.rb 31657 2011-05-20 22:25:35Z shyouhei $
-=end
-
-##
-# Should we care what if somebody require this file directly?
-#require 'openssl'
+#--
+#
+# $RCSfile$
+#
+# = Ruby-space definitions that completes C-space funcs for BN
+#
+# = Info
+# 'OpenSSL for Ruby 2' project
+# Copyright (C) 2002  Michal Rokos <m.rokos@sh.cvut.cz>
+# All rights reserved.
+#
+# = Licence
+# This program is licenced under the same licence as Ruby.
+# (See the file 'LICENCE'.)
+#
+# = Version
+# $Id$
+#
+#++
 
 module OpenSSL
   class BN

data/lib/openssl/buffering.rb

@@ -11,13 +11,27 @@
   (See the file 'LICENCE'.)
 
 = Version
-  $Id: buffering.rb 28004 2010-05-24 23:58:49Z shyouhei $
+  $Id$
 =end
 
-module OpenSSL
-module Buffering
+##
+# OpenSSL IO buffering mix-in module.
+#
+# This module allows an OpenSSL::SSL::SSLSocket to behave like an IO.
+
+module OpenSSL::Buffering
   include Enumerable
+
+  ##
+  # The "sync mode" of the SSLSocket.
+  #
+  # See IO#sync for full details.
+
   attr_accessor :sync
+
+  ##
+  # Default size to read from or write to the SSLSocket for buffer operations.
+
   BLOCK_SIZE = 1024*16
 
   def initialize(*args)
@@ -31,6 +45,9 @@ module Buffering
   #
   private
 
+  ##
+  # Fills the buffer from the underlying SSLSocket
+
   def fill_rbuff
     begin
       @rbuffer << self.sysread(BLOCK_SIZE)
@@ -41,6 +58,9 @@ module Buffering
     end
   end
 
+  ##
+  # Consumes +size+ bytes from the buffer
+
   def consume_rbuff(size=nil)
     if @rbuffer.empty?
       nil
@@ -54,14 +74,20 @@ module Buffering
 
   public
 
+  ##
+  # Reads +size+ bytes from the stream.  If +buf+ is provided it must
+  # reference a string which will receive the data.
+  #
+  # See IO#read for full details.
+
   def read(size=nil, buf=nil)
     if size == 0
       if buf
         buf.clear
+        return buf
       else
-        buf = ""
+        return ""
       end
-      return @eof ? nil : buf
     end
     until @eof
       break if size && size <= @rbuffer.size
@@ -75,14 +101,20 @@ module Buffering
     (size && ret.empty?) ? nil : ret
   end
 
+  ##
+  # Reads at most +maxlen+ bytes from the stream.  If +buf+ is provided it
+  # must reference a string which will receive the data.
+  #
+  # See IO#readpartial for full details.
+
   def readpartial(maxlen, buf=nil)
     if maxlen == 0
       if buf
         buf.clear
+        return buf
       else
-        buf = ""
+        return ""
       end
-      return @eof ? nil : buf
     end
     if @rbuffer.empty?
       begin
@@ -100,7 +132,68 @@ module Buffering
     ret
   end
 
-  def gets(eol=$/)
+  ##
+  # Reads at most +maxlen+ bytes in the non-blocking manner.
+  #
+  # When no data can be read without blocking it raises
+  # OpenSSL::SSL::SSLError extended by IO::WaitReadable or IO::WaitWritable.
+  #
+  # IO::WaitReadable means SSL needs to read internally so read_nonblock
+  # should be called again when the underlying IO is readable.
+  #
+  # IO::WaitWritable means SSL needs to write internally so read_nonblock
+  # should be called again after the underlying IO is writable.
+  #
+  # OpenSSL::Buffering#read_nonblock needs two rescue clause as follows:
+  #
+  #   # emulates blocking read (readpartial).
+  #   begin
+  #     result = ssl.read_nonblock(maxlen)
+  #   rescue IO::WaitReadable
+  #     IO.select([io])
+  #     retry
+  #   rescue IO::WaitWritable
+  #     IO.select(nil, [io])
+  #     retry
+  #   end
+  #
+  # Note that one reason that read_nonblock writes to the underlying IO is
+  # when the peer requests a new TLS/SSL handshake.  See openssl the FAQ for
+  # more details.  http://www.openssl.org/support/faq.html
+
+  def read_nonblock(maxlen, buf=nil)
+    if maxlen == 0
+      if buf
+        buf.clear
+        return buf
+      else
+        return ""
+      end
+    end
+    if @rbuffer.empty?
+      return sysread_nonblock(maxlen, buf)
+    end
+    ret = consume_rbuff(maxlen)
+    if buf
+      buf.replace(ret)
+      ret = buf
+    end
+    raise EOFError if ret.empty?
+    ret
+  end
+
+  ##
+  # Reads the next "line+ from the stream.  Lines are separated by +eol+.  If
+  # +limit+ is provided the result will not be longer than the given number of
+  # bytes.
+  #
+  # +eol+ may be a String or Regexp.
+  #
+  # Unlike IO#gets the line read will not be assigned to +$_+.
+  #
+  # Unlike IO#gets the separator must be provided if a limit is provided.
+
+  def gets(eol=$/, limit=nil)
     idx = @rbuffer.index(eol)
     until @eof
       break if idx
@@ -112,9 +205,18 @@ module Buffering
     else
       size = idx ? idx+eol.size : nil
     end
+    if limit and limit >= 0
+      size = [size, limit].min
+    end
     consume_rbuff(size)
   end
 
+  ##
+  # Executes the block for every line in the stream where lines are separated
+  # by +eol+.
+  #
+  # See also #gets
+
   def each(eol=$/)
     while line = self.gets(eol)
       yield line
@@ -122,6 +224,11 @@ module Buffering
   end
   alias each_line each
 
+  ##
+  # Reads lines from the stream which are separated by +eol+.
+  #
+  # See also #gets
+
   def readlines(eol=$/)
     ary = []
     while line = self.gets(eol)
@@ -130,31 +237,58 @@ module Buffering
     ary
   end
 
+  ##
+  # Reads a line from the stream which is separated by +eol+.
+  #
+  # Raises EOFError if at end of file.
+
   def readline(eol=$/)
     raise EOFError if eof?
     gets(eol)
   end
 
+  ##
+  # Reads one character from the stream.  Returns nil if called at end of
+  # file.
+
   def getc
-    c = read(1)
-    c ? c[0] : nil
+    read(1)
   end
 
-  def each_byte
+  ##
+  # Calls the given block once for each byte in the stream.
+
+  def each_byte # :yields: byte
     while c = getc
-      yield(c)
+      yield(c.ord)
     end
   end
 
+  ##
+  # Reads a one-character string from the stream.  Raises an EOFError at end
+  # of file.
+
   def readchar
     raise EOFError if eof?
     getc
   end
 
+  ##
+  # Pushes character +c+ back onto the stream such that a subsequent buffered
+  # character read will return it.
+  #
+  # Unlike IO#getc multiple bytes may be pushed back onto the stream.
+  #
+  # Has no effect on unbuffered reads (such as #sysread).
+
   def ungetc(c)
     @rbuffer[0,0] = c.chr
   end
 
+  ##
+  # Returns true if the stream is at file which means there is no more data to
+  # be read.
+
   def eof?
     fill_rbuff if !@eof && @rbuffer.empty?
     @eof && @rbuffer.empty?
@@ -166,9 +300,14 @@ module Buffering
   #
   private
 
+  ##
+  # Writes +s+ to the buffer.  When the buffer is full or #sync is true the
+  # buffer is flushed to the underlying socket.
+
   def do_write(s)
     @wbuffer = "" unless defined? @wbuffer
     @wbuffer << s
+    @wbuffer.force_encoding(Encoding::BINARY)
     @sync ||= false
     if @sync or @wbuffer.size > BLOCK_SIZE or idx = @wbuffer.rindex($/)
       remain = idx ? idx + $/.size : @wbuffer.length
@@ -189,16 +328,67 @@ module Buffering
 
   public
 
+  ##
+  # Writes +s+ to the stream.  If the argument is not a string it will be
+  # converted using String#to_s.  Returns the number of bytes written.
+
   def write(s)
     do_write(s)
-    s.length
+    s.bytesize
+  end
+
+  ##
+  # Writes +str+ in the non-blocking manner.
+  #
+  # If there is buffered data, it is flushed first.  This may block.
+  #
+  # write_nonblock returns number of bytes written to the SSL connection.
+  #
+  # When no data can be written without blocking it raises
+  # OpenSSL::SSL::SSLError extended by IO::WaitReadable or IO::WaitWritable.
+  #
+  # IO::WaitReadable means SSL needs to read internally so write_nonblock
+  # should be called again after the underlying IO is readable.
+  #
+  # IO::WaitWritable means SSL needs to write internally so write_nonblock
+  # should be called again after underlying IO is writable.
+  #
+  # So OpenSSL::Buffering#write_nonblock needs two rescue clause as follows.
+  #
+  #   # emulates blocking write.
+  #   begin
+  #     result = ssl.write_nonblock(str)
+  #   rescue IO::WaitReadable
+  #     IO.select([io])
+  #     retry
+  #   rescue IO::WaitWritable
+  #     IO.select(nil, [io])
+  #     retry
+  #   end
+  #
+  # Note that one reason that write_nonblock reads from the underlying IO
+  # is when the peer requests a new TLS/SSL handshake.  See the openssl FAQ
+  # for more details.  http://www.openssl.org/support/faq.html
+
+  def write_nonblock(s)
+    flush
+    syswrite_nonblock(s)
   end
 
+  ##
+  # Writes +s+ to the stream.  +s+ will be converted to a String using
+  # String#to_s.
+
   def << (s)
     do_write(s)
     self
   end
 
+  ##
+  # Writes +args+ to the stream along with a record separator.
+  #
+  # See IO#puts for full details.
+
   def puts(*args)
     s = ""
     if args.empty?
@@ -214,6 +404,11 @@ module Buffering
     nil
   end
 
+  ##
+  # Writes +args+ to the stream.
+  #
+  # See IO#print for full details.
+
   def print(*args)
     s = ""
     args.each{ |arg| s << arg.to_s }
@@ -221,21 +416,34 @@ module Buffering
     nil
   end
 
+  ##
+  # Formats and writes to the stream converting parameters under control of
+  # the format string.
+  #
+  # See Kernel#sprintf for format string details.
+
   def printf(s, *args)
     do_write(s % args)
     nil
   end
 
+  ##
+  # Flushes buffered data to the SSLSocket.
+
   def flush
     osync = @sync
     @sync = true
     do_write ""
+    return self
+  ensure
     @sync = osync
   end
 
+  ##
+  # Closes the SSLSocket and flushes any unwritten data.
+
   def close
     flush rescue nil
     sysclose
   end
 end
-end