working on client ssl network

Author: JavaSaBr

rlib-logger-impl/src/main/java/com/ss/rlib/logger/impl/DefaultLoggerFactory.java

@@ -117,11 +117,7 @@ private void write(@NotNull LoggerLevel level, @NotNull String resultMessage) {
         listeners.forEachInReadLockR(resultMessage, LoggerListener::println);
         writers.forEachInReadLockR(resultMessage, DefaultLoggerFactory::append);
 
-        try {
-            System.err.write((resultMessage + "\n").getBytes());
-        } catch (IOException e) {
-            throw new RuntimeException(e);
-        }
+        System.err.println(resultMessage);
 
         if (!level.isForceFlush()) {
             return;

rlib-network/src/main/java/com/ss/rlib/network/packet/WritablePacket.java

@@ -1,7 +1,9 @@
 package com.ss.rlib.network.packet;
 
+import com.ss.rlib.logger.api.LoggerManager;
 import org.jetbrains.annotations.NotNull;
 
+import java.nio.BufferOverflowException;
 import java.nio.ByteBuffer;
 
 /**
@@ -105,10 +107,19 @@ default void writeShort(@NotNull ByteBuffer buffer, int value) {
      * @param string the string for writing.
      */
     default void writeString(@NotNull ByteBuffer buffer, @NotNull String string) {
-        writeInt(buffer, string.length());
+        try {
 
-        for (int i = 0, length = string.length(); i < length; i++) {
-            buffer.putChar(string.charAt(i));
+            writeInt(buffer, string.length());
+
+            for (int i = 0, length = string.length(); i < length; i++) {
+                buffer.putChar(string.charAt(i));
+            }
+
+        } catch (BufferOverflowException ex) {
+            LoggerManager.getLogger(WritablePacket.class)
+                .error("Cannot write a string to buffer because the string is too long." +
+                    " String length: " + string.length() + ", buffer: " + buffer);
+            throw ex;
         }
     }
 

rlib-network/src/main/java/com/ss/rlib/network/packet/impl/AbstractPacketReader.java

@@ -34,16 +34,16 @@ public abstract class AbstractPacketReader<R extends ReadablePacket, C extends C
 
     private static final Logger LOGGER = LoggerManager.getLogger(AbstractPacketReader.class);
 
-    private final CompletionHandler<Integer, Void> readHandler = new CompletionHandler<>() {
+    private final CompletionHandler<Integer, ByteBuffer> readHandler = new CompletionHandler<>() {
 
         @Override
-        public void completed(@NotNull Integer result, @Nullable Void attachment) {
-            handleReadData(result);
+        public void completed(@NotNull Integer receivedBytes, @NotNull ByteBuffer readingBuffer) {
+            handleReceivedData(receivedBytes, readingBuffer);
         }
 
         @Override
-        public void failed(@NotNull Throwable exc, @Nullable Void attachment) {
-            handleFailedRead(exc);
+        public void failed(@NotNull Throwable exc, @NotNull ByteBuffer readingBuffer) {
+            handleFailedReceiving(exc, readingBuffer);
         }
     };
 
@@ -96,7 +96,9 @@ public void startRead() {
 
         LOGGER.debug(channel, ch -> "Start waiting for new data from channel \"" + getRemoteAddress(ch) + "\"");
 
-        channel.read(getBufferToReadFromChannel(), null, readHandler);
+        var buffer = getBufferToReadFromChannel();
+
+        channel.read(buffer, buffer, readHandler);
     }
 
     /**
@@ -118,24 +120,24 @@ protected int readPackets(@NotNull ByteBuffer receivedBuffer) {
      */
     protected int readPackets(@NotNull ByteBuffer receivedBuffer, @NotNull ByteBuffer pendingBuffer) {
 
-        LOGGER.debug(receivedBuffer, buf -> "Start reading packets from received buffer: " + buf);
+        LOGGER.debug(receivedBuffer, buf -> "Start reading packets from received buffer " + buf);
 
         var waitedBytes = pendingBuffer.position();
         var bufferToRead = receivedBuffer;
         var tempPendingBuffer = getTempPendingBuffer();
 
-        // if we have read mapped buffer it means that we are reading a really big packet now
+        // if we have a temp buffer it means that we are reading a really big packet now
         if (tempPendingBuffer != null) {
 
             if (tempPendingBuffer.remaining() < receivedBuffer.remaining()) {
                 reAllocTempBuffers(tempPendingBuffer.flip(), tempPendingBuffer.capacity());
                 tempPendingBuffer = notNull(getTempPendingBuffer());
             }
 
-            LOGGER.debugNullable(
+            LOGGER.debug(
                 receivedBuffer,
                 tempPendingBuffer,
-                (buf, mappedBuf) -> "Put received buffer: " + buf + " to read mapped buffer: " + mappedBuf
+                (buf, mappedBuf) -> "Put received buffer " + buf + " to read mapped buffer " + mappedBuf
             );
 
             bufferToRead = BufferUtils.putToAndFlip(tempPendingBuffer, receivedBuffer);
@@ -149,8 +151,8 @@ else if (waitedBytes > 0) {
                 LOGGER.debug(
                     pendingBuffer,
                     receivedBuffer,
-                    (penBuf, buf) -> "Pending buffer: " + penBuf + " is too small to append received buffer: " +
-                        buf + ", allocate mapped buffer for this"
+                    (penBuf, buf) -> "Pending buffer " + penBuf + " is too small to append received buffer " +
+                        buf + ", will allocate new temp buffer for this"
                 );
 
                 allocTempBuffers(pendingBuffer.flip(), pendingBuffer.capacity());
@@ -264,23 +266,29 @@ else if (packetLength > tempPendingBuffer.capacity()) {
                 LOGGER.debug(
                     channel,
                     readPackets,
-                    (ch, count) -> "Read " + count + " packet(s) from buffered data of " + getRemoteAddress(ch) + ", " +
+                    (ch, count) -> "Read " + count + " packets from received buffer of " + getRemoteAddress(ch) + ", " +
                         "but 1 packet is still waiting for receiving additional data."
                 );
 
+                receivedBuffer.clear();
                 return readPackets;
             }
 
             R packet = createPacketFor(bufferToRead, positionBeforeRead, packetLength, dataLength);
 
             if (packet != null) {
                 LOGGER.debug(packet, pck -> "Created instance of packet to read data: " + pck);
-                packet.read(connection, bufferToRead, dataLength);
-                readPacketHandler.accept(packet);
-                LOGGER.debug(packet, pck -> "Read data of packet: " + pck);
+
+                if (packet.read(connection, bufferToRead, dataLength)) {
+                    readPacketHandler.accept(packet);
+                } else {
+                    LOGGER.error("Packet " + packet + " was read incorrectly");
+                }
+
+                LOGGER.debug(packet, pck -> "Finished reading data of packet: " + pck);
                 readPackets++;
             } else {
-                LOGGER.warning("Cannot create any instance of packet to read data.");
+                LOGGER.warning("Cannot create any instance of packet to read data");
             }
 
             bufferToRead.position(endPosition);
@@ -301,9 +309,13 @@ else if (packetLength > tempPendingBuffer.capacity()) {
             freeTempBuffers();
         }
 
-        LOGGER.debug(channel, readPackets,
-            (ch, count) -> "Read " + count + " packet(s) from buffered data of " + getRemoteAddress(ch) + ".");
+        LOGGER.debug(
+            channel,
+            readPackets,
+            (ch, count) -> "Read " + count + " packets from received buffer of " + getRemoteAddress(ch) + "."
+        );
 
+        receivedBuffer.clear();
         return readPackets;
     }
 
@@ -393,32 +405,30 @@ protected void freeTempBuffers() {
     }
 
     /**
-     * Handle read data.
+     * Handle received data.
      *
-     * @param result the count of read bytes.
+     * @param receivedBytes the count of received bytes.
+     * @param readingBuffer the currently reading buffer.
      */
-    protected void handleReadData(@NotNull Integer result) {
+    protected void handleReceivedData(@NotNull Integer receivedBytes, @NotNull ByteBuffer readingBuffer) {
         updateActivityFunction.run();
 
-        if (result == -1) {
+        if (receivedBytes == -1) {
             connection.close();
             return;
         }
 
         LOGGER.debug(
-            result,
+            receivedBytes,
             channel,
             (bytes, ch) -> "Received " + bytes + " bytes from channel \"" + NetworkUtils.getRemoteAddress(ch) + "\""
         );
 
-        var readBuffer = getBufferToReadFromChannel();
-        readBuffer.flip();
+        readingBuffer.flip();
         try {
-            readPackets(readBuffer);
+            readPackets(readingBuffer);
         } catch (Exception e) {
             LOGGER.error(e);
-        } finally {
-            readBuffer.clear();
         }
 
         if (isReading.compareAndSet(true, false)) {
@@ -427,13 +437,14 @@ protected void handleReadData(@NotNull Integer result) {
     }
 
     /**
-     * Handle the exception during reading data.
+     * Handle the exception during receiving data.
      *
-     * @param exception the exception.
+     * @param exception     the exception.
+     * @param readingBuffer the currently reading buffer.
      */
-    protected void handleFailedRead(@NotNull Throwable exception) {
+    protected void handleFailedReceiving(@NotNull Throwable exception, @NotNull ByteBuffer readingBuffer) {
         if (exception instanceof AsynchronousCloseException) {
-            LOGGER.warning(connection, cn -> "Connection " + cn.getRemoteAddress() + " was closed.");
+            LOGGER.info(connection, cn -> "Connection " + cn.getRemoteAddress() + " was closed.");
         } else {
             LOGGER.error(exception);
             connection.close();

rlib-network/src/main/java/com/ss/rlib/network/packet/impl/AbstractPacketWriter.java

@@ -99,7 +99,8 @@ public void writeNextPacket() {
         if (resultBuffer.limit() != 0) {
             writingBuffer = resultBuffer;
 
-            LOGGER.debug(channel,
+            LOGGER.debug(
+                channel,
                 resultBuffer,
                 (ch, buf) -> "Write to channel \"" + getRemoteAddress(ch) + "\" data:\n" + hexDump(buf)
             );
@@ -121,13 +122,15 @@ public void writeNextPacket() {
         W resultPacket = (W) packet;
 
         var expectedLength = packet.getExpectedLength();
-        var totalSize = getTotalSize(packet, expectedLength);
+        var totalSize = expectedLength == -1 ? -1 : getTotalSize(packet, expectedLength);
 
         // if the packet is too big to use a write buffer
         if (expectedLength != -1 && totalSize > firstWriteBuffer.capacity()) {
-            firstWriteTempBuffer = bufferAllocator.takeBuffer(totalSize);
-            secondWriteTempBuffer = bufferAllocator.takeBuffer(totalSize);
-            return serialize(resultPacket, expectedLength, totalSize, firstWriteTempBuffer, secondWriteTempBuffer);
+            var first = bufferAllocator.takeBuffer(totalSize);
+            var second = bufferAllocator.takeBuffer(totalSize);
+            firstWriteTempBuffer = first;
+            secondWriteTempBuffer = second;
+            return serialize(resultPacket, expectedLength, totalSize, first, second);
         } else {
             return serialize(resultPacket, expectedLength, totalSize, firstWriteBuffer, secondWriteBuffer);
         }
@@ -254,22 +257,29 @@ protected boolean onAfterWrite(
     }
 
     protected @NotNull ByteBuffer writeHeader(@NotNull ByteBuffer buffer, int position, int value, int headerSize) {
+        try {
+
+            switch (headerSize) {
+                case 1:
+                    buffer.put(position, (byte) value);
+                    break;
+                case 2:
+                    buffer.putShort(position, (short) value);
+                    break;
+                case 4:
+                    buffer.putInt(position, value);
+                    break;
+                default:
+                    throw new IllegalStateException("Wrong packet's header size: " + headerSize);
+            }
 
-        switch (headerSize) {
-            case 1:
-                buffer.put(position, (byte) value);
-                break;
-            case 2:
-                buffer.putShort(position, (short) value);
-                break;
-            case 4:
-                buffer.putInt(position, value);
-                break;
-            default:
-                throw new IllegalStateException("Wrong packet's header size: " + headerSize);
-        }
+            return buffer;
 
-        return buffer;
+        } catch (IndexOutOfBoundsException ex) {
+            LOGGER.error("Cannot write header by position " + position + " with header size " + headerSize +
+                " to buffer " + buffer);
+            throw ex;
+        }
     }
 
     protected @NotNull ByteBuffer writeHeader(@NotNull ByteBuffer buffer, int value, int headerSize) {

rlib-network/src/main/java/com/ss/rlib/network/packet/impl/AbstractReadablePacket.java

@@ -7,6 +7,7 @@
 import lombok.NoArgsConstructor;
 import org.jetbrains.annotations.NotNull;
 
+import java.nio.BufferUnderflowException;
 import java.nio.ByteBuffer;
 
 /**
@@ -133,12 +134,29 @@ protected int readShort(@NotNull ByteBuffer buffer) {
     protected @NotNull String readString(@NotNull ByteBuffer buffer) {
 
         var length = readInt(buffer);
-        var array = new char[length];
+        try {
 
-        for (int i = 0; i < length; i++) {
-            array[i] = buffer.getChar();
-        }
+            var requiredRemainingBytes = length * 2;
+
+            if (requiredRemainingBytes > buffer.remaining()) {
+                throw new IllegalStateException("Found too long string " + length + " from buffer " + buffer);
+            }
+
+            var array = new char[length];
 
-        return new String(array);
+            for (int i = 0; i < length; i++) {
+                array[i] = buffer.getChar();
+            }
+
+            return new String(array);
+
+        } catch (OutOfMemoryError ex) {
+            LOGGER.error("Cannot read too long \"" + length + "\" string by memory reason");
+            throw ex;
+        } catch (BufferUnderflowException ex) {
+            LOGGER.error("Cannot read string because buffer doesn't contains enough data. " +
+                "Expected string length " + length + ", buffer " + buffer);
+            throw ex;
+        }
     }
 }

rlib-network/src/main/java/com/ss/rlib/network/packet/impl/AbstractSSLPacketReader.java

@@ -64,14 +64,14 @@ protected AbstractSSLPacketReader(
     }
 
     @Override
-    protected void handleReadData(@NotNull Integer result) {
+    protected void handleReceivedData(@NotNull Integer receivedBytes, @NotNull ByteBuffer readingBuffer) {
 
-        if (result == -1) {
-            doHandshake(getBufferToReadFromChannel(), -1);
+        if (receivedBytes == -1) {
+            doHandshake(readingBuffer, -1);
             return;
         }
 
-        super.handleReadData(result);
+        super.handleReceivedData(receivedBytes, readingBuffer);
     }
 
     @Override
@@ -209,10 +209,7 @@ protected int decryptAndRead(@NotNull ByteBuffer receivedBuffer) {
                 LOGGER.debug(receivedBuffer, buf -> "Try to decrypt data:\n" + hexDump(buf));
                 result = sslEngine.unwrap(receivedBuffer, sslDataBuffer.clear());
             } catch (SSLException e) {
-                if (e.getCause() instanceof BadPaddingException) {
-                    increaseNetworkBuffer();
-                    return SKIP_READ_PACKETS;
-                }
+                var handshakeStatus = sslEngine.getHandshakeStatus();
                 throw new IllegalStateException(e);
             }
 
@@ -229,10 +226,18 @@ protected int decryptAndRead(@NotNull ByteBuffer receivedBuffer) {
                     closeConnection();
                     return SKIP_READ_PACKETS;
                 default:
+
+                    if (receivedBuffer.position() > 0) {
+                        receivedBuffer.compact();
+                        return total;
+                    }
+
                     throw new IllegalStateException("Invalid SSL status: " + result.getStatus());
             }
         }
 
+        receivedBuffer.clear();
+
         return total;
     }