 module OpenSSL8b7c:f320:99b9:690f:4595:cd17:293a:c069uffering 

Included modules:
Enumerable
  OpenSSL IO buffering mix-in module. This module allows an OpenSSL8b7c:f320:99b9:690f:4595:cd17:293a:c069SSL8b7c:f320:99b9:690f:4595:cd17:293a:c069SSLSocket to behave like an IO. You typically won't use this module directly, you can see it implemented in OpenSSL8b7c:f320:99b9:690f:4595:cd17:293a:c069SSL8b7c:f320:99b9:690f:4595:cd17:293a:c069SSLSocket.     Constants   BLOCK_SIZE 

Default size to read from or write to the SSLSocket for buffer operations. 
    Attributes    sync[RW]   The “sync mode” of the SSLSocket. See IO#sync for full details.      Public Class Methods    new(*) Show source  
 # File ext/openssl/lib/openssl/buffering.rb, line 40
def initialize(*)
  super
  @eof = false
  @rbuffer = ""
  @sync = @io.sync
end  Creates an instance of OpenSSL's buffering IO module.  Calls superclass method       Public Instance Methods    <<(s) Show source  
 # File ext/openssl/lib/openssl/buffering.rb, line 390
def <<(s)
  do_write(s)
  self
end  Writes s to the stream. s will be converted to a String using .to_s method.     close() Show source  
 # File ext/openssl/lib/openssl/buffering.rb, line 451
def close
  flush rescue nil
  sysclose
end  Closes the SSLSocket and flushes any unwritten data.     each(eol=$/) { |line| ... } Show source  
 # File ext/openssl/lib/openssl/buffering.rb, line 227
def each(eol=$/)
  while line = self.gets(eol)
    yield line
  end
end  Executes the block for every line in the stream where lines are separated by eol. See also gets   Also aliased as: each_line     each_byte() { |byte| ... } Show source  
 # File ext/openssl/lib/openssl/buffering.rb, line 268
def each_byte # :yields: byte
  while c = getc
    yield(c.ord)
  end
end  Calls the given block once for each byte in the stream.     each_line(eol=$/)   Alias for: each     eof()   Alias for: eof?     eof?() Show source  
 # File ext/openssl/lib/openssl/buffering.rb, line 299
def eof?
  fill_rbuff if !@eof && @rbuffer.empty?
  @eof && @rbuffer.empty?
end  Returns true if the stream is at file which means there is no more data to be read.   Also aliased as: eof     flush() Show source  
 # File ext/openssl/lib/openssl/buffering.rb, line 439
def flush
  osync = @sync
  @sync = true
  do_write ""
  return self
ensure
  @sync = osync
end  Flushes buffered data to the SSLSocket.     getc() Show source  
 # File ext/openssl/lib/openssl/buffering.rb, line 261
def getc
  read(1)
end  Reads one character from the stream. Returns nil if called at end of file.     gets(eol=$/, limit=nil) Show source  
 # File ext/openssl/lib/openssl/buffering.rb, line 203
def gets(eol=$/, limit=nil)
  idx = @rbuffer.index(eol)
  until @eof
    break if idx
    fill_rbuff
    idx = @rbuffer.index(eol)
  end
  if eol.is_a?(Regexp)
    size = idx ? idx+$&.size : nil
  else
    size = idx ? idx+eol.size : nil
  end
  if size && limit && limit >= 0
    size = [size, limit].min
  end
  consume_rbuff(size)
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.     print(*args) Show source  
 # File ext/openssl/lib/openssl/buffering.rb, line 418
def print(*args)
  s = ""
  args.each{ |arg| s << arg.to_s }
  do_write(s)
  nil
end  Writes args to the stream. See IO#print for full details.     printf(s, *args) Show source  
 # File ext/openssl/lib/openssl/buffering.rb, line 431
def printf(s, *args)
  do_write(s % args)
  nil
end  Formats and writes to the stream converting parameters under control of the format string. See Kernel#sprintf for format string details.     puts(*args) Show source  
 # File ext/openssl/lib/openssl/buffering.rb, line 400
def puts(*args)
  s = ""
  if args.empty?
    s << "\n"
  end
  args.each{|arg|
    s << arg.to_s
    s.sub!(/(?<!\n)\z/, "\n")
  }
  do_write(s)
  nil
end  Writes args to the stream along with a record separator. See IO#puts for full details.     read(size=nil, buf=nil) Show source  
 # File ext/openssl/lib/openssl/buffering.rb, line 87
def read(size=nil, buf=nil)
  if size == 0
    if buf
      buf.clear
      return buf
    else
      return ""
    end
  end
  until @eof
    break if size && size <= @rbuffer.size
    fill_rbuff
  end
  ret = consume_rbuff(size) || ""
  if buf
    buf.replace(ret)
    ret = buf
  end
  (size && ret.empty?) ? nil : ret
end  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.     read_nonblock(maxlen, buf=nil, exception: true) Show source  
 # File ext/openssl/lib/openssl/buffering.rb, line 172
def read_nonblock(maxlen, buf=nil, exception: true)
  if maxlen == 0
    if buf
      buf.clear
      return buf
    else
      return ""
    end
  end
  if @rbuffer.empty?
    return sysread_nonblock(maxlen, buf, exception: exception)
  end
  ret = consume_rbuff(maxlen)
  if buf
    buf.replace(ret)
    ret = buf
  end
  ret
end  Reads at most maxlen bytes in the non-blocking manner. When no data can be read without blocking it raises OpenSSL8b7c:f320:99b9:690f:4595:cd17:293a:c069SSL8b7c:f320:99b9:690f:4595:cd17:293a:c069SSLError extended by IO8b7c:f320:99b9:690f:4595:cd17:293a:c069WaitReadable or IO8b7c:f320:99b9:690f:4595:cd17:293a:c069WaitWritable. IO8b7c:f320:99b9:690f:4595:cd17:293a:c069WaitReadable means SSL needs to read internally so read_nonblock should be called again when the underlying IO is readable. IO8b7c:f320:99b9:690f:4595:cd17:293a:c069WaitWritable means SSL needs to write internally so read_nonblock should be called again after the underlying IO is writable. OpenSSL8b7c:f320:99b9:690f:4595:cd17:293a:c069uffering#read_nonblock needs two rescue clause as follows: # emulates blocking read (readpartial).
begin
  result = ssl.read_nonblock(maxlen)
rescue IO8b7c:f320:99b9:690f:4595:cd17:293a:c069WaitReadable
  IO.select([io])
  retry
rescue IO8b7c:f320:99b9:690f:4595:cd17:293a:c069WaitWritable
  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. www.openssl.org/support/faq.html By specifying a keyword argument exception to false, you can indicate that read_nonblock should not raise an IO8b7c:f320:99b9:690f:4595:cd17:293a:c069Wait*able exception, but return the symbol :wait_writable or :wait_readable instead. At EOF, it will return nil instead of raising EOFError.     readchar() Show source  
 # File ext/openssl/lib/openssl/buffering.rb, line 278
def readchar
  raise EOFError if eof?
  getc
end  Reads a one-character string from the stream. Raises an EOFError at end of file.     readline(eol=$/) Show source  
 # File ext/openssl/lib/openssl/buffering.rb, line 252
def readline(eol=$/)
  raise EOFError if eof?
  gets(eol)
end  Reads a line from the stream which is separated by eol. Raises EOFError if at end of file.     readlines(eol=$/) Show source  
 # File ext/openssl/lib/openssl/buffering.rb, line 239
def readlines(eol=$/)
  ary = []
  while line = self.gets(eol)
    ary << line
  end
  ary
end  Reads lines from the stream which are separated by eol. See also gets     readpartial(maxlen, buf=nil) Show source  
 # File ext/openssl/lib/openssl/buffering.rb, line 114
def readpartial(maxlen, buf=nil)
  if maxlen == 0
    if buf
      buf.clear
      return buf
    else
      return ""
    end
  end
  if @rbuffer.empty?
    begin
      return sysread(maxlen, buf)
    rescue Errno8b7c:f320:99b9:690f:4595:cd17:293a:c069GAIN
      retry
    end
  end
  ret = consume_rbuff(maxlen)
  if buf
    buf.replace(ret)
    ret = buf
  end
  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.     ungetc(c) Show source  
 # File ext/openssl/lib/openssl/buffering.rb, line 291
def ungetc(c)
  @rbuffer[0,0] = c.chr
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).     write(*s) Show source  
 # File ext/openssl/lib/openssl/buffering.rb, line 337
def write(*s)
  s.inject(0) do |written, str|
    do_write(str)
    written + str.bytesize
  end
end  Writes s to the stream. If the argument is not a String it will be converted using .to_s method. Returns the number of bytes written.     write_nonblock(s, exception: true) Show source  
 # File ext/openssl/lib/openssl/buffering.rb, line 381
def write_nonblock(s, exception: true)
  flush
  syswrite_nonblock(s, exception: exception)
end  Writes s 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 OpenSSL8b7c:f320:99b9:690f:4595:cd17:293a:c069SSL8b7c:f320:99b9:690f:4595:cd17:293a:c069SSLError extended by IO8b7c:f320:99b9:690f:4595:cd17:293a:c069WaitReadable or IO8b7c:f320:99b9:690f:4595:cd17:293a:c069WaitWritable. IO8b7c:f320:99b9:690f:4595:cd17:293a:c069WaitReadable means SSL needs to read internally so write_nonblock should be called again after the underlying IO is readable. IO8b7c:f320:99b9:690f:4595:cd17:293a:c069WaitWritable means SSL needs to write internally so write_nonblock should be called again after underlying IO is writable. So OpenSSL8b7c:f320:99b9:690f:4595:cd17:293a:c069uffering#write_nonblock needs two rescue clause as follows. # emulates blocking write.
begin
  result = ssl.write_nonblock(str)
rescue IO8b7c:f320:99b9:690f:4595:cd17:293a:c069WaitReadable
  IO.select([io])
  retry
rescue IO8b7c:f320:99b9:690f:4595:cd17:293a:c069WaitWritable
  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. www.openssl.org/support/faq.html By specifying a keyword argument exception to false, you can indicate that write_nonblock should not raise an IO8b7c:f320:99b9:690f:4595:cd17:293a:c069Wait*able exception, but return the symbol :wait_writable or :wait_readable instead.      Private Instance Methods    consume_rbuff(size=nil) Show source  
 # File ext/openssl/lib/openssl/buffering.rb, line 68
def consume_rbuff(size=nil)
  if @rbuffer.empty?
    nil
  else
    size = @rbuffer.size unless size
    ret = @rbuffer[0, size]
    @rbuffer[0, size] = ""
    ret
  end
end  Consumes size bytes from the buffer     do_write(s) Show source  
 # File ext/openssl/lib/openssl/buffering.rb, line 314
def do_write(s)
  @wbuffer = "" unless defined? @wbuffer
  @wbuffer << s
  @wbuffer.force_encoding(Encoding8b7c:f320:99b9:690f:4595:cd17:293a:c069INARY)
  @sync ||= false
  if @sync or @wbuffer.size > BLOCK_SIZE
    until @wbuffer.empty?
      begin
        nwrote = syswrite(@wbuffer)
      rescue Errno8b7c:f320:99b9:690f:4595:cd17:293a:c069GAIN
        retry
      end
      @wbuffer[0, nwrote] = ""
    end
  end
end  Writes s to the buffer. When the buffer is full or sync is true the buffer is flushed to the underlying socket.     fill_rbuff() Show source  
 # File ext/openssl/lib/openssl/buffering.rb, line 55
def fill_rbuff
  begin
    @rbuffer << self.sysread(BLOCK_SIZE)
  rescue Errno8b7c:f320:99b9:690f:4595:cd17:293a:c069GAIN
    retry
  rescue EOFError
    @eof = true
  end
end  Fills the buffer from the underlying SSLSocket    

    Ruby Core © 1993–2017 Yukihiro MatsumotoLicensed under the Ruby License.Ruby Standard Library 
{'path': 'public/docs/ruby~2.6/openssl/buffering.html', 'source': 'DevDocs.IO'}