OpenSSL IO buffering mix-in module.
This module allows an OpenSSL::SSL::SSLSocket to behave like an IO.
- #
- C
- D
- E
- F
- G
- N
- P
- R
- U
- W
| BLOCK_SIZE | = | 1024*16 |
Default size to read from or write to the SSLSocket for buffer operations. |
||
| [RW] | sync | The “sync mode” of the SSLSocket. See IO#sync for full details. |
Writes s to the stream. s will be converted to a
String using String#to_s.
Closes the SSLSocket and flushes any unwritten data.
Executes the block for every line in the stream where lines are separated
by eol.
See also gets
Calls the given block once for each byte in the stream.
Returns true if the stream is at file which means there is no more data to be read.
Flushes buffered data to the SSLSocket.
Reads one character from the stream. Returns nil if called at end of file.
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.
# File ../ruby/ext/openssl/lib/openssl/buffering.rb, line 196 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
Formats and writes to the stream converting parameters under control of the format string.
See Kernel#sprintf for format string details.
Writes args to the stream along with a record separator.
See IO#puts for full details.
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.
# File ../ruby/ext/openssl/lib/openssl/buffering.rb, line 83 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 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.
#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
endNote 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
# File ../ruby/ext/openssl/lib/openssl/buffering.rb, line 164 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 a line from the stream which is separated by eol.
Raises EOFError if at end of file.
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.
# File ../ruby/ext/openssl/lib/openssl/buffering.rb, line 110 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
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).
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.
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 #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
endNote 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
Consumes size bytes from the buffer
Writes s to the buffer. When the buffer is full or sync is true the buffer is
flushed to the underlying socket.
# File ../ruby/ext/openssl/lib/openssl/buffering.rb, line 307 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 nwritten = 0 while remain > 0 str = @wbuffer[nwritten,remain] begin nwrote = syswrite(str) rescue Errno::EAGAIN retry end remain -= nwrote nwritten += nwrote end @wbuffer[0,nwritten] = "" end end