Inline MemoryBIO into PMemoryBIO

Author: msimacek

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/objects/ssl/MemoryBIO.java

@@ -90,7 +90,7 @@ PMemoryBIO create(Object type) {
     abstract static class PendingNode extends PythonUnaryBuiltinNode {
         @Specialization
         static int getPending(PMemoryBIO self) {
-            return self.getBio().getPending();
+            return self.getPending();
         }
     }
 
@@ -99,7 +99,7 @@ static int getPending(PMemoryBIO self) {
     abstract static class EOFNode extends PythonUnaryBuiltinNode {
         @Specialization
         static boolean eof(PMemoryBIO self) {
-            return self.getBio().isEOF();
+            return self.isEOF();
         }
     }
 
@@ -110,7 +110,7 @@ abstract static class ReadNode extends PythonBinaryClinicBuiltinNode {
         @Specialization
         PBytes read(PMemoryBIO self, int size) {
             int len = size >= 0 ? size : Integer.MAX_VALUE;
-            return factory().createBytes(self.getBio().read(len));
+            return factory().createBytes(self.read(len));
         }
 
         @Override
@@ -125,13 +125,13 @@ abstract static class WriteNode extends PythonBinaryBuiltinNode {
         @Specialization(guards = "lib.isBuffer(buffer)", limit = "3")
         int write(PMemoryBIO self, Object buffer,
                         @CachedLibrary("buffer") PythonObjectLibrary lib) {
-            if (self.getBio().didWriteEOF()) {
+            if (self.didWriteEOF()) {
                 throw raise(SSLError, "cannot write() after write_eof()");
             }
             try {
                 byte[] bytes = lib.getBufferBytes(buffer);
                 int len = lib.getBufferLength(buffer);
-                self.getBio().write(bytes, len);
+                self.write(bytes, len);
                 return len;
             } catch (OverflowException e) {
                 throw raise(MemoryError);
@@ -152,7 +152,7 @@ Object error(Object self, Object arg) {
     abstract static class WriteEOFNode extends PythonUnaryBuiltinNode {
         @Specialization
         static PNone writeEOF(PMemoryBIO self) {
-            self.getBio().writeEOF();
+            self.writeEOF();
             return PNone.NONE;
         }
     }

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/objects/ssl/MemoryBIOBuiltins.java

@@ -40,20 +40,140 @@
  */
 package com.oracle.graal.python.builtins.objects.ssl;
 
+import java.nio.ByteBuffer;
+
 import com.oracle.graal.python.builtins.objects.object.PythonObject;
+import com.oracle.graal.python.util.OverflowException;
+import com.oracle.graal.python.util.PythonUtils;
 import com.oracle.truffle.api.object.Shape;
 
 /**
- * Python wrapper around {@link MemoryBIO} objects which emulate OpenSSL's BIO interface.
+ * Our rough equivalent of OpenSSL memory BIO objects used as buffers when performing SSL
+ * wrapping/unwrapping. They are similar to Java {@link ByteBuffer}, but they have a separate
+ * position for reading and writing.
  */
 public class PMemoryBIO extends PythonObject {
-    private final MemoryBIO bio = new MemoryBIO();
+
+    private byte[] bytes = new byte[0];
+    private int readPosition;
+    private int writePosition;
+    private boolean eofWritten;
 
     public PMemoryBIO(Object pythonClass, Shape instanceShape) {
         super(pythonClass, instanceShape);
     }
 
-    public MemoryBIO getBio() {
-        return bio;
+    /**
+     * Get number of bytes that can be read from this BIO.
+     */
+    public int getPending() {
+        return writePosition - readPosition;
+    }
+
+    /**
+     * Wrap into a {@link ByteBuffer} meant for reading the data of this BIO. It is necessary to
+     * call {@link #applyRead(ByteBuffer)} after performing the read to propagate the updated
+     * positions.
+     */
+    public ByteBuffer getBufferForReading() {
+        return ByteBuffer.wrap(bytes, readPosition, getPending());
+    }
+
+    /**
+     * Update read position from a buffer previously obtained using {@link #getBufferForReading()}
+     */
+    public void applyRead(ByteBuffer buffer) {
+        readPosition = buffer.position();
+        assert readPosition <= bytes.length;
+        assert readPosition <= writePosition;
+    }
+
+    /**
+     * Wrap into a {@link ByteBuffer} meant for writing the data into this BIO. It is necessary to
+     * call {@link #applyWrite(ByteBuffer)} after performing the read to propagate the updated
+     * positions.
+     *
+     * @see #ensureWriteCapacity(int)
+     */
+    public ByteBuffer getBufferForWriting() {
+        return ByteBuffer.wrap(bytes, writePosition, bytes.length - writePosition);
+    }
+
+    /**
+     * Update write position from a buffer previously obtained using {@link #getBufferForWriting()}
+     */
+    public void applyWrite(ByteBuffer buffer) {
+        writePosition = buffer.position();
+        assert writePosition <= bytes.length;
+        assert readPosition <= writePosition;
+    }
+
+    /**
+     * Make sure that at least {@code capacity} bytes can be written into this BIO. Disposes of the
+     * already read part of the buffer when applicable.
+     *
+     * @param capacity Required capacity in bytes
+     */
+    public void ensureWriteCapacity(int capacity) throws OverflowException {
+        if (bytes.length - writePosition < capacity) {
+            int pending = getPending();
+            if (bytes.length - pending < capacity) {
+                byte[] newBytes = new byte[PythonUtils.addExact(capacity, pending)];
+                PythonUtils.arraycopy(bytes, readPosition, newBytes, 0, pending);
+                bytes = newBytes;
+            } else {
+                PythonUtils.arraycopy(bytes, readPosition, bytes, 0, pending);
+            }
+            readPosition = 0;
+            writePosition = pending;
+        }
+    }
+
+    /**
+     * Read at most {@code lenght} bytes from this BIO into a byte array.
+     *
+     * @param length Maximum number of bytes to be read. Can be more than the actual size
+     * @return A new byte array with the read content. Can be empty if there is no data to be read.
+     */
+    public byte[] read(int length) {
+        int len = Math.min(length, getPending());
+        byte[] to = new byte[len];
+        PythonUtils.arraycopy(bytes, readPosition, to, 0, len);
+        readPosition += len;
+        return to;
+    }
+
+    /**
+     * Write entire bytearray into this BIO.
+     *
+     * @param from Data to be written
+     * @param length Lenght of data to be written
+     */
+    public void write(byte[] from, int length) throws OverflowException {
+        ensureWriteCapacity(length);
+        PythonUtils.arraycopy(from, 0, bytes, writePosition, Math.min(length, from.length));
+        writePosition += length;
+    }
+
+    public boolean didWriteEOF() {
+        return eofWritten;
+    }
+
+    /**
+     * Return if we reached an EOF marker.
+     */
+    public boolean isEOF() {
+        return eofWritten && getPending() == 0;
+    }
+
+    /**
+     * Write an EOF marker.
+     */
+    public void writeEOF() {
+        this.eofWritten = true;
+    }
+
+    public byte getByte(int offset) {
+        return bytes[readPosition + offset];
     }
 }