# File openssl/lib/openssl/buffering.rb, line 295
def << (s)
do_write(s)
self
end
# File openssl/lib/openssl/buffering.rb, line 336
def close
flush rescue nil
sysclose
end
# File openssl/lib/openssl/buffering.rb, line 174
def each(eol=$/)
while line = self.gets(eol)
yield line
end
end
# File openssl/lib/openssl/buffering.rb, line 199
def each_byte
while c = getc
yield(c)
end
end
# File openssl/lib/openssl/buffering.rb, line 214
def eof?
fill_rbuff if !@eof && @rbuffer.empty?
@eof && @rbuffer.empty?
end
# File openssl/lib/openssl/buffering.rb, line 327
def flush
osync = @sync
@sync = true
do_write ""
return self
ensure
@sync = osync
end
# File openssl/lib/openssl/buffering.rb, line 194
def getc
c = read(1)
c ? c[0] : nil
end
# File openssl/lib/openssl/buffering.rb, line 156
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 limit and limit >= 0
size = [size, limit].min
end
consume_rbuff(size)
end
# File openssl/lib/openssl/buffering.rb, line 315
def print(*args)
s = ""
args.each{ |arg| s << arg.to_s }
do_write(s)
nil
end
# File openssl/lib/openssl/buffering.rb, line 322
def printf(s, *args)
do_write(s % args)
nil
end
# File openssl/lib/openssl/buffering.rb, line 300
def puts(*args)
s = ""
if args.empty?
s << "\n"
end
args.each{|arg|
s << arg.to_s
if $/ && /\n\z/ !~ s
s << "\n"
end
}
do_write(s)
nil
end
# File openssl/lib/openssl/buffering.rb, line 57
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 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 after underlying IO is readable.
IO::WaitWritable means SSL needs to write internally. So read_nonblock should be called again after underlying IO is writable.
So 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 write to a underlying IO is the peer requests a new TLS/SSL handshake. See openssl FAQ for more details. www.openssl.org/support/faq.html
# File openssl/lib/openssl/buffering.rb, line 135
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
# File openssl/lib/openssl/buffering.rb, line 205
def readchar
raise EOFError if eof?
getc
end
# File openssl/lib/openssl/buffering.rb, line 189
def readline(eol=$/)
raise EOFError if eof?
gets(eol)
end
# File openssl/lib/openssl/buffering.rb, line 181
def readlines(eol=$/)
ary = []
while line = self.gets(eol)
ary << line
end
ary
end
# File openssl/lib/openssl/buffering.rb, line 78
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 Errno::EAGAIN
retry
end
end
ret = consume_rbuff(maxlen)
if buf
buf.replace(ret)
ret = buf
end
raise EOFError if ret.empty?
ret
end
# File openssl/lib/openssl/buffering.rb, line 210
def ungetc(c)
@rbuffer[0,0] = c.chr
end
# File openssl/lib/openssl/buffering.rb, line 248
def write(s)
do_write(s)
s.length
end
Writes str in the non-blocking manner.
If there are buffered data, it is flushed at 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 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 read from a underlying IO is the peer requests a new TLS/SSL handshake. See openssl FAQ for more details. www.openssl.org/support/faq.html
# File openssl/lib/openssl/buffering.rb, line 290
def write_nonblock(s)
flush
syswrite_nonblock(s)
end