модуль OpenSSL::Buffering

# File ext/openssl/lib/openssl/buffering.rb, line 434
def <<(s)
  do_write(s)
  self
end

Записывает s в поток. s будет преобразован в String с помощью .to_s метода.

# File ext/openssl/lib/openssl/buffering.rb, line 495
def close
  flush rescue nil
  sysclose
end

Закрывает SSLSocket и сбрасывает все не записанные данные.

# File ext/openssl/lib/openssl/buffering.rb, line 266
def each(eol=$/)
  while line = self.gets(eol)
    yield line
  end
end

Выполняет блок для каждой строки в потоке, где строки разделены eol.

См. также gets

# File ext/openssl/lib/openssl/buffering.rb, line 307
def each_byte # :yields: byte
  while c = getc
    yield(c.ord)
  end
end

Вызывает заданный блок один раз для каждого байта в потоке.

# File ext/openssl/lib/openssl/buffering.rb, line 338
def eof?
  fill_rbuff if !@eof && @rbuffer.empty?
  @eof && @rbuffer.empty?
end

Возвращает true, если поток находится в конце файла, что означает, что больше нет данных для чтения.

# File ext/openssl/lib/openssl/buffering.rb, line 483
def flush
  osync = @sync
  @sync = true
  do_write ""
  return self
ensure
  @sync = osync
end

Сбрасывает данные буфера в SSLSocket.

# File ext/openssl/lib/openssl/buffering.rb, line 106
def getbyte
  read(1)&.ord
end

Получает следующий байт 8 бит из ‘ssl`. Возвращает `nil` при EOF

# File ext/openssl/lib/openssl/buffering.rb, line 300
def getc
  read(1)
end

Читает один символ из потока. Возвращает nil, если вызвана в конце файла.

# File ext/openssl/lib/openssl/buffering.rb, line 238
def gets(eol=$/, limit=nil, chomp: false)
  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
  line = consume_rbuff(size)
  if chomp && line
    line.chomp!(eol)
  end
  line
end

Читает следующую “строку” из потока. Строки разделяются eol. Если limit указан, результат не будет длиннее заданного количества байт.

eol может быть String или Regexp.

В отличие от IO#gets, считанная строка не будет назначена +$_+.

В отличие от IO#gets, разделитель должен быть указан, если указан лимит.

# File ext/openssl/lib/openssl/buffering.rb, line 462
def print(*args)
  s = Buffer.new
  args.each{ |arg| s << arg.to_s }
  do_write(s)
  nil
end

Записывает args в поток.

См. IO#print для полных подробностей.

# File ext/openssl/lib/openssl/buffering.rb, line 475
def printf(s, *args)
  do_write(s % args)
  nil
end

Форматирует и записывает в поток, преобразуя параметры под управлением строки формата.

См. Kernel#sprintf для подробностей о строке формата.

# File ext/openssl/lib/openssl/buffering.rb, line 444
def puts(*args)
  s = Buffer.new
  if args.empty?
    s << "\n"
  end
  args.each{|arg|
    s << arg.to_s
    s.sub!(/(?<!\n)\z/, "\n")
  }
  do_write(s)
  nil
end

Записывает args в поток вместе с разделителем записи.

См. IO#puts для полных подробностей.

# File ext/openssl/lib/openssl/buffering.rb, line 122
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

Читает size байт из потока. Если buf указан, он должен ссылаться на строку, которая примет данные.

См. IO#read для полных подробностей.

# File ext/openssl/lib/openssl/buffering.rb, line 207
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

Читает не более maxlen байтов в неблокирующем режиме.

Если данные не могут быть прочитаны без блокировки, возникает исключение OpenSSL::SSL::SSLError, расширенное с помощью IO::WaitReadable или IO::WaitWritable.

IO::WaitReadable означает, что SSL необходимо выполнить внутреннее чтение, поэтому read_nonblock следует вызывать снова, когда нижележащий IO доступен для чтения.

IO::WaitWritable означает, что SSL необходимо выполнить внутреннюю запись, поэтому read_nonblock следует вызывать снова после того, как нижележащий IO станет доступен для записи.

OpenSSL::Buffering#read_nonblock требует два блока rescue следующим образом:

# 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

Обратите внимание, что одной из причин, по которой read_nonblock записывает в нижележащий IO, является запрос однорангового узла на новое рукопожатие TLS/SSL. Дополнительные сведения см. в часто задаваемых вопросах по OpenSSL. www.openssl.org/support/faq.html

Указав именованный аргумент exception для false, можно указать, что read_nonblock не должен генерировать исключение IO::Wait*able, а вместо этого возвращать символ :wait_writable или :wait_readable. В конце файла он вернет nil вместо генерации исключения EOFError.

# File ext/openssl/lib/openssl/buffering.rb, line 111
def readbyte
  raise EOFError if eof?
  getbyte
end

Получает следующий 8-битный байт. В конце файла генерирует исключение EOFError

# File ext/openssl/lib/openssl/buffering.rb, line 317
def readchar
  raise EOFError if eof?
  getc
end

Читает строку из одного символа из потока. В конце файла генерирует исключение EOFError.

# File ext/openssl/lib/openssl/buffering.rb, line 291
def readline(eol=$/)
  raise EOFError if eof?
  gets(eol)
end

Читает строку из потока, которая разделена eol.

Генерирует исключение EOFError в конце файла.

# File ext/openssl/lib/openssl/buffering.rb, line 278
def readlines(eol=$/)
  ary = []
  while line = self.gets(eol)
    ary << line
  end
  ary
end

Читает строки из потока, которые разделены eol.

См. также gets

# File ext/openssl/lib/openssl/buffering.rb, line 149
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
  ret
end

Читает не более maxlen байтов из потока. Если предоставлен buf, он должен ссылаться на строку, которая получит данные.

См. IO#readpartial для получения полной информации.

# File ext/openssl/lib/openssl/buffering.rb, line 330
def ungetc(c)
  @rbuffer[0,0] = c.chr
end

Возвращает символ c обратно в поток, так что последующее чтение буферизованного символа вернет его.

В отличие от IO#getc, несколько байтов могут быть возвращены обратно в поток.

Не оказывает влияния на небуферизованные чтения (например, sysread).

# File ext/openssl/lib/openssl/buffering.rb, line 381
def write(*s)
  s.inject(0) do |written, str|
    do_write(str)
    written + str.bytesize
  end
end

Записывает s в поток. Если аргумент не является String, он будет преобразован с помощью метода .to_s. Возвращает количество записанных байтов.

# File ext/openssl/lib/openssl/buffering.rb, line 425
def write_nonblock(s, exception: true)
  flush
  syswrite_nonblock(s, exception: exception)
end

Записывает s в неблокирующем режиме.

Если есть буферизованные данные, они сначала очищаются. Это может заблокировать.

write_nonblock возвращает количество байтов, записанных в соединение SSL.

Если данные не могут быть записаны без блокировки, возникает исключение OpenSSL::SSL::SSLError, расширенное с помощью IO::WaitReadable или IO::WaitWritable.

IO::WaitReadable означает, что SSL необходимо выполнить внутреннее чтение, поэтому write_nonblock следует вызывать снова после того, как нижележащий IO станет доступен для чтения.

IO::WaitWritable означает, что SSL необходимо выполнить внутреннюю запись, поэтому write_nonblock следует вызывать снова после того, как нижележащий IO станет доступен для записи.

Таким образом, OpenSSL::Buffering#write_nonblock требует два блока rescue следующим образом.

# 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

Обратите внимание, что одной из причин, по которой write_nonblock читает из нижележащего IO, является запрос однорангового узла на новое рукопожатие TLS/SSL. Дополнительные сведения см. в часто задаваемых вопросах по OpenSSL. www.openssl.org/support/faq.html

Указав именованный аргумент exception для false, можно указать, что write_nonblock не должен генерировать исключение IO::Wait*able, а вместо этого возвращать символ :wait_writable или :wait_readable.