UnpackedObject.java

  1. /*
  2.  * Copyright (C) 2007, Robin Rosenberg <robin.rosenberg@dewire.com>
  3.  * Copyright (C) 2006-2008, Shawn O. Pearce <spearce@spearce.org>
  4.  * Copyright (C) 2010, Google Inc. and others
  5.  *
  6.  * This program and the accompanying materials are made available under the
  7.  * terms of the Eclipse Distribution License v. 1.0 which is available at
  8.  * https://www.eclipse.org/org/documents/edl-v10.php.
  9.  *
  10.  * SPDX-License-Identifier: BSD-3-Clause
  11.  */

  13. package org.eclipse.jgit.internal.storage.file;

  15. import java.io.BufferedInputStream;
  16. import java.io.ByteArrayInputStream;
  17. import java.io.File;
  18. import java.io.FileInputStream;
  19. import java.io.FileNotFoundException;
  20. import java.io.IOException;
  21. import java.io.InputStream;
  22. import java.util.zip.DataFormatException;
  23. import java.util.zip.Inflater;
  24. import java.util.zip.InflaterInputStream;
  25. import java.util.zip.ZipException;

  27. import org.eclipse.jgit.errors.CorruptObjectException;
  28. import org.eclipse.jgit.errors.LargeObjectException;
  29. import org.eclipse.jgit.errors.MissingObjectException;
  30. import org.eclipse.jgit.internal.JGitText;
  31. import org.eclipse.jgit.lib.AnyObjectId;
  32. import org.eclipse.jgit.lib.Constants;
  33. import org.eclipse.jgit.lib.InflaterCache;
  34. import org.eclipse.jgit.lib.ObjectId;
  35. import org.eclipse.jgit.lib.ObjectLoader;
  36. import org.eclipse.jgit.lib.ObjectStream;
  37. import org.eclipse.jgit.util.IO;
  38. import org.eclipse.jgit.util.MutableInteger;
  39. import org.eclipse.jgit.util.RawParseUtils;

  41. /**
  42.  * Loose object loader. This class loads an object not stored in a pack.
  43.  */
  44. public class UnpackedObject {
  45.     private static final int BUFFER_SIZE = 8192;

  47.     /**
  48.      * Parse an object from the unpacked object format.
  49.      *
  50.      * @param raw
  51.      *            complete contents of the compressed object.
  52.      * @param id
  53.      *            expected ObjectId of the object, used only for error reporting
  54.      *            in exceptions.
  55.      * @return loader to read the inflated contents.
  56.      * @throws java.io.IOException
  57.      *             the object cannot be parsed.
  58.      */
  59.     public static ObjectLoader parse(byte[] raw, AnyObjectId id)
  60.             throws IOException {
  61.         try (WindowCursor wc = new WindowCursor(null)) {
  62.             return open(new ByteArrayInputStream(raw), null, id, wc);
  63.         }
  64.     }

  66.     static ObjectLoader open(InputStream in, File path, AnyObjectId id,
  67.             WindowCursor wc) throws IOException {
  68.         try {
  69.             in = buffer(in);
  70.             in.mark(20);
  71.             final byte[] hdr = new byte[64];
  72.             IO.readFully(in, hdr, 0, 2);

  74.             if (isStandardFormat(hdr)) {
  75.                 in.reset();
  76.                 Inflater inf = wc.inflater();
  77.                 InputStream zIn = inflate(in, inf);
  78.                 int avail = readSome(zIn, hdr, 0, 64);
  79.                 if (avail < 5)
  80.                     throw new CorruptObjectException(id,
  81.                             JGitText.get().corruptObjectNoHeader);

  83.                 final MutableInteger p = new MutableInteger();
  84.                 int type = Constants.decodeTypeString(id, hdr, (byte) ' ', p);
  85.                 long size = RawParseUtils.parseLongBase10(hdr, p.value, p);
  86.                 if (size < 0)
  87.                     throw new CorruptObjectException(id,
  88.                             JGitText.get().corruptObjectNegativeSize);
  89.                 if (hdr[p.value++] != 0)
  90.                     throw new CorruptObjectException(id,
  91.                             JGitText.get().corruptObjectGarbageAfterSize);
  92.                 if (path == null && Integer.MAX_VALUE < size) {
  93.                     LargeObjectException.ExceedsByteArrayLimit e;
  94.                     e = new LargeObjectException.ExceedsByteArrayLimit();
  95.                     e.setObjectId(id);
  96.                     throw e;
  97.                 }
  98.                 if (size < wc.getStreamFileThreshold() || path == null) {
  99.                     byte[] data = new byte[(int) size];
  100.                     int n = avail - p.value;
  101.                     if (n > 0)
  102.                         System.arraycopy(hdr, p.value, data, 0, n);
  103.                     IO.readFully(zIn, data, n, data.length - n);
  104.                     checkValidEndOfStream(in, inf, id, hdr);
  105.                     return new ObjectLoader.SmallObject(type, data);
  106.                 }
  107.                 return new LargeObject(type, size, path, id, wc.db);

  109.             }
  110.             readSome(in, hdr, 2, 18);
  111.             int c = hdr[0] & 0xff;
  112.             int type = (c >> 4) & 7;
  113.             long size = c & 15;
  114.             int shift = 4;
  115.             int p = 1;
  116.             while ((c & 0x80) != 0) {
  117.                 c = hdr[p++] & 0xff;
  118.                 size += ((long) (c & 0x7f)) << shift;
  119.                 shift += 7;
  120.             }

  122.             switch (type) {
  123.             case Constants.OBJ_COMMIT:
  124.             case Constants.OBJ_TREE:
  125.             case Constants.OBJ_BLOB:
  126.             case Constants.OBJ_TAG:
  127.                 // Acceptable types for a loose object.
  128.                 break;
  129.             default:
  130.                 throw new CorruptObjectException(id,
  131.                         JGitText.get().corruptObjectInvalidType);
  132.             }

  134.             if (path == null && Integer.MAX_VALUE < size) {
  135.                 LargeObjectException.ExceedsByteArrayLimit e;
  136.                 e = new LargeObjectException.ExceedsByteArrayLimit();
  137.                 e.setObjectId(id);
  138.                 throw e;
  139.             }
  140.             if (size < wc.getStreamFileThreshold() || path == null) {
  141.                 in.reset();
  142.                 IO.skipFully(in, p);
  143.                 Inflater inf = wc.inflater();
  144.                 InputStream zIn = inflate(in, inf);
  145.                 byte[] data = new byte[(int) size];
  146.                 IO.readFully(zIn, data, 0, data.length);
  147.                 checkValidEndOfStream(in, inf, id, hdr);
  148.                 return new ObjectLoader.SmallObject(type, data);
  149.             }
  150.             return new LargeObject(type, size, path, id, wc.db);
  151.         } catch (ZipException badStream) {
  152.             CorruptObjectException coe = new CorruptObjectException(id,
  153.                     JGitText.get().corruptObjectBadStream);
  154.             coe.initCause(badStream);
  155.             throw coe;
  156.         }
  157.     }

  159.     static long getSize(InputStream in, AnyObjectId id, WindowCursor wc)
  160.             throws IOException {
  161.         try {
  162.             in = buffer(in);
  163.             in.mark(20);
  164.             final byte[] hdr = new byte[64];
  165.             IO.readFully(in, hdr, 0, 2);

  167.             if (isStandardFormat(hdr)) {
  168.                 in.reset();
  169.                 Inflater inf = wc.inflater();
  170.                 InputStream zIn = inflate(in, inf);
  171.                 int avail = readSome(zIn, hdr, 0, 64);
  172.                 if (avail < 5)
  173.                     throw new CorruptObjectException(id,
  174.                             JGitText.get().corruptObjectNoHeader);

  176.                 final MutableInteger p = new MutableInteger();
  177.                 Constants.decodeTypeString(id, hdr, (byte) ' ', p);
  178.                 long size = RawParseUtils.parseLongBase10(hdr, p.value, p);
  179.                 if (size < 0)
  180.                     throw new CorruptObjectException(id,
  181.                             JGitText.get().corruptObjectNegativeSize);
  182.                 return size;

  184.             }
  185.             readSome(in, hdr, 2, 18);
  186.             int c = hdr[0] & 0xff;
  187.             long size = c & 15;
  188.             int shift = 4;
  189.             int p = 1;
  190.             while ((c & 0x80) != 0) {
  191.                 c = hdr[p++] & 0xff;
  192.                 size += ((long) (c & 0x7f)) << shift;
  193.                 shift += 7;
  194.             }
  195.             return size;
  196.         } catch (ZipException badStream) {
  197.             CorruptObjectException coe = new CorruptObjectException(id,
  198.                     JGitText.get().corruptObjectBadStream);
  199.             coe.initCause(badStream);
  200.             throw coe;
  201.         }
  202.     }

  204.     static void checkValidEndOfStream(InputStream in, Inflater inf,
  205.             AnyObjectId id, final byte[] buf) throws IOException,
  206.             CorruptObjectException {
  207.         for (;;) {
  208.             int r;
  209.             try {
  210.                 r = inf.inflate(buf);
  211.             } catch (DataFormatException e) {
  212.                 CorruptObjectException coe = new CorruptObjectException(id,
  213.                         JGitText.get().corruptObjectBadStream);
  214.                 coe.initCause(e);
  215.                 throw coe;
  216.             }
  217.             if (r != 0)
  218.                 throw new CorruptObjectException(id,
  219.                         JGitText.get().corruptObjectIncorrectLength);

  221.             if (inf.finished()) {
  222.                 if (inf.getRemaining() != 0 || in.read() != -1)
  223.                     throw new CorruptObjectException(id,
  224.                             JGitText.get().corruptObjectBadStream);
  225.                 break;
  226.             }

  228.             if (!inf.needsInput())
  229.                 throw new CorruptObjectException(id,
  230.                         JGitText.get().corruptObjectBadStream);

  232.             r = in.read(buf);
  233.             if (r <= 0)
  234.                 throw new CorruptObjectException(id,
  235.                         JGitText.get().corruptObjectBadStream);
  236.             inf.setInput(buf, 0, r);
  237.         }
  238.     }

  240.     static boolean isStandardFormat(byte[] hdr) {
  241.         /*
  242.          * We must determine if the buffer contains the standard
  243.          * zlib-deflated stream or the experimental format based
  244.          * on the in-pack object format. Compare the header byte
  245.          * for each format:
  246.          *
  247.          * RFC1950 zlib w/ deflate : 0www1000 : 0 <= www <= 7
  248.          * Experimental pack-based : Stttssss : ttt = 1,2,3,4
  249.          *
  250.          * If bit 7 is clear and bits 0-3 equal 8, the buffer MUST be
  251.          * in standard loose-object format, UNLESS it is a Git-pack
  252.          * format object *exactly* 8 bytes in size when inflated.
  253.          *
  254.          * However, RFC1950 also specifies that the 1st 16-bit word
  255.          * must be divisible by 31 - this checksum tells us our buffer
  256.          * is in the standard format, giving a false positive only if
  257.          * the 1st word of the Git-pack format object happens to be
  258.          * divisible by 31, ie:
  259.          *      ((byte0 * 256) + byte1) % 31 = 0
  260.          *   =>        0ttt10000www1000 % 31 = 0
  261.          *
  262.          * As it happens, this case can only arise for www=3 & ttt=1
  263.          * - ie, a Commit object, which would have to be 8 bytes in
  264.          * size. As no Commit can be that small, we find that the
  265.          * combination of these two criteria (bitmask & checksum)
  266.          * can always correctly determine the buffer format.
  267.          */
  268.         final int fb = hdr[0] & 0xff;
  269.         return (fb & 0x8f) == 0x08 && (((fb << 8) | (hdr[1] & 0xff)) % 31) == 0;
  270.     }

  272.     static InputStream inflate(final InputStream in, final long size,
  273.             final ObjectId id) {
  274.         final Inflater inf = InflaterCache.get();
  275.         return new InflaterInputStream(in, inf) {
  276.             private long remaining = size;

  278.             @Override
  279.             public int read(byte[] b, int off, int cnt) throws IOException {
  280.                 try {
  281.                     int r = super.read(b, off, cnt);
  282.                     if (r > 0)
  283.                         remaining -= r;
  284.                     return r;
  285.                 } catch (ZipException badStream) {
  286.                     CorruptObjectException coe = new CorruptObjectException(id,
  287.                             JGitText.get().corruptObjectBadStream);
  288.                     coe.initCause(badStream);
  289.                     throw coe;
  290.                 }
  291.             }

  293.             @Override
  294.             public void close() throws IOException {
  295.                 try {
  296.                     if (remaining <= 0)
  297.                         checkValidEndOfStream(in, inf, id, new byte[64]);
  298.                 } finally {
  299.                     InflaterCache.release(inf);
  300.                     super.close();
  301.                 }
  302.             }
  303.         };
  304.     }

  306.     private static InflaterInputStream inflate(InputStream in, Inflater inf) {
  307.         return new InflaterInputStream(in, inf, BUFFER_SIZE);
  308.     }

  310.     static BufferedInputStream buffer(InputStream in) {
  311.         return new BufferedInputStream(in, BUFFER_SIZE);
  312.     }

  314.     static int readSome(InputStream in, final byte[] hdr, int off,
  315.             int cnt) throws IOException {
  316.         int avail = 0;
  317.         while (0 < cnt) {
  318.             int n = in.read(hdr, off, cnt);
  319.             if (n < 0)
  320.                 break;
  321.             avail += n;
  322.             off += n;
  323.             cnt -= n;
  324.         }
  325.         return avail;
  326.     }

  328.     private static final class LargeObject extends ObjectLoader {
  329.         private final int type;

  331.         private final long size;

  333.         private final File path;

  335.         private final ObjectId id;

  337.         private final FileObjectDatabase source;

  339.         LargeObject(int type, long size, File path, AnyObjectId id,
  340.                 FileObjectDatabase db) {
  341.             this.type = type;
  342.             this.size = size;
  343.             this.path = path;
  344.             this.id = id.copy();
  345.             this.source = db;
  346.         }

  348.         @Override
  349.         public int getType() {
  350.             return type;
  351.         }

  353.         @Override
  354.         public long getSize() {
  355.             return size;
  356.         }

  358.         @Override
  359.         public boolean isLarge() {
  360.             return true;
  361.         }

  363.         @Override
  364.         public byte[] getCachedBytes() throws LargeObjectException {
  365.             throw new LargeObjectException(id);
  366.         }

  368.         @Override
  369.         public ObjectStream openStream() throws MissingObjectException,
  370.                 IOException {
  371.             InputStream in;
  372.             try {
  373.                 in = buffer(new FileInputStream(path));
  374.             } catch (FileNotFoundException gone) {
  375.                 if (path.exists()) {
  376.                     throw gone;
  377.                 }
  378.                 // If the loose file no longer exists, it may have been
  379.                 // moved into a pack file in the mean time. Try again
  380.                 // to locate the object.
  381.                 //
  382.                 return source.open(id, type).openStream();
  383.             }

  385.             boolean ok = false;
  386.             try {
  387.                 final byte[] hdr = new byte[64];
  388.                 in.mark(20);
  389.                 IO.readFully(in, hdr, 0, 2);

  391.                 if (isStandardFormat(hdr)) {
  392.                     in.reset();
  393.                     in = buffer(inflate(in, size, id));
  394.                     while (0 < in.read())
  395.                         continue;
  396.                 } else {
  397.                     readSome(in, hdr, 2, 18);
  398.                     int c = hdr[0] & 0xff;
  399.                     int p = 1;
  400.                     while ((c & 0x80) != 0)
  401.                         c = hdr[p++] & 0xff;

  403.                     in.reset();
  404.                     IO.skipFully(in, p);
  405.                     in = buffer(inflate(in, size, id));
  406.                 }

  408.                 ok = true;
  409.                 return new ObjectStream.Filter(type, size, in);
  410.             } finally {
  411.                 if (!ok)
  412.                     in.close();
  413.             }
  414.         }
  415.     }
  416. }
Created with JaCoCo 0.8.7.202105040129