modul OpenSSL::Buffering

OpenSSL IO Pufferungs-Mixin-Modul.

Dieses Modul ermöglicht es einem OpenSSL::SSL::SSLSocket, sich wie eine IO zu verhalten.

Sie werden dieses Modul normalerweise nicht direkt verwenden, es ist in OpenSSL::SSL::SSLSocket implementiert.

Constants

BLOCK_SIZE: Standardgröße zum Lesen von oder Schreiben in den SSLSocket für Pufferoperationen.

Attribute

sync [RW]

Der "Sync-Modus" des SSLSocket.

Siehe IO#sync für vollständige Details.

Öffentliche Klassenmethoden

new (*)

Source

# File ext/openssl/lib/openssl/buffering.rb, line 59
def initialize(*)
  super
  @eof = false
  @rbuffer = Buffer.new
  @sync = @io.sync
end

Erstellt eine Instanz des OpenSSL-Pufferungs- IO Moduls.

Ruft die Methode der Superklasse auf

Öffentliche Instanzmethoden

<< (s)

Source

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

Schreibt s in den Stream. s wird mit der Methode .to_s in einen String konvertiert.

close ()

Source

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

Schließt den SSLSocket und leert alle ungeschriebenen Daten.

each (eol=$/) { |line| ... }

Source

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

Führt den Block für jede Zeile im Stream aus, wobei Zeilen durch eol getrennt sind.

Siehe auch gets

Auch als Alias: each_line

each_byte () { |byte| ... }

Source

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

Ruft den gegebenen Block einmal für jedes Byte im Stream auf.

each_line (eol=$/)

Alias für: each

eof ()

Alias für: eof?

eof? ()

Source

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

Gibt true zurück, wenn der Stream am Ende ist, d.h. keine weiteren Daten zu lesen sind.

Auch als Alias: eof

flush ()

Source

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

Spült gepufferte Daten zum SSLSocket.

getbyte → 81

Source

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

Holt das nächste 8-Bit-Byte von ‘ssl`. Gibt `nil` bei EOF zurück.

getc ()

Source

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

Liest ein Zeichen aus dem Stream. Gibt nil zurück, wenn am Dateiende aufgerufen.

gets (eol=$/, limit=nil, chomp: false)

Source

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

Liest die nächste "Zeile" aus dem Stream. Zeilen werden durch eol getrennt. Wenn limit angegeben ist, ist das Ergebnis nicht länger als die angegebene Anzahl von Bytes.

eol kann ein String oder ein Regexp sein.

Im Gegensatz zu IO#gets wird die gelesene Zeile nicht an +$_+ zugewiesen.

Im Gegensatz zu IO#gets muss der Separator angegeben werden, wenn ein Limit vorhanden ist.

print (*args)

Source

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

Schreibt args in den Stream.

Siehe IO#print für vollständige Details.

printf (s, *args)

Source

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

Formatiert und schreibt in den Stream, wobei die Parameter gemäß der Formatierungszeichenfolge konvertiert werden.

Siehe Kernel#sprintf für Details zur Formatierungszeichenfolge.

puts (*args)

Source

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

Schreibt args in den Stream zusammen mit einem Aufzeichnungsseparator.

Siehe IO#puts für vollständige Details.

read (size=nil, buf=nil)

Source

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

Liest size Bytes aus dem Stream. Wenn buf angegeben ist, muss es sich auf einen String beziehen, der die Daten empfängt.

Siehe IO#read für vollständige Details.

read_nonblock (maxlen, buf=nil, exception: true)

Source

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

Liest maximal maxlen Bytes im nicht-blockierenden Modus.

Wenn keine Daten ohne Blockieren gelesen werden können, löst es eine OpenSSL::SSL::SSLError aus, die von IO::WaitReadable oder IO::WaitWritable erweitert wird.

IO::WaitReadable bedeutet, dass SSL intern lesen muss, daher sollte read_nonblock erneut aufgerufen werden, wenn die zugrunde liegende IO lesbar ist.

IO::WaitWritable bedeutet, dass SSL intern schreiben muss, daher sollte read_nonblock erneut aufgerufen werden, nachdem die zugrunde liegende IO schreibbar ist.

OpenSSL::Buffering#read_nonblock benötigt zwei Rettungsabschnitte wie folgt:

# 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

Beachten Sie, dass ein Grund, warum read_nonblock in die zugrunde liegende IO schreibt, darin besteht, dass der Peer eine neue TLS/SSL-Handshake anfordert. Weitere Details finden Sie in den OpenSSL-FAQs. www.openssl.org/support/faq.html

Durch Angabe eines Schlüsselwortarguments exception mit false können Sie angeben, dass read_nonblock keine IO::Wait*-Ausnahme auslösen soll, sondern stattdessen das Symbol :wait_writable oder :wait_readable zurückgeben soll. Bei EOF gibt es stattdessen nil zurück, anstatt EOFError auszulösen.

readbyte ()

Source

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

Holt das nächste 8-Bit-Byte. Löst EOFError bei EOF aus.

readchar ()

Source

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

Liest einen Ein-Zeichen-String aus dem Stream. Löst eine EOFError am Dateiende aus.

readline (eol=$/)

Source

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

Liest eine Zeile aus dem Stream, die durch eol getrennt ist.

Löst EOFError aus, wenn am Dateiende.

readlines (eol=$/)

Source

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

Liest Zeilen aus dem Stream, die durch eol getrennt sind.

Siehe auch gets

readpartial (maxlen, buf=nil)

Source

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

Liest maximal maxlen Bytes aus dem Stream. Wenn buf angegeben ist, muss es sich auf einen String beziehen, der die Daten empfängt.

Siehe IO#readpartial für vollständige Details.

ungetc (c)

Source

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

Drückt das Zeichen c zurück in den Stream, so dass eine nachfolgende gepufferte Zeichenlesung es zurückgibt.

Im Gegensatz zu IO#getc können mehrere Bytes zurück in den Stream gedrückt werden.

Hat keine Auswirkung auf ungepufferte Lesevorgänge (wie sysread).

write (*s)

Source

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

Schreibt s in den Stream. Wenn das Argument kein String ist, wird es mit der Methode .to_s konvertiert. Gibt die Anzahl der geschriebenen Bytes zurück.

write_nonblock (s, exception: true)

Source

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

Schreibt s im nicht-blockierenden Modus.

Wenn gepufferte Daten vorhanden sind, werden diese zuerst geleert. Dies kann blockieren.

write_nonblock gibt die Anzahl der Bytes zurück, die in die SSL-Verbindung geschrieben wurden.

Wenn keine Daten ohne Blockieren geschrieben werden können, löst es eine OpenSSL::SSL::SSLError aus, die von IO::WaitReadable oder IO::WaitWritable erweitert wird.

IO::WaitReadable bedeutet, dass SSL intern lesen muss, daher sollte write_nonblock erneut aufgerufen werden, nachdem die zugrunde liegende IO lesbar ist.

IO::WaitWritable bedeutet, dass SSL intern schreiben muss, daher sollte write_nonblock erneut aufgerufen werden, nachdem die zugrunde liegende IO schreibbar ist.

Daher benötigt OpenSSL::Buffering#write_nonblock zwei Rettungsabschnitte wie folgt.

# 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

Beachten Sie, dass ein Grund, warum write_nonblock aus der zugrunde liegenden IO liest, darin besteht, dass der Peer eine neue TLS/SSL-Handshake anfordert. Weitere Details finden Sie in den OpenSSL-FAQs. www.openssl.org/support/faq.html

Durch Angabe eines Schlüsselwortarguments exception mit false können Sie angeben, dass write_nonblock keine IO::Wait*-Ausnahme auslösen soll, sondern stattdessen das Symbol :wait_writable oder :wait_readable zurückgeben soll.

Private Instanzmethoden

consume_rbuff (size=nil)

Source

# File ext/openssl/lib/openssl/buffering.rb, line 87
def consume_rbuff(size=nil)
  if @rbuffer.empty?
    nil
  else
    size = @rbuffer.size unless size
    @rbuffer.slice!(0, size)
  end
end

Verbraucht size Bytes aus dem Puffer.

do_write (s)

Source

# File ext/openssl/lib/openssl/buffering.rb, line 349
def do_write(s)
  @wbuffer = Buffer.new unless defined? @wbuffer
  @wbuffer.append_as_bytes(s)

  @sync ||= false
  buffer_size = @wbuffer.bytesize
  if @sync or buffer_size > BLOCK_SIZE
    nwrote = 0
    begin
      while nwrote < buffer_size do
        begin
          chunk = if nwrote > 0
            @wbuffer.byteslice(nwrote, @wbuffer.bytesize)
          else
            @wbuffer
          end

          nwrote += syswrite(chunk)
        rescue Errno::EAGAIN
          retry
        end
      end
    ensure
      if nwrote < @wbuffer.bytesize
        @wbuffer[0, nwrote] = ""
      else
        @wbuffer.clear
      end
    end
  end
end

Schreibt s in den Puffer. Wenn der Puffer voll ist oder sync true ist, wird der Puffer an den zugrunde liegenden Socket gesendet.

fill_rbuff ()

Source

# File ext/openssl/lib/openssl/buffering.rb, line 74
def fill_rbuff
  begin
    @rbuffer.append_as_bytes(self.sysread(BLOCK_SIZE))
  rescue Errno::EAGAIN
    retry
  rescue EOFError
    @eof = true
  end
end

Füllt den Puffer aus dem zugrunde liegenden SSLSocket.