java JarEntry getSize() returns -1

EDIT 3

It turns out some jar files will properly report entry.getSize() with JarStreamInput and some don't. All the jar files I created going back to 2013 (on OSX Java 8 and higher) work and various others like mongo-spark-connector-10.0.0.jar work. Others like antlr-runtime-4.7.2.jar, mongodb-driver-core-4.9.0.jar, and hadoop-azure-3.2.0.jar do not. But all files properly report size when accessed via JarFile.

I have a valid JarInputStream js sourced from a database (i.e. not using files on filesystem). In case there are some nuances to byte[], streams, and unzipping, this is how the JarInputStream is set up:

byte[] bb = get complete set of bytes; // print bb.length is 14523 so OK
ByteArrayInputStream bas = new ByteArrayInputStream(bb);
JarInputStream js = new JarInputStream(bas);

I iterate it in this way:

        JarEntry entry;
while ((entry = js.getNextJarEntry()) != null) {
if (!entry.isDirectory() && entry.getName().endsWith(".class")) {
String className = entry.getName().replace('/', '.').substring(0, entry\
.getName().length() - 6);
long len = entry.getSize();
long zlen = entry.getCompressedSize();
System.out.println("  class [" + className + "]: Z " + zlen + "; unZ " + len);
if(len > 0) {
byte[] classBytes = new byte[len];
js.read(classBytes);
System.out.println("captured [" + className + "]");
classBytesMap.put(className, classBytes);
}
...

The loop "works" because it correctly pulls all the class names out so it is clearly walking the input stream properly. However, both entry.getSize() and entry.getCompressedSize are always -1. This is openjdk version "17.0.7" 2023-04-18.

The javadoc states that -1 means the size is unknown but there must be a size or some other means by which to process just this entry before moving further down the stream.

I am not wed to this approach; the ultimate goal is to walk a JarInputStream and extract classname-classbyte entries.

EDIT

As a test, the byte[] bb array is written back to file XX2.jar and then examined using regular JarFile classes. This works:

        JarFile jf = new JarFile("XX2.jar");
for (java.util.Enumeration<JarEntry> e = jf.entries(); e.hasMoreElements();) {
entry = e.nextElement();
if (!entry.isDirectory() && entry.getName().endsWith(".class")) {
String className = entry.getName().replace('/', '.').substring(0, entry\
.getName().length() - 6);
int x = (int)entry.getSize();
int cx = (int)entry.getCompressedSize();
System.out.println("  class [" + className + "]: Z " + cx + "; unZ " + \
x);
}
}
class [org.bson.AbstractBsonReader$1]: Z 506; unZ 792
class [org.bson.AbstractBsonReader$Context]: Z 497; unZ 1227
class [org.bson.AbstractBsonReader$Mark]: Z 813; unZ 2201

However, trying to read that file using a regular FileInputStream as we see in many other SO examples does not work:

      JarInputStream jarInputStream = new JarInputStream(new FileInputStream("XX2.jar"));
loop runs but size and compressedSize are STILL -1.

EDIT 2

Here is a complete example that demos the problem:

import java.util.jar.JarEntry;
import java.util.jar.JarInputStream;
import java.util.jar.JarFile;
import java.io.FileInputStream;
class jartest {
public static void showEntry(JarEntry entry) {
if (!entry.isDirectory() && entry.getName().endsWith(".class")) {
String className = entry.getName().replace('/', '.').substring(0, entry.get\
Name().length() - 6);
int x = (int)entry.getSize();
int cx = (int)entry.getCompressedSize();
System.out.println("  class [" + className + "]: Z " + cx + "; unZ " + x);
}
}
public static void main(String[] args) {
try {
JarEntry entry;
String fname = "XX2.jar";
// THIS WORKS                                                               
JarFile jf = new JarFile(fname);
for (java.util.Enumeration<JarEntry> e = jf.entries(); e.hasMoreElements();\
) {
entry =	e.nextElement();
showEntry(entry);
}
// THIS DOES NOT WORK                                                       
JarInputStream js = new JarInputStream(new FileInputStream(fname));
while ((entry = js.getNextJarEntry()) != null) {
showEntry(entry);
}
} catch(Exception e) {
System.out.println("fail: " + e);
}
}
}
$ java jartest
class [grun$ExecutionContextImpl]: Z 706; unZ 1245
class [grun]: Z 3210; unZ 6476
class [grun$ExecutionContextImpl]: Z -1; unZ -1
class [grun]: Z -1; unZ -1

Any clues? Overall it looks like streams are not working but filename based logic does work.

According to the javadoc, -1 means that the respective size is unknown.

According to the source code, the values of a ZipEntry / JarEntry's size fields are read from the ZIP or JAR file itself. The logic is a bit complicated¹, but immediate explanation for getting a -1 is that the code was unable to extract sizes from the LOC header, or because the sizes were -1 in the LOC header.

To figure out what is actually going on in your case, you will need to decode the JAR file's headers by hand. Note that a JAR file is actually a ZIP file with a manifest, so you can use the format description in the ZIP file format Wikipedia page as a reference.

As suggested by @g00se's comment, the problem could be that the JAR file you are trying to read is incomplete or malformed. So another alternative would be to write the bytes to a file and see if a ZIP tool or the jar command can read the file.

^{1 - Classic ZIP and ZIP64 represent the sizes differently in the LOC headers. The ZipEntry code has to unpick this.}