SSL hang / timeout fix

This fixes ssl, which can be seen using litesockets-http-client when using https.  The behavior would be the start of the handshake which would eventually hang.
This regression was introduced in this PR: #71
The specific flaw was introduced when the .duplicate() was removed here: https://github.com/threadly/litesockets/pull/71/files#diff-851d3597731b2cecc83331ede7aec7ebL143

It seems for SSL to work correctly we need to make sure that the MergedByteBuffer does not work against the original ByteBuffer that was originally passed in.
This fixes that behavior by making sure that when ByteBuffers are added (or provided at construction), we do this .duplicate() then.  This way when buffers are leaving the MergedByteBuffer we know it already has an independent experience from the one provided initially.  The goal being that by having this duplicate action happen at a consistent point will make this safer.
Overall I don't think we really add any .duplicate() actions, if anything at times we might have less.  With it happening at the start we can safely avoid duplicate calls at other points we had them previously.

Author: jentfoo

gradle.properties

@@ -1,3 +1,3 @@
 group = org.threadly
 version = 4.13
-threadlyVersion = 5.41
+threadlyVersion = 5.42

src/main/java/org/threadly/litesockets/buffers/AbstractMergedByteBuffers.java

@@ -58,20 +58,15 @@ public void add(final byte[] ...bas) {
   @Override
   public void add(final ByteBuffer ...buffers) {
     for(ByteBuffer buffer: buffers) {
-      if(buffer.hasRemaining()) {
-        doAppend(buffer.duplicate());
-      }
+      doAppend(buffer);
     }
   }
 
   @Override
   public void add(final MergedByteBuffers ...mbbs) {
     for(MergedByteBuffers mbb: mbbs) {
       while(mbb.hasRemaining()) {
-        ByteBuffer bb = mbb.popBuffer();
-        if(bb.hasRemaining()) {
-          doAppend(bb);
-        }
+        doAppend(mbb.popBuffer());
       }
     }
   }

src/main/java/org/threadly/litesockets/buffers/ReuseableMergedByteBuffers.java

@@ -39,15 +39,17 @@ public ReuseableMergedByteBuffers(boolean readOnly, ByteBuffer ...bbs) {
 
   @Override
   protected void doAppend(final ByteBuffer bb) {
-    availableBuffers.add(bb);
-    currentSize+=bb.remaining();
+    if (bb.hasRemaining()) {
+      availableBuffers.add(bb.duplicate());
+      currentSize+=bb.remaining();
+    }
   }
 
   @Override
   public ReuseableMergedByteBuffers duplicate() {
     final ReuseableMergedByteBuffers mbb  = new ReuseableMergedByteBuffers(markReadOnly);
     for(final ByteBuffer bb: this.availableBuffers) {
-      mbb.add(bb.duplicate());
+      mbb.doAppend(bb);
     }
     return mbb;
   }
@@ -61,7 +63,7 @@ public ReuseableMergedByteBuffers duplicateAndClean() {
 
   @Override
   protected void addToFront(ByteBuffer bb) {
-    this.availableBuffers.addFirst(bb.duplicate());
+    this.availableBuffers.addFirst(bb);
     this.currentSize+=bb.remaining();
   }
 

src/main/java/org/threadly/litesockets/buffers/SimpleMergedByteBuffers.java

@@ -14,17 +14,18 @@
 public class SimpleMergedByteBuffers extends AbstractMergedByteBuffers {
   private static final ByteBuffer[] EMPTY_BUFFER_ARRAY = new ByteBuffer[] {};
 
-  
   private final ByteBuffer[] bba;
   private int currentBuffer = 0;
   protected long consumedSize = 0;
 
   public SimpleMergedByteBuffers(boolean readOnly, ByteBuffer ...bbs) {
     super(readOnly);
-    for(ByteBuffer bb: bbs) {
-      if(bb == null) {
+    
+    for (int i = 0; i < bbs.length; i++) {
+      if(bbs[i] == null) {
         throw new IllegalArgumentException("Can not add null buffers!");
       }
+      bbs[i] = bbs[i].duplicate();
     }
     if(bbs.length > 0) {
       bba = bbs;
@@ -50,10 +51,6 @@ public SimpleMergedByteBuffers(boolean readOnly, SimpleMergedByteBuffers smbb, B
     }
   }
 
-  private void doGet(final byte[] destBytes) {
-    doGet(destBytes, 0, destBytes.length);
-  }
-  
   private void doGet(final byte[] destBytes, int start, int len) {
     int remainingToCopy = len;
 
@@ -88,7 +85,7 @@ protected void addToFront(ByteBuffer bb) {
   public SimpleMergedByteBuffers duplicate() {
     ByteBuffer[] bba2 = new ByteBuffer[bba.length-currentBuffer];
     for(int i=currentBuffer; i<bba.length; i++) {
-      bba2[i-currentBuffer] = bba[i].duplicate();
+      bba2[i-currentBuffer] = bba[i];
     }
     return new SimpleMergedByteBuffers(markReadOnly, bba2);
   }
@@ -97,7 +94,7 @@ public SimpleMergedByteBuffers duplicate() {
   public SimpleMergedByteBuffers duplicateAndClean() {
     SimpleMergedByteBuffers smbb = duplicate();
     currentBuffer = bba.length;
-    for(int i=0; i<bba.length; i++) {
+    for(int i=currentBuffer; i<bba.length; i++) {
       bba[i] = null;
     }
     return smbb;
@@ -170,15 +167,15 @@ public ByteBuffer pullBuffer(int size) {
     final ByteBuffer first = getNextBuffer();
     if(first.remaining() == size) {
       currentBuffer++;
-      return first.duplicate();
+      return first;
     } else if(first.remaining() > size) {
       final ByteBuffer bb = first.duplicate();
       bb.limit(bb.position()+size);
       first.position(first.position()+size);
       return bb;
     } else {
       final byte[] result = new byte[size];
-      doGet(result);
+      doGet(result, 0, size);
       return ByteBuffer.wrap(result);
     }
   }