PackParser.java
/*
* Copyright (C) 2008-2011, Google Inc.
* Copyright (C) 2007-2008, Robin Rosenberg <robin.rosenberg@dewire.com>
* Copyright (C) 2008, Shawn O. Pearce <spearce@spearce.org> and others
*
* This program and the accompanying materials are made available under the
* terms of the Eclipse Distribution License v. 1.0 which is available at
* https://www.eclipse.org/org/documents/edl-v10.php.
*
* SPDX-License-Identifier: BSD-3-Clause
*/
package org.eclipse.jgit.transport;
import java.io.EOFException;
import java.io.IOException;
import java.io.InputStream;
import java.security.MessageDigest;
import java.text.MessageFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import java.util.concurrent.TimeUnit;
import java.util.zip.DataFormatException;
import java.util.zip.Inflater;
import org.eclipse.jgit.errors.CorruptObjectException;
import org.eclipse.jgit.errors.MissingObjectException;
import org.eclipse.jgit.errors.TooLargeObjectInPackException;
import org.eclipse.jgit.internal.JGitText;
import org.eclipse.jgit.internal.storage.pack.BinaryDelta;
import org.eclipse.jgit.lib.AnyObjectId;
import org.eclipse.jgit.lib.BatchingProgressMonitor;
import org.eclipse.jgit.lib.BlobObjectChecker;
import org.eclipse.jgit.lib.Constants;
import org.eclipse.jgit.lib.InflaterCache;
import org.eclipse.jgit.lib.MutableObjectId;
import org.eclipse.jgit.lib.NullProgressMonitor;
import org.eclipse.jgit.lib.ObjectChecker;
import org.eclipse.jgit.lib.ObjectDatabase;
import org.eclipse.jgit.lib.ObjectId;
import org.eclipse.jgit.lib.ObjectIdOwnerMap;
import org.eclipse.jgit.lib.ObjectIdSubclassMap;
import org.eclipse.jgit.lib.ObjectLoader;
import org.eclipse.jgit.lib.ObjectReader;
import org.eclipse.jgit.lib.ObjectStream;
import org.eclipse.jgit.lib.ProgressMonitor;
import org.eclipse.jgit.util.BlockList;
import org.eclipse.jgit.util.IO;
import org.eclipse.jgit.util.LongMap;
import org.eclipse.jgit.util.NB;
import org.eclipse.jgit.util.sha1.SHA1;
/**
* Parses a pack stream and imports it for an
* {@link org.eclipse.jgit.lib.ObjectInserter}.
* <p>
* Applications can acquire an instance of a parser from ObjectInserter's
* {@link org.eclipse.jgit.lib.ObjectInserter#newPackParser(InputStream)}
* method.
* <p>
* Implementations of {@link org.eclipse.jgit.lib.ObjectInserter} should
* subclass this type and provide their own logic for the various {@code on*()}
* event methods declared to be abstract.
*/
public abstract class PackParser {
/** Size of the internal stream buffer. */
private static final int BUFFER_SIZE = 8192;
/** Location data is being obtained from. */
public enum Source {
/** Data is read from the incoming stream. */
INPUT,
/** Data is read back from the database's buffers. */
DATABASE;
}
/** Object database used for loading existing objects. */
private final ObjectDatabase objectDatabase;
private InflaterStream inflater;
private byte[] tempBuffer;
private byte[] hdrBuf;
private final SHA1 objectHasher = SHA1.newInstance();
private final MutableObjectId tempObjectId;
private InputStream in;
byte[] buf;
/** Position in the input stream of {@code buf[0]}. */
private long bBase;
private int bOffset;
int bAvail;
private ObjectChecker objCheck;
private boolean allowThin;
private boolean checkObjectCollisions;
private boolean needBaseObjectIds;
private boolean checkEofAfterPackFooter;
private boolean expectDataAfterPackFooter;
private long expectedObjectCount;
private PackedObjectInfo[] entries;
/**
* Every object contained within the incoming pack.
* <p>
* This is a subset of {@link #entries}, as thin packs can add additional
* objects to {@code entries} by copying already existing objects from the
* repository onto the end of the thin pack to make it self-contained.
*/
private ObjectIdSubclassMap<ObjectId> newObjectIds;
private int deltaCount;
private int entryCount;
private ObjectIdOwnerMap<DeltaChain> baseById;
/**
* Objects referenced by their name from deltas, that aren't in this pack.
* <p>
* This is the set of objects that were copied onto the end of this pack to
* make it complete. These objects were not transmitted by the remote peer,
* but instead were assumed to already exist in the local repository.
*/
private ObjectIdSubclassMap<ObjectId> baseObjectIds;
private LongMap<UnresolvedDelta> baseByPos;
/** Objects need to be double-checked for collision after indexing. */
private BlockList<PackedObjectInfo> collisionCheckObjs;
private MessageDigest packDigest;
private ObjectReader readCurs;
/** Message to protect the pack data from garbage collection. */
private String lockMessage;
/** Git object size limit */
private long maxObjectSizeLimit;
private final ReceivedPackStatistics.Builder stats =
new ReceivedPackStatistics.Builder();
/**
* Initialize a pack parser.
*
* @param odb
* database the parser will write its objects into.
* @param src
* the stream the parser will read.
*/
protected PackParser(ObjectDatabase odb, InputStream src) {
objectDatabase = odb.newCachedDatabase();
in = src;
inflater = new InflaterStream();
readCurs = objectDatabase.newReader();
buf = new byte[BUFFER_SIZE];
tempBuffer = new byte[BUFFER_SIZE];
hdrBuf = new byte[64];
tempObjectId = new MutableObjectId();
packDigest = Constants.newMessageDigest();
checkObjectCollisions = true;
}
/**
* Whether a thin pack (missing base objects) is permitted.
*
* @return {@code true} if a thin pack (missing base objects) is permitted.
*/
public boolean isAllowThin() {
return allowThin;
}
/**
* Configure this index pack instance to allow a thin pack.
* <p>
* Thin packs are sometimes used during network transfers to allow a delta
* to be sent without a base object. Such packs are not permitted on disk.
*
* @param allow
* true to enable a thin pack.
*/
public void setAllowThin(boolean allow) {
allowThin = allow;
}
/**
* Whether received objects are verified to prevent collisions.
*
* @return if true received objects are verified to prevent collisions.
* @since 4.1
*/
protected boolean isCheckObjectCollisions() {
return checkObjectCollisions;
}
/**
* Enable checking for collisions with existing objects.
* <p>
* By default PackParser looks for each received object in the repository.
* If the object already exists, the existing object is compared
* byte-for-byte with the newly received copy to ensure they are identical.
* The receive is aborted with an exception if any byte differs. This check
* is necessary to prevent an evil attacker from supplying a replacement
* object into this repository in the event that a discovery enabling SHA-1
* collisions is made.
* <p>
* This check may be very costly to perform, and some repositories may have
* other ways to segregate newly received object data. The check is enabled
* by default, but can be explicitly disabled if the implementation can
* provide the same guarantee, or is willing to accept the risks associated
* with bypassing the check.
*
* @param check
* true to enable collision checking (strongly encouraged).
* @since 4.1
*/
protected void setCheckObjectCollisions(boolean check) {
checkObjectCollisions = check;
}
/**
* Configure this index pack instance to keep track of new objects.
* <p>
* By default an index pack doesn't save the new objects that were created
* when it was instantiated. Setting this flag to {@code true} allows the
* caller to use {@link #getNewObjectIds()} to retrieve that list.
*
* @param b
* {@code true} to enable keeping track of new objects.
*/
public void setNeedNewObjectIds(boolean b) {
if (b)
newObjectIds = new ObjectIdSubclassMap<>();
else
newObjectIds = null;
}
private boolean needNewObjectIds() {
return newObjectIds != null;
}
/**
* Configure this index pack instance to keep track of the objects assumed
* for delta bases.
* <p>
* By default an index pack doesn't save the objects that were used as delta
* bases. Setting this flag to {@code true} will allow the caller to use
* {@link #getBaseObjectIds()} to retrieve that list.
*
* @param b
* {@code true} to enable keeping track of delta bases.
*/
public void setNeedBaseObjectIds(boolean b) {
this.needBaseObjectIds = b;
}
/**
* Whether the EOF should be read from the input after the footer.
*
* @return true if the EOF should be read from the input after the footer.
*/
public boolean isCheckEofAfterPackFooter() {
return checkEofAfterPackFooter;
}
/**
* Ensure EOF is read from the input stream after the footer.
*
* @param b
* true if the EOF should be read; false if it is not checked.
*/
public void setCheckEofAfterPackFooter(boolean b) {
checkEofAfterPackFooter = b;
}
/**
* Whether there is data expected after the pack footer.
*
* @return true if there is data expected after the pack footer.
*/
public boolean isExpectDataAfterPackFooter() {
return expectDataAfterPackFooter;
}
/**
* Set if there is additional data in InputStream after pack.
*
* @param e
* true if there is additional data in InputStream after pack.
* This requires the InputStream to support the mark and reset
* functions.
*/
public void setExpectDataAfterPackFooter(boolean e) {
expectDataAfterPackFooter = e;
}
/**
* Get the new objects that were sent by the user
*
* @return the new objects that were sent by the user
*/
public ObjectIdSubclassMap<ObjectId> getNewObjectIds() {
if (newObjectIds != null)
return newObjectIds;
return new ObjectIdSubclassMap<>();
}
/**
* Get set of objects the incoming pack assumed for delta purposes
*
* @return set of objects the incoming pack assumed for delta purposes
*/
public ObjectIdSubclassMap<ObjectId> getBaseObjectIds() {
if (baseObjectIds != null)
return baseObjectIds;
return new ObjectIdSubclassMap<>();
}
/**
* Configure the checker used to validate received objects.
* <p>
* Usually object checking isn't necessary, as Git implementations only
* create valid objects in pack files. However, additional checking may be
* useful if processing data from an untrusted source.
*
* @param oc
* the checker instance; null to disable object checking.
*/
public void setObjectChecker(ObjectChecker oc) {
objCheck = oc;
}
/**
* Configure the checker used to validate received objects.
* <p>
* Usually object checking isn't necessary, as Git implementations only
* create valid objects in pack files. However, additional checking may be
* useful if processing data from an untrusted source.
* <p>
* This is shorthand for:
*
* <pre>
* setObjectChecker(on ? new ObjectChecker() : null);
* </pre>
*
* @param on
* true to enable the default checker; false to disable it.
*/
public void setObjectChecking(boolean on) {
setObjectChecker(on ? new ObjectChecker() : null);
}
/**
* Get the message to record with the pack lock.
*
* @return the message to record with the pack lock.
*/
public String getLockMessage() {
return lockMessage;
}
/**
* Set the lock message for the incoming pack data.
*
* @param msg
* if not null, the message to associate with the incoming data
* while it is locked to prevent garbage collection.
*/
public void setLockMessage(String msg) {
lockMessage = msg;
}
/**
* Set the maximum allowed Git object size.
* <p>
* If an object is larger than the given size the pack-parsing will throw an
* exception aborting the parsing.
*
* @param limit
* the Git object size limit. If zero then there is not limit.
*/
public void setMaxObjectSizeLimit(long limit) {
maxObjectSizeLimit = limit;
}
/**
* Get the number of objects in the stream.
* <p>
* The object count is only available after {@link #parse(ProgressMonitor)}
* has returned. The count may have been increased if the stream was a thin
* pack, and missing bases objects were appending onto it by the subclass.
*
* @return number of objects parsed out of the stream.
*/
public int getObjectCount() {
return entryCount;
}
/**
* Get the information about the requested object.
* <p>
* The object information is only available after
* {@link #parse(ProgressMonitor)} has returned.
*
* @param nth
* index of the object in the stream. Must be between 0 and
* {@link #getObjectCount()}-1.
* @return the object information.
*/
public PackedObjectInfo getObject(int nth) {
return entries[nth];
}
/**
* Get all of the objects, sorted by their name.
* <p>
* The object information is only available after
* {@link #parse(ProgressMonitor)} has returned.
* <p>
* To maintain lower memory usage and good runtime performance, this method
* sorts the objects in-place and therefore impacts the ordering presented
* by {@link #getObject(int)}.
*
* @param cmp
* comparison function, if null objects are stored by ObjectId.
* @return sorted list of objects in this pack stream.
*/
public List<PackedObjectInfo> getSortedObjectList(
Comparator<PackedObjectInfo> cmp) {
Arrays.sort(entries, 0, entryCount, cmp);
List<PackedObjectInfo> list = Arrays.asList(entries);
if (entryCount < entries.length)
list = list.subList(0, entryCount);
return list;
}
/**
* Get the size of the newly created pack.
* <p>
* This will also include the pack index size if an index was created. This
* method should only be called after pack parsing is finished.
*
* @return the pack size (including the index size) or -1 if the size cannot
* be determined
* @since 3.3
*/
public long getPackSize() {
return -1;
}
/**
* Returns the statistics of the parsed pack.
* <p>
* This should only be called after pack parsing is finished.
*
* @return {@link org.eclipse.jgit.transport.ReceivedPackStatistics}
* @since 4.6
*/
public ReceivedPackStatistics getReceivedPackStatistics() {
return stats.build();
}
/**
* Parse the pack stream.
*
* @param progress
* callback to provide progress feedback during parsing. If null,
* {@link org.eclipse.jgit.lib.NullProgressMonitor} will be used.
* @return the pack lock, if one was requested by setting
* {@link #setLockMessage(String)}.
* @throws java.io.IOException
* the stream is malformed, or contains corrupt objects.
* @since 6.0
*/
public final PackLock parse(ProgressMonitor progress) throws IOException {
return parse(progress, progress);
}
/**
* Parse the pack stream.
*
* @param receiving
* receives progress feedback during the initial receiving
* objects phase. If null,
* {@link org.eclipse.jgit.lib.NullProgressMonitor} will be used.
* @param resolving
* receives progress feedback during the resolving objects phase.
* @return the pack lock, if one was requested by setting
* {@link #setLockMessage(String)}.
* @throws java.io.IOException
* the stream is malformed, or contains corrupt objects.
* @since 6.0
*/
public PackLock parse(ProgressMonitor receiving, ProgressMonitor resolving)
throws IOException {
if (receiving == null)
receiving = NullProgressMonitor.INSTANCE;
if (resolving == null)
resolving = NullProgressMonitor.INSTANCE;
if (receiving == resolving)
receiving.start(2 /* tasks */);
try {
readPackHeader();
entries = new PackedObjectInfo[(int) expectedObjectCount];
baseById = new ObjectIdOwnerMap<>();
baseByPos = new LongMap<>();
collisionCheckObjs = new BlockList<>();
receiving.beginTask(JGitText.get().receivingObjects,
(int) expectedObjectCount);
try {
for (int done = 0; done < expectedObjectCount; done++) {
indexOneObject();
receiving.update(1);
if (receiving.isCancelled())
throw new IOException(JGitText.get().downloadCancelled);
}
readPackFooter();
endInput();
} finally {
receiving.endTask();
}
if (!collisionCheckObjs.isEmpty()) {
checkObjectCollision();
}
if (deltaCount > 0) {
processDeltas(resolving);
}
packDigest = null;
baseById = null;
baseByPos = null;
} finally {
try {
if (readCurs != null)
readCurs.close();
} finally {
readCurs = null;
}
try {
inflater.release();
} finally {
inflater = null;
}
}
return null; // By default there is no locking.
}
private void processDeltas(ProgressMonitor resolving) throws IOException {
if (resolving instanceof BatchingProgressMonitor) {
((BatchingProgressMonitor) resolving).setDelayStart(1000,
TimeUnit.MILLISECONDS);
}
resolving.beginTask(JGitText.get().resolvingDeltas, deltaCount);
resolveDeltas(resolving);
if (entryCount < expectedObjectCount) {
if (!isAllowThin()) {
throw new IOException(MessageFormat.format(
JGitText.get().packHasUnresolvedDeltas,
Long.valueOf(expectedObjectCount - entryCount)));
}
resolveDeltasWithExternalBases(resolving);
if (entryCount < expectedObjectCount) {
throw new IOException(MessageFormat.format(
JGitText.get().packHasUnresolvedDeltas,
Long.valueOf(expectedObjectCount - entryCount)));
}
}
resolving.endTask();
}
private void resolveDeltas(ProgressMonitor progress)
throws IOException {
final int last = entryCount;
for (int i = 0; i < last; i++) {
resolveDeltas(entries[i], progress);
if (progress.isCancelled())
throw new IOException(
JGitText.get().downloadCancelledDuringIndexing);
}
}
private void resolveDeltas(final PackedObjectInfo oe,
ProgressMonitor progress) throws IOException {
UnresolvedDelta children = firstChildOf(oe);
if (children == null)
return;
DeltaVisit visit = new DeltaVisit();
visit.nextChild = children;
ObjectTypeAndSize info = openDatabase(oe, new ObjectTypeAndSize());
switch (info.type) {
case Constants.OBJ_COMMIT:
case Constants.OBJ_TREE:
case Constants.OBJ_BLOB:
case Constants.OBJ_TAG:
visit.data = inflateAndReturn(Source.DATABASE, info.size);
visit.id = oe;
break;
default:
throw new IOException(MessageFormat.format(
JGitText.get().unknownObjectType,
Integer.valueOf(info.type)));
}
if (!checkCRC(oe.getCRC())) {
throw new IOException(MessageFormat.format(
JGitText.get().corruptionDetectedReReadingAt,
Long.valueOf(oe.getOffset())));
}
resolveDeltas(visit.next(), info.type, info, progress);
}
private void resolveDeltas(DeltaVisit visit, final int type,
ObjectTypeAndSize info, ProgressMonitor progress)
throws IOException {
stats.addDeltaObject(type);
do {
progress.update(1);
info = openDatabase(visit.delta, info);
switch (info.type) {
case Constants.OBJ_OFS_DELTA:
case Constants.OBJ_REF_DELTA:
break;
default:
throw new IOException(MessageFormat.format(
JGitText.get().unknownObjectType,
Integer.valueOf(info.type)));
}
byte[] delta = inflateAndReturn(Source.DATABASE, info.size);
long finalSz = BinaryDelta.getResultSize(delta);
checkIfTooLarge(type, finalSz);
visit.data = BinaryDelta.apply(visit.parent.data, delta);
delta = null;
if (!checkCRC(visit.delta.crc))
throw new IOException(MessageFormat.format(
JGitText.get().corruptionDetectedReReadingAt,
Long.valueOf(visit.delta.position)));
SHA1 objectDigest = objectHasher.reset();
objectDigest.update(Constants.encodedTypeString(type));
objectDigest.update((byte) ' ');
objectDigest.update(Constants.encodeASCII(visit.data.length));
objectDigest.update((byte) 0);
objectDigest.update(visit.data);
objectDigest.digest(tempObjectId);
verifySafeObject(tempObjectId, type, visit.data);
if (isCheckObjectCollisions() && readCurs.has(tempObjectId)) {
checkObjectCollision(tempObjectId, type, visit.data,
visit.delta.sizeBeforeInflating);
}
PackedObjectInfo oe;
oe = newInfo(tempObjectId, visit.delta, visit.parent.id);
oe.setFullSize(finalSz);
oe.setOffset(visit.delta.position);
oe.setType(type);
onInflatedObjectData(oe, type, visit.data);
addObjectAndTrack(oe);
visit.id = oe;
visit.nextChild = firstChildOf(oe);
visit = visit.next();
} while (visit != null);
}
private final void checkIfTooLarge(int typeCode, long size)
throws IOException {
if (0 < maxObjectSizeLimit && maxObjectSizeLimit < size) {
switch (typeCode) {
case Constants.OBJ_COMMIT:
case Constants.OBJ_TREE:
case Constants.OBJ_BLOB:
case Constants.OBJ_TAG:
throw new TooLargeObjectInPackException(size, maxObjectSizeLimit);
case Constants.OBJ_OFS_DELTA:
case Constants.OBJ_REF_DELTA:
throw new TooLargeObjectInPackException(size, maxObjectSizeLimit);
default:
throw new IOException(MessageFormat.format(
JGitText.get().unknownObjectType,
Integer.valueOf(typeCode)));
}
}
if (size > Integer.MAX_VALUE - 8) {
throw new TooLargeObjectInPackException(size, Integer.MAX_VALUE - 8);
}
}
/**
* Read the header of the current object.
* <p>
* After the header has been parsed, this method automatically invokes
* {@link #onObjectHeader(Source, byte[], int, int)} to allow the
* implementation to update its internal checksums for the bytes read.
* <p>
* When this method returns the database will be positioned on the first
* byte of the deflated data stream.
*
* @param info
* the info object to populate.
* @return {@code info}, after populating.
* @throws java.io.IOException
* the size cannot be read.
*/
protected ObjectTypeAndSize readObjectHeader(ObjectTypeAndSize info)
throws IOException {
int hdrPtr = 0;
int c = readFrom(Source.DATABASE);
hdrBuf[hdrPtr++] = (byte) c;
info.type = (c >> 4) & 7;
long sz = c & 15;
int shift = 4;
while ((c & 0x80) != 0) {
c = readFrom(Source.DATABASE);
hdrBuf[hdrPtr++] = (byte) c;
sz += ((long) (c & 0x7f)) << shift;
shift += 7;
}
info.size = sz;
switch (info.type) {
case Constants.OBJ_COMMIT:
case Constants.OBJ_TREE:
case Constants.OBJ_BLOB:
case Constants.OBJ_TAG:
onObjectHeader(Source.DATABASE, hdrBuf, 0, hdrPtr);
break;
case Constants.OBJ_OFS_DELTA:
c = readFrom(Source.DATABASE);
hdrBuf[hdrPtr++] = (byte) c;
while ((c & 128) != 0) {
c = readFrom(Source.DATABASE);
hdrBuf[hdrPtr++] = (byte) c;
}
onObjectHeader(Source.DATABASE, hdrBuf, 0, hdrPtr);
break;
case Constants.OBJ_REF_DELTA:
System.arraycopy(buf, fill(Source.DATABASE, 20), hdrBuf, hdrPtr, 20);
hdrPtr += 20;
use(20);
onObjectHeader(Source.DATABASE, hdrBuf, 0, hdrPtr);
break;
default:
throw new IOException(MessageFormat.format(
JGitText.get().unknownObjectType,
Integer.valueOf(info.type)));
}
return info;
}
private UnresolvedDelta removeBaseById(AnyObjectId id) {
final DeltaChain d = baseById.get(id);
return d != null ? d.remove() : null;
}
private static UnresolvedDelta reverse(UnresolvedDelta c) {
UnresolvedDelta tail = null;
while (c != null) {
final UnresolvedDelta n = c.next;
c.next = tail;
tail = c;
c = n;
}
return tail;
}
private UnresolvedDelta firstChildOf(PackedObjectInfo oe) {
UnresolvedDelta a = reverse(removeBaseById(oe));
UnresolvedDelta b = reverse(baseByPos.remove(oe.getOffset()));
if (a == null)
return b;
if (b == null)
return a;
UnresolvedDelta first = null;
UnresolvedDelta last = null;
while (a != null || b != null) {
UnresolvedDelta curr;
if (b == null || (a != null && a.position < b.position)) {
curr = a;
a = a.next;
} else {
curr = b;
b = b.next;
}
if (last != null)
last.next = curr;
else
first = curr;
last = curr;
curr.next = null;
}
return first;
}
private void resolveDeltasWithExternalBases(ProgressMonitor progress)
throws IOException {
growEntries(baseById.size());
if (needBaseObjectIds)
baseObjectIds = new ObjectIdSubclassMap<>();
final List<DeltaChain> missing = new ArrayList<>(64);
for (DeltaChain baseId : baseById) {
if (baseId.head == null)
continue;
if (needBaseObjectIds)
baseObjectIds.add(baseId);
final ObjectLoader ldr;
try {
ldr = readCurs.open(baseId);
} catch (MissingObjectException notFound) {
missing.add(baseId);
continue;
}
final DeltaVisit visit = new DeltaVisit();
visit.data = ldr.getCachedBytes(Integer.MAX_VALUE);
visit.id = baseId;
final int typeCode = ldr.getType();
final PackedObjectInfo oe = newInfo(baseId, null, null);
oe.setType(typeCode);
oe.setFullSize(ldr.getSize());
if (onAppendBase(typeCode, visit.data, oe))
entries[entryCount++] = oe;
visit.nextChild = firstChildOf(oe);
resolveDeltas(visit.next(), typeCode,
new ObjectTypeAndSize(), progress);
if (progress.isCancelled())
throw new IOException(
JGitText.get().downloadCancelledDuringIndexing);
}
for (DeltaChain base : missing) {
if (base.head != null)
throw new MissingObjectException(base, "delta base"); //$NON-NLS-1$
}
onEndThinPack();
}
private void growEntries(int extraObjects) {
final PackedObjectInfo[] ne;
ne = new PackedObjectInfo[(int) expectedObjectCount + extraObjects];
System.arraycopy(entries, 0, ne, 0, entryCount);
entries = ne;
}
private void readPackHeader() throws IOException {
if (expectDataAfterPackFooter) {
if (!in.markSupported())
throw new IOException(
JGitText.get().inputStreamMustSupportMark);
in.mark(buf.length);
}
final int hdrln = Constants.PACK_SIGNATURE.length + 4 + 4;
final int p = fill(Source.INPUT, hdrln);
for (int k = 0; k < Constants.PACK_SIGNATURE.length; k++)
if (buf[p + k] != Constants.PACK_SIGNATURE[k])
throw new IOException(JGitText.get().notAPACKFile);
final long vers = NB.decodeUInt32(buf, p + 4);
if (vers != 2 && vers != 3)
throw new IOException(MessageFormat.format(
JGitText.get().unsupportedPackVersion, Long.valueOf(vers)));
final long objectCount = NB.decodeUInt32(buf, p + 8);
use(hdrln);
setExpectedObjectCount(objectCount);
onPackHeader(objectCount);
}
private void readPackFooter() throws IOException {
sync();
final byte[] actHash = packDigest.digest();
final int c = fill(Source.INPUT, 20);
final byte[] srcHash = new byte[20];
System.arraycopy(buf, c, srcHash, 0, 20);
use(20);
if (bAvail != 0 && !expectDataAfterPackFooter)
throw new CorruptObjectException(MessageFormat.format(
JGitText.get().expectedEOFReceived,
"\\x" + Integer.toHexString(buf[bOffset] & 0xff))); //$NON-NLS-1$
if (isCheckEofAfterPackFooter()) {
int eof = in.read();
if (0 <= eof)
throw new CorruptObjectException(MessageFormat.format(
JGitText.get().expectedEOFReceived,
"\\x" + Integer.toHexString(eof))); //$NON-NLS-1$
} else if (bAvail > 0 && expectDataAfterPackFooter) {
in.reset();
IO.skipFully(in, bOffset);
}
if (!Arrays.equals(actHash, srcHash))
throw new CorruptObjectException(
JGitText.get().corruptObjectPackfileChecksumIncorrect);
onPackFooter(srcHash);
}
// Cleanup all resources associated with our input parsing.
private void endInput() {
stats.setNumBytesRead(streamPosition());
in = null;
}
// Read one entire object or delta from the input.
private void indexOneObject() throws IOException {
final long streamPosition = streamPosition();
int hdrPtr = 0;
int c = readFrom(Source.INPUT);
hdrBuf[hdrPtr++] = (byte) c;
final int typeCode = (c >> 4) & 7;
long sz = c & 15;
int shift = 4;
while ((c & 0x80) != 0) {
c = readFrom(Source.INPUT);
hdrBuf[hdrPtr++] = (byte) c;
sz += ((long) (c & 0x7f)) << shift;
shift += 7;
}
checkIfTooLarge(typeCode, sz);
switch (typeCode) {
case Constants.OBJ_COMMIT:
case Constants.OBJ_TREE:
case Constants.OBJ_BLOB:
case Constants.OBJ_TAG:
stats.addWholeObject(typeCode);
onBeginWholeObject(streamPosition, typeCode, sz);
onObjectHeader(Source.INPUT, hdrBuf, 0, hdrPtr);
whole(streamPosition, typeCode, sz);
break;
case Constants.OBJ_OFS_DELTA: {
stats.addOffsetDelta();
c = readFrom(Source.INPUT);
hdrBuf[hdrPtr++] = (byte) c;
long ofs = c & 127;
while ((c & 128) != 0) {
ofs += 1;
c = readFrom(Source.INPUT);
hdrBuf[hdrPtr++] = (byte) c;
ofs <<= 7;
ofs += (c & 127);
}
final long base = streamPosition - ofs;
onBeginOfsDelta(streamPosition, base, sz);
onObjectHeader(Source.INPUT, hdrBuf, 0, hdrPtr);
inflateAndSkip(Source.INPUT, sz);
UnresolvedDelta n = onEndDelta();
n.position = streamPosition;
n.next = baseByPos.put(base, n);
n.sizeBeforeInflating = streamPosition() - streamPosition;
deltaCount++;
break;
}
case Constants.OBJ_REF_DELTA: {
stats.addRefDelta();
c = fill(Source.INPUT, 20);
final ObjectId base = ObjectId.fromRaw(buf, c);
System.arraycopy(buf, c, hdrBuf, hdrPtr, 20);
hdrPtr += 20;
use(20);
DeltaChain r = baseById.get(base);
if (r == null) {
r = new DeltaChain(base);
baseById.add(r);
}
onBeginRefDelta(streamPosition, base, sz);
onObjectHeader(Source.INPUT, hdrBuf, 0, hdrPtr);
inflateAndSkip(Source.INPUT, sz);
UnresolvedDelta n = onEndDelta();
n.position = streamPosition;
n.sizeBeforeInflating = streamPosition() - streamPosition;
r.add(n);
deltaCount++;
break;
}
default:
throw new IOException(
MessageFormat.format(JGitText.get().unknownObjectType,
Integer.valueOf(typeCode)));
}
}
private void whole(long pos, int type, long sz)
throws IOException {
SHA1 objectDigest = objectHasher.reset();
objectDigest.update(Constants.encodedTypeString(type));
objectDigest.update((byte) ' ');
objectDigest.update(Constants.encodeASCII(sz));
objectDigest.update((byte) 0);
final byte[] data;
if (type == Constants.OBJ_BLOB) {
byte[] readBuffer = buffer();
BlobObjectChecker checker = null;
if (objCheck != null) {
checker = objCheck.newBlobObjectChecker();
}
if (checker == null) {
checker = BlobObjectChecker.NULL_CHECKER;
}
long cnt = 0;
try (InputStream inf = inflate(Source.INPUT, sz)) {
while (cnt < sz) {
int r = inf.read(readBuffer);
if (r <= 0)
break;
objectDigest.update(readBuffer, 0, r);
checker.update(readBuffer, 0, r);
cnt += r;
}
}
objectDigest.digest(tempObjectId);
checker.endBlob(tempObjectId);
data = null;
} else {
data = inflateAndReturn(Source.INPUT, sz);
objectDigest.update(data);
objectDigest.digest(tempObjectId);
verifySafeObject(tempObjectId, type, data);
}
long sizeBeforeInflating = streamPosition() - pos;
PackedObjectInfo obj = newInfo(tempObjectId, null, null);
obj.setOffset(pos);
obj.setType(type);
obj.setSize(sizeBeforeInflating);
obj.setFullSize(sz);
onEndWholeObject(obj);
if (data != null)
onInflatedObjectData(obj, type, data);
addObjectAndTrack(obj);
if (isCheckObjectCollisions()) {
collisionCheckObjs.add(obj);
}
}
/**
* Verify the integrity of the object.
*
* @param id
* identity of the object to be checked.
* @param type
* the type of the object.
* @param data
* raw content of the object.
* @throws org.eclipse.jgit.errors.CorruptObjectException
* @since 4.9
*/
protected void verifySafeObject(final AnyObjectId id, final int type,
final byte[] data) throws CorruptObjectException {
if (objCheck != null) {
try {
objCheck.check(id, type, data);
} catch (CorruptObjectException e) {
if (e.getErrorType() != null) {
throw e;
}
throw new CorruptObjectException(
MessageFormat.format(JGitText.get().invalidObject,
Constants.typeString(type), id.name(),
e.getMessage()),
e);
}
}
}
private void checkObjectCollision() throws IOException {
for (PackedObjectInfo obj : collisionCheckObjs) {
if (!readCurs.has(obj)) {
continue;
}
checkObjectCollision(obj);
}
}
private void checkObjectCollision(PackedObjectInfo obj)
throws IOException {
ObjectTypeAndSize info = openDatabase(obj, new ObjectTypeAndSize());
final byte[] readBuffer = buffer();
final byte[] curBuffer = new byte[readBuffer.length];
long sz = info.size;
try (ObjectStream cur = readCurs.open(obj, info.type).openStream()) {
if (cur.getSize() != sz) {
throw new IOException(MessageFormat.format(
JGitText.get().collisionOn, obj.name()));
}
try (InputStream pck = inflate(Source.DATABASE, sz)) {
while (0 < sz) {
int n = (int) Math.min(readBuffer.length, sz);
IO.readFully(cur, curBuffer, 0, n);
IO.readFully(pck, readBuffer, 0, n);
for (int i = 0; i < n; i++) {
if (curBuffer[i] != readBuffer[i]) {
throw new IOException(MessageFormat.format(
JGitText.get().collisionOn, obj.name()));
}
}
sz -= n;
}
}
stats.incrementObjectsDuplicated();
stats.incrementNumBytesDuplicated(obj.getSize());
} catch (MissingObjectException notLocal) {
// This is OK, we don't have a copy of the object locally
// but the API throws when we try to read it as usually it's
// an error to read something that doesn't exist.
}
}
private void checkObjectCollision(AnyObjectId obj, int type, byte[] data,
long sizeBeforeInflating) throws IOException {
try {
final ObjectLoader ldr = readCurs.open(obj, type);
final byte[] existingData = ldr.getCachedBytes(data.length);
if (!Arrays.equals(data, existingData)) {
throw new IOException(MessageFormat
.format(JGitText.get().collisionOn, obj.name()));
}
stats.incrementObjectsDuplicated();
stats.incrementNumBytesDuplicated(sizeBeforeInflating);
} catch (MissingObjectException notLocal) {
// This is OK, we don't have a copy of the object locally
// but the API throws when we try to read it as usually its
// an error to read something that doesn't exist.
}
}
/** @return current position of the input stream being parsed. */
private long streamPosition() {
return bBase + bOffset;
}
private ObjectTypeAndSize openDatabase(PackedObjectInfo obj,
ObjectTypeAndSize info) throws IOException {
bOffset = 0;
bAvail = 0;
return seekDatabase(obj, info);
}
private ObjectTypeAndSize openDatabase(UnresolvedDelta delta,
ObjectTypeAndSize info) throws IOException {
bOffset = 0;
bAvail = 0;
return seekDatabase(delta, info);
}
// Consume exactly one byte from the buffer and return it.
private int readFrom(Source src) throws IOException {
if (bAvail == 0)
fill(src, 1);
bAvail--;
return buf[bOffset++] & 0xff;
}
// Consume cnt bytes from the buffer.
void use(int cnt) {
bOffset += cnt;
bAvail -= cnt;
}
// Ensure at least need bytes are available in {@link #buf}.
int fill(Source src, int need) throws IOException {
while (bAvail < need) {
int next = bOffset + bAvail;
int free = buf.length - next;
if (free + bAvail < need) {
switch (src) {
case INPUT:
sync();
break;
case DATABASE:
if (bAvail > 0)
System.arraycopy(buf, bOffset, buf, 0, bAvail);
bOffset = 0;
break;
}
next = bAvail;
free = buf.length - next;
}
switch (src) {
case INPUT:
next = in.read(buf, next, free);
break;
case DATABASE:
next = readDatabase(buf, next, free);
break;
}
if (next <= 0)
throw new EOFException(
JGitText.get().packfileIsTruncatedNoParam);
bAvail += next;
}
return bOffset;
}
// Store consumed bytes in {@link #buf} up to {@link #bOffset}.
private void sync() throws IOException {
packDigest.update(buf, 0, bOffset);
onStoreStream(buf, 0, bOffset);
if (expectDataAfterPackFooter) {
if (bAvail > 0) {
in.reset();
IO.skipFully(in, bOffset);
bAvail = 0;
}
in.mark(buf.length);
} else if (bAvail > 0)
System.arraycopy(buf, bOffset, buf, 0, bAvail);
bBase += bOffset;
bOffset = 0;
}
/**
* Get a temporary byte array for use by the caller.
*
* @return a temporary byte array for use by the caller.
*/
protected byte[] buffer() {
return tempBuffer;
}
/**
* Construct a PackedObjectInfo instance for this parser.
*
* @param id
* identity of the object to be tracked.
* @param delta
* if the object was previously an unresolved delta, this is the
* delta object that was tracking it. Otherwise null.
* @param deltaBase
* if the object was previously an unresolved delta, this is the
* ObjectId of the base of the delta. The base may be outside of
* the pack stream if the stream was a thin-pack.
* @return info object containing this object's data.
*/
protected PackedObjectInfo newInfo(AnyObjectId id, UnresolvedDelta delta,
ObjectId deltaBase) {
PackedObjectInfo oe = new PackedObjectInfo(id);
if (delta != null)
oe.setCRC(delta.crc);
return oe;
}
/**
* Set the expected number of objects in the pack stream.
* <p>
* The object count in the pack header is not always correct for some Dfs
* pack files. e.g. INSERT pack always assume 1 object in the header since
* the actual object count is unknown when the pack is written.
* <p>
* If external implementation wants to overwrite the expectedObjectCount,
* they should call this method during {@link #onPackHeader(long)}.
*
* @param expectedObjectCount a long.
* @since 4.9
*/
protected void setExpectedObjectCount(long expectedObjectCount) {
this.expectedObjectCount = expectedObjectCount;
}
/**
* Store bytes received from the raw stream.
* <p>
* This method is invoked during {@link #parse(ProgressMonitor)} as data is
* consumed from the incoming stream. Implementors may use this event to
* archive the raw incoming stream to the destination repository in large
* chunks, without paying attention to object boundaries.
* <p>
* The only component of the pack not supplied to this method is the last 20
* bytes of the pack that comprise the trailing SHA-1 checksum. Those are
* passed to {@link #onPackFooter(byte[])}.
*
* @param raw
* buffer to copy data out of.
* @param pos
* first offset within the buffer that is valid.
* @param len
* number of bytes in the buffer that are valid.
* @throws java.io.IOException
* the stream cannot be archived.
*/
protected abstract void onStoreStream(byte[] raw, int pos, int len)
throws IOException;
/**
* Store (and/or checksum) an object header.
* <p>
* Invoked after any of the {@code onBegin()} events. The entire header is
* supplied in a single invocation, before any object data is supplied.
*
* @param src
* where the data came from
* @param raw
* buffer to read data from.
* @param pos
* first offset within buffer that is valid.
* @param len
* number of bytes in buffer that are valid.
* @throws java.io.IOException
* the stream cannot be archived.
*/
protected abstract void onObjectHeader(Source src, byte[] raw, int pos,
int len) throws IOException;
/**
* Store (and/or checksum) a portion of an object's data.
* <p>
* This method may be invoked multiple times per object, depending on the
* size of the object, the size of the parser's internal read buffer, and
* the alignment of the object relative to the read buffer.
* <p>
* Invoked after {@link #onObjectHeader(Source, byte[], int, int)}.
*
* @param src
* where the data came from
* @param raw
* buffer to read data from.
* @param pos
* first offset within buffer that is valid.
* @param len
* number of bytes in buffer that are valid.
* @throws java.io.IOException
* the stream cannot be archived.
*/
protected abstract void onObjectData(Source src, byte[] raw, int pos,
int len) throws IOException;
/**
* Invoked for commits, trees, tags, and small blobs.
*
* @param obj
* the object info, populated.
* @param typeCode
* the type of the object.
* @param data
* inflated data for the object.
* @throws java.io.IOException
* the object cannot be archived.
*/
protected abstract void onInflatedObjectData(PackedObjectInfo obj,
int typeCode, byte[] data) throws IOException;
/**
* Provide the implementation with the original stream's pack header.
*
* @param objCnt
* number of objects expected in the stream.
* @throws java.io.IOException
* the implementation refuses to work with this many objects.
*/
protected abstract void onPackHeader(long objCnt) throws IOException;
/**
* Provide the implementation with the original stream's pack footer.
*
* @param hash
* the trailing 20 bytes of the pack, this is a SHA-1 checksum of
* all of the pack data.
* @throws java.io.IOException
* the stream cannot be archived.
*/
protected abstract void onPackFooter(byte[] hash) throws IOException;
/**
* Provide the implementation with a base that was outside of the pack.
* <p>
* This event only occurs on a thin pack for base objects that were outside
* of the pack and came from the local repository. Usually an implementation
* uses this event to compress the base and append it onto the end of the
* pack, so the pack stays self-contained.
*
* @param typeCode
* type of the base object.
* @param data
* complete content of the base object.
* @param info
* packed object information for this base. Implementors must
* populate the CRC and offset members if returning true.
* @return true if the {@code info} should be included in the object list
* returned by {@link #getSortedObjectList(Comparator)}, false if it
* should not be included.
* @throws java.io.IOException
* the base could not be included into the pack.
*/
protected abstract boolean onAppendBase(int typeCode, byte[] data,
PackedObjectInfo info) throws IOException;
/**
* Event indicating a thin pack has been completely processed.
* <p>
* This event is invoked only if a thin pack has delta references to objects
* external from the pack. The event is called after all of those deltas
* have been resolved.
*
* @throws java.io.IOException
* the pack cannot be archived.
*/
protected abstract void onEndThinPack() throws IOException;
/**
* Reposition the database to re-read a previously stored object.
* <p>
* If the database is computing CRC-32 checksums for object data, it should
* reset its internal CRC instance during this method call.
*
* @param obj
* the object position to begin reading from. This is from
* {@link #newInfo(AnyObjectId, UnresolvedDelta, ObjectId)}.
* @param info
* object to populate with type and size.
* @return the {@code info} object.
* @throws java.io.IOException
* the database cannot reposition to this location.
*/
protected abstract ObjectTypeAndSize seekDatabase(PackedObjectInfo obj,
ObjectTypeAndSize info) throws IOException;
/**
* Reposition the database to re-read a previously stored object.
* <p>
* If the database is computing CRC-32 checksums for object data, it should
* reset its internal CRC instance during this method call.
*
* @param delta
* the object position to begin reading from. This is an instance
* previously returned by {@link #onEndDelta()}.
* @param info
* object to populate with type and size.
* @return the {@code info} object.
* @throws java.io.IOException
* the database cannot reposition to this location.
*/
protected abstract ObjectTypeAndSize seekDatabase(UnresolvedDelta delta,
ObjectTypeAndSize info) throws IOException;
/**
* Read from the database's current position into the buffer.
*
* @param dst
* the buffer to copy read data into.
* @param pos
* position within {@code dst} to start copying data into.
* @param cnt
* ideal target number of bytes to read. Actual read length may
* be shorter.
* @return number of bytes stored.
* @throws java.io.IOException
* the database cannot be accessed.
*/
protected abstract int readDatabase(byte[] dst, int pos, int cnt)
throws IOException;
/**
* Check the current CRC matches the expected value.
* <p>
* This method is invoked when an object is read back in from the database
* and its data is used during delta resolution. The CRC is validated after
* the object has been fully read, allowing the parser to verify there was
* no silent data corruption.
* <p>
* Implementations are free to ignore this check by always returning true if
* they are performing other data integrity validations at a lower level.
*
* @param oldCRC
* the prior CRC that was recorded during the first scan of the
* object from the pack stream.
* @return true if the CRC matches; false if it does not.
*/
protected abstract boolean checkCRC(int oldCRC);
/**
* Event notifying the start of an object stored whole (not as a delta).
*
* @param streamPosition
* position of this object in the incoming stream.
* @param type
* type of the object; one of
* {@link org.eclipse.jgit.lib.Constants#OBJ_COMMIT},
* {@link org.eclipse.jgit.lib.Constants#OBJ_TREE},
* {@link org.eclipse.jgit.lib.Constants#OBJ_BLOB}, or
* {@link org.eclipse.jgit.lib.Constants#OBJ_TAG}.
* @param inflatedSize
* size of the object when fully inflated. The size stored within
* the pack may be larger or smaller, and is not yet known.
* @throws java.io.IOException
* the object cannot be recorded.
*/
protected abstract void onBeginWholeObject(long streamPosition, int type,
long inflatedSize) throws IOException;
/**
* Event notifying the current object.
*
*@param info
* object information.
* @throws java.io.IOException
* the object cannot be recorded.
*/
protected abstract void onEndWholeObject(PackedObjectInfo info)
throws IOException;
/**
* Event notifying start of a delta referencing its base by offset.
*
* @param deltaStreamPosition
* position of this object in the incoming stream.
* @param baseStreamPosition
* position of the base object in the incoming stream. The base
* must be before the delta, therefore {@code baseStreamPosition
* < deltaStreamPosition}. This is <b>not</b> the position
* returned by a prior end object event.
* @param inflatedSize
* size of the delta when fully inflated. The size stored within
* the pack may be larger or smaller, and is not yet known.
* @throws java.io.IOException
* the object cannot be recorded.
*/
protected abstract void onBeginOfsDelta(long deltaStreamPosition,
long baseStreamPosition, long inflatedSize) throws IOException;
/**
* Event notifying start of a delta referencing its base by ObjectId.
*
* @param deltaStreamPosition
* position of this object in the incoming stream.
* @param baseId
* name of the base object. This object may be later in the
* stream, or might not appear at all in the stream (in the case
* of a thin-pack).
* @param inflatedSize
* size of the delta when fully inflated. The size stored within
* the pack may be larger or smaller, and is not yet known.
* @throws java.io.IOException
* the object cannot be recorded.
*/
protected abstract void onBeginRefDelta(long deltaStreamPosition,
AnyObjectId baseId, long inflatedSize) throws IOException;
/**
* Event notifying the current object.
*
*@return object information that must be populated with at least the
* offset.
* @throws java.io.IOException
* the object cannot be recorded.
*/
protected UnresolvedDelta onEndDelta() throws IOException {
return new UnresolvedDelta();
}
/** Type and size information about an object in the database buffer. */
public static class ObjectTypeAndSize {
/** The type of the object. */
public int type;
/** The inflated size of the object. */
public long size;
}
private void inflateAndSkip(Source src, long inflatedSize)
throws IOException {
try (InputStream inf = inflate(src, inflatedSize)) {
IO.skipFully(inf, inflatedSize);
}
}
private byte[] inflateAndReturn(Source src, long inflatedSize)
throws IOException {
final byte[] dst = new byte[(int) inflatedSize];
try (InputStream inf = inflate(src, inflatedSize)) {
IO.readFully(inf, dst, 0, dst.length);
}
return dst;
}
private InputStream inflate(Source src, long inflatedSize)
throws IOException {
inflater.open(src, inflatedSize);
return inflater;
}
private static class DeltaChain extends ObjectIdOwnerMap.Entry {
UnresolvedDelta head;
DeltaChain(AnyObjectId id) {
super(id);
}
UnresolvedDelta remove() {
final UnresolvedDelta r = head;
if (r != null)
head = null;
return r;
}
void add(UnresolvedDelta d) {
d.next = head;
head = d;
}
}
/** Information about an unresolved delta in this pack stream. */
public static class UnresolvedDelta {
long position;
int crc;
UnresolvedDelta next;
long sizeBeforeInflating;
/** @return offset within the input stream. */
public long getOffset() {
return position;
}
/** @return the CRC-32 checksum of the stored delta data. */
public int getCRC() {
return crc;
}
/**
* @param crc32
* the CRC-32 checksum of the stored delta data.
*/
public void setCRC(int crc32) {
crc = crc32;
}
}
private static class DeltaVisit {
final UnresolvedDelta delta;
ObjectId id;
byte[] data;
DeltaVisit parent;
UnresolvedDelta nextChild;
DeltaVisit() {
this.delta = null; // At the root of the stack we have a base.
}
DeltaVisit(DeltaVisit parent) {
this.parent = parent;
this.delta = parent.nextChild;
parent.nextChild = delta.next;
}
DeltaVisit next() {
// If our parent has no more children, discard it.
if (parent != null && parent.nextChild == null) {
parent.data = null;
parent = parent.parent;
}
if (nextChild != null)
return new DeltaVisit(this);
// If we have no child ourselves, our parent must (if it exists),
// due to the discard rule above. With no parent, we are done.
if (parent != null)
return new DeltaVisit(parent);
return null;
}
}
private void addObjectAndTrack(PackedObjectInfo oe) {
entries[entryCount++] = oe;
if (needNewObjectIds())
newObjectIds.add(oe);
}
private class InflaterStream extends InputStream {
private final Inflater inf;
private final byte[] skipBuffer;
private Source src;
private long expectedSize;
private long actualSize;
private int p;
InflaterStream() {
inf = InflaterCache.get();
skipBuffer = new byte[512];
}
void release() {
inf.reset();
InflaterCache.release(inf);
}
void open(Source source, long inflatedSize) throws IOException {
src = source;
expectedSize = inflatedSize;
actualSize = 0;
p = fill(src, 1);
inf.setInput(buf, p, bAvail);
}
@Override
public long skip(long toSkip) throws IOException {
long n = 0;
while (n < toSkip) {
final int cnt = (int) Math.min(skipBuffer.length, toSkip - n);
final int r = read(skipBuffer, 0, cnt);
if (r <= 0)
break;
n += r;
}
return n;
}
@Override
public int read() throws IOException {
int n = read(skipBuffer, 0, 1);
return n == 1 ? skipBuffer[0] & 0xff : -1;
}
@Override
public int read(byte[] dst, int pos, int cnt) throws IOException {
try {
int n = 0;
while (n < cnt) {
int r = inf.inflate(dst, pos + n, cnt - n);
n += r;
if (inf.finished())
break;
if (inf.needsInput()) {
onObjectData(src, buf, p, bAvail);
use(bAvail);
p = fill(src, 1);
inf.setInput(buf, p, bAvail);
} else if (r == 0) {
throw new CorruptObjectException(MessageFormat.format(
JGitText.get().packfileCorruptionDetected,
JGitText.get().unknownZlibError));
}
}
actualSize += n;
return 0 < n ? n : -1;
} catch (DataFormatException dfe) {
throw new CorruptObjectException(MessageFormat.format(JGitText
.get().packfileCorruptionDetected, dfe.getMessage()));
}
}
@Override
public void close() throws IOException {
// We need to read here to enter the loop above and pump the
// trailing checksum into the Inflater. It should return -1 as the
// caller was supposed to consume all content.
//
if (read(skipBuffer) != -1 || actualSize != expectedSize) {
throw new CorruptObjectException(MessageFormat.format(JGitText
.get().packfileCorruptionDetected,
JGitText.get().wrongDecompressedLength));
}
int used = bAvail - inf.getRemaining();
if (0 < used) {
onObjectData(src, buf, p, used);
use(used);
}
inf.reset();
}
}
}