feat: fetch upstream & bump to 3.0.9

Author: smartcmd

README.md

@@ -17,7 +17,7 @@ An Named Binary Tag library built including VarInt support introduced by Minecra
     <dependency>
         <groupId>com.github.AllayMC</groupId>
         <artifactId>NBT</artifactId>
-        <version>3.0.8</version>
+        <version>3.0.9</version>
     </dependency>
 </dependencies>
 ```

gradle.properties

@@ -1 +1 @@
-version=3.0.8
+version=3.0.9

src/main/java/org/cloudburstmc/nbt/NBTInputStream.java

@@ -1,5 +1,7 @@
 package org.cloudburstmc.nbt;
 
+import org.cloudburstmc.nbt.util.stream.LimitedDataInput;
+
 import java.io.Closeable;
 import java.io.DataInput;
 import java.io.IOException;
@@ -9,6 +11,7 @@
 import java.util.Objects;
 
 import static org.cloudburstmc.nbt.NbtUtils.MAX_DEPTH;
+import static org.cloudburstmc.nbt.NbtUtils.MAX_READ_SIZE;
 
 public class NBTInputStream implements Closeable {
     private final DataInput input;
@@ -17,7 +20,16 @@ public class NBTInputStream implements Closeable {
     private boolean closed = false;
 
     public NBTInputStream(DataInput input, boolean internKeys, boolean internValues) {
-        this.input = Objects.requireNonNull(input, "input");
+        this(input, internKeys, internValues, MAX_READ_SIZE);
+    }
+
+    public NBTInputStream(DataInput input, boolean internKeys, boolean internValues, long maxReadSize) {
+        Objects.requireNonNull(input, "input");
+        if (input instanceof LimitedDataInput) {
+            this.input = input;
+        } else {
+            this.input = new LimitedDataInput(input, maxReadSize);
+        }
         this.internKeys = internKeys;
         this.internValues = internValues;
     }
@@ -26,6 +38,10 @@ public NBTInputStream(DataInput input) {
         this(input, false, false);
     }
 
+    public NBTInputStream(DataInput input, long maxReadSize) {
+        this(input, false, false, maxReadSize);
+    }
+
     public Object readTag() throws IOException {
         return readTag(MAX_DEPTH);
     }

src/main/java/org/cloudburstmc/nbt/NbtUtils.java

@@ -22,43 +22,76 @@
 
 public class NbtUtils {
     public static final int MAX_DEPTH = 16;
+    public static final long MAX_READ_SIZE = 0; // Disabled by default
 
     private NbtUtils() {
     }
 
     public static NBTInputStream createReader(InputStream stream, boolean internKeys, boolean internValues) {
+        return createReader(stream, internKeys, internValues, MAX_READ_SIZE);
+    }
+
+    public static NBTInputStream createReader(InputStream stream, boolean internKeys, boolean internValues, long maxReadSize) {
         requireNonNull(stream, "stream");
-        return new NBTInputStream(new DataInputStream(stream), internKeys, internValues);
+        return new NBTInputStream(new DataInputStream(stream), internKeys, internValues, maxReadSize);
     }
 
     public static NBTInputStream createReaderLE(InputStream stream, boolean internKeys, boolean internValues) {
+        return createReaderLE(stream, internKeys, internValues, MAX_READ_SIZE);
+    }
+
+    public static NBTInputStream createReaderLE(InputStream stream, boolean internKeys, boolean internValues, long maxReadSize) {
         requireNonNull(stream, "stream");
-        return new NBTInputStream(new LittleEndianDataInputStream(stream), internKeys, internValues);
+        return new NBTInputStream(new LittleEndianDataInputStream(stream, maxReadSize), internKeys, internValues);
     }
 
     public static NBTInputStream createGZIPReader(InputStream stream, boolean internKeys, boolean internValues) throws IOException {
-        return createReader(new GZIPInputStream(stream), internKeys, internValues);
+        return createGZIPReader(stream, internKeys, internValues, MAX_READ_SIZE);
+    }
+
+    public static NBTInputStream createGZIPReader(InputStream stream, boolean internKeys, boolean internValues, long maxReadSize) throws IOException {
+        return createReader(new GZIPInputStream(stream), internKeys, internValues, maxReadSize);
     }
 
     public static NBTInputStream createNetworkReader(InputStream stream, boolean internKeys, boolean internValues) {
+        return createNetworkReader(stream, internKeys, internValues, MAX_READ_SIZE);
+    }
+    
+    public static NBTInputStream createNetworkReader(InputStream stream, boolean internKeys, boolean internValues, long maxReadSize) {
         requireNonNull(stream, "stream");
-        return new NBTInputStream(new NetworkDataInputStream(stream), internKeys, internValues);
+        return new NBTInputStream(new NetworkDataInputStream(stream, maxReadSize), internKeys, internValues);
     }
 
     public static NBTInputStream createReader(InputStream stream) {
-        return createReader(stream, false, false);
+        return createReader(stream, MAX_READ_SIZE);
+    }
+    
+    public static NBTInputStream createReader(InputStream stream, long maxReadSize) {
+        return createReader(stream, false, false, maxReadSize);
     }
 
     public static NBTInputStream createReaderLE(InputStream stream) {
-        return createReaderLE(stream, false, false);
+        return createReaderLE(stream, MAX_READ_SIZE);
+    }
+    
+    public static NBTInputStream createReaderLE(InputStream stream, long maxReadSize) {
+        return createReaderLE(stream, false, false, maxReadSize);
     }
 
     public static NBTInputStream createGZIPReader(InputStream stream) throws IOException {
-        return createGZIPReader(stream, false, false);
+        return createGZIPReader(stream, MAX_READ_SIZE);
+    }
+
+    public static NBTInputStream createGZIPReader(InputStream stream, long maxReadSize) throws IOException {
+        return createGZIPReader(stream, false, false, maxReadSize);
     }
 
     public static NBTInputStream createNetworkReader(InputStream stream) {
-        return createNetworkReader(stream, false, false);
+        return createNetworkReader(stream, MAX_READ_SIZE);
+    }
+
+    public static NBTInputStream createNetworkReader(InputStream stream, long maxReadSize) {
+        return createNetworkReader(stream, false, false, maxReadSize);
     }
 
     public static NBTOutputStream createWriter(OutputStream stream) {

src/main/java/org/cloudburstmc/nbt/util/stream/LimitedDataInput.java

@@ -0,0 +1,134 @@
+package org.cloudburstmc.nbt.util.stream;
+
+import org.cloudburstmc.nbt.NbtUtils;
+
+import java.io.Closeable;
+import java.io.DataInput;
+import java.io.IOException;
+
+public class LimitedDataInput implements DataInput, Closeable {
+
+    private final DataInput delegate;
+    private final long maxReadSize;
+
+    private long readSize = 0;
+
+    public LimitedDataInput(DataInput delegate) {
+        this(delegate, NbtUtils.MAX_READ_SIZE);
+    }
+
+    public LimitedDataInput(DataInput delegate, long maxReadSize) {
+        this.delegate = delegate;
+        this.maxReadSize = maxReadSize;
+    }
+
+    @Override
+    public void close() throws IOException {
+        if (delegate instanceof Closeable) {
+            ((Closeable) delegate).close();
+        }
+    }
+
+    protected void tryRead(int size) throws IOException {
+        this.readSize += size;
+        if (this.maxReadSize > 0 && this.readSize > this.maxReadSize) {
+            throw new IOException("Read size exceeded limit: read=" + this.readSize + ", limit=" + this.maxReadSize);
+        }
+    }
+
+    @Override
+    public void readFully(byte[] b) throws IOException {
+        this.tryRead(b.length);
+        this.delegate.readFully(b);
+    }
+
+    @Override
+    public void readFully(byte[] b, int off, int len) throws IOException {
+        this.tryRead(len);
+        this.delegate.readFully(b, off, len);
+    }
+
+    @Override
+    public int skipBytes(int n) throws IOException {
+        this.tryRead(n);
+        return this.delegate.skipBytes(n);
+    }
+
+    @Override
+    public boolean readBoolean() throws IOException {
+        this.tryRead(1);
+        return this.delegate.readBoolean();
+    }
+
+    @Override
+    public byte readByte() throws IOException {
+        this.tryRead(1);
+        return this.delegate.readByte();
+    }
+
+    @Override
+    public int readUnsignedByte() throws IOException {
+        this.tryRead(1);
+        return this.delegate.readUnsignedByte();
+    }
+
+    @Override
+    public short readShort() throws IOException {
+        this.tryRead(2);
+        return this.delegate.readShort();
+    }
+
+    @Override
+    public int readUnsignedShort() throws IOException {
+        this.tryRead(2);
+        return this.delegate.readUnsignedShort();
+    }
+
+    @Override
+    public char readChar() throws IOException {
+        this.tryRead(2);
+        return this.delegate.readChar();
+    }
+
+    @Override
+    public int readInt() throws IOException {
+        this.tryRead(4);
+        return this.delegate.readInt();
+    }
+
+    @Override
+    public long readLong() throws IOException {
+        this.tryRead(8);
+        return this.delegate.readLong();
+    }
+
+    @Override
+    public float readFloat() throws IOException {
+        this.tryRead(4);
+        return this.delegate.readFloat();
+    }
+
+    @Override
+    public double readDouble() throws IOException {
+        this.tryRead(8);
+        return this.delegate.readDouble();
+    }
+
+    @Override
+    public String readLine() throws IOException {
+        String line =  this.delegate.readLine();
+        this.tryRead(line.length()); // not ideal, but we do not have a better way to estimate the size
+        return line;
+    }
+
+    @Override
+    public String readUTF() throws IOException {
+        String utf = this.delegate.readUTF();
+        this.tryRead(utf.length()); // not ideal, but we do not have a better way to estimate the size
+        return utf;
+    }
+
+    public DataInput delegate() {
+        return this.delegate;
+    }
+}