public static GitObjectId FindNode(Stream stream, ReadOnlySpan <byte> name)
{
byte[] buffer = ArrayPool <byte> .Shared.Rent((int)stream.Length);
Span <byte> contents = new Span <byte>(buffer, 0, (int)stream.Length);
stream.ReadAll(contents);
GitObjectId value = GitObjectId.Empty;
while (contents.Length > 0)
{
// Format: [mode] [file/ folder name]\0[SHA - 1 of referencing blob or tree]
// Mode is either 6-bytes long (directory) or 7-bytes long (file).
// If the entry is a file, the first byte is '1'
var fileNameEnds = contents.IndexOf((byte)0);
bool isFile = contents[0] == (byte)'1';
var modeLength = isFile ? 7 : 6;
var currentName = contents.Slice(modeLength, fileNameEnds - modeLength);
if (currentName.SequenceEqual(name))
{
value = GitObjectId.Parse(contents.Slice(fileNameEnds + 1, 20));
break;
}
else
{
contents = contents.Slice(fileNameEnds + 1 + 20);
}
}
ArrayPool <byte> .Shared.Return(buffer);
return(value);
}
public GitObjectId?Lookup(string objectish)
{
bool skipObjectIdLookup = false;
if (objectish == "HEAD")
{
var reference = this.GetHeadAsReferenceOrSha();
if (reference is GitObjectId headObjectId)
{
return(headObjectId);
}
objectish = (string)reference;
}
var possibleLooseFileMatches = new List <string>();
if (objectish.StartsWith("refs/", StringComparison.Ordinal))
{
// Match on loose ref files by their canonical name.
possibleLooseFileMatches.Add(Path.Combine(this.CommonDirectory, objectish));
skipObjectIdLookup = true;
}
else
{
// Look for simple names for branch or tag.
possibleLooseFileMatches.Add(Path.Combine(this.CommonDirectory, "refs", "heads", objectish));
possibleLooseFileMatches.Add(Path.Combine(this.CommonDirectory, "refs", "tags", objectish));
possibleLooseFileMatches.Add(Path.Combine(this.CommonDirectory, "refs", "remotes", objectish));
}
if (possibleLooseFileMatches.FirstOrDefault(File.Exists) is string existingPath)
{
return(GitObjectId.Parse(File.ReadAllText(existingPath).TrimEnd()));
}
// Match in packed-refs file.
string packedRefPath = Path.Combine(this.CommonDirectory, "packed-refs");
if (File.Exists(packedRefPath))
{
using var refReader = File.OpenText(packedRefPath);
string?line;
while ((line = refReader.ReadLine()) is object)
{
if (line.StartsWith("#", StringComparison.Ordinal))
{
continue;
}
string refName = line.Substring(41);
if (string.Equals(refName, objectish, StringComparison.Ordinal))
{
return(GitObjectId.Parse(line.Substring(0, 40)));
}
else if (!objectish.StartsWith("refs/", StringComparison.Ordinal))
{
// Not a canonical ref, so try heads and tags
if (string.Equals(refName, "refs/heads/" + objectish, StringComparison.Ordinal))
{
return(GitObjectId.Parse(line.Substring(0, 40)));
}
else if (string.Equals(refName, "refs/tags/" + objectish, StringComparison.Ordinal))
{
return(GitObjectId.Parse(line.Substring(0, 40)));
}
else if (string.Equals(refName, "refs/remotes/" + objectish, StringComparison.Ordinal))
{
return(GitObjectId.Parse(line.Substring(0, 40)));
}
}
}
}
if (skipObjectIdLookup)
{
return(null);
}
if (objectish.Length == 40)
{
return(GitObjectId.Parse(objectish));
}
var possibleObjectIds = new List <GitObjectId>();
if (objectish.Length > 2 && objectish.Length < 40)
{
// Search for _any_ object whose id starts with objectish in the object database
var directory = Path.Combine(this.ObjectDirectory, objectish.Substring(0, 2));
if (Directory.Exists(directory))
{
var files = Directory.GetFiles(directory, $"{objectish.Substring(2)}*");
foreach (var file in files)
{
var objectId = $"{objectish.Substring(0, 2)}{Path.GetFileName(file)}";
possibleObjectIds.Add(GitObjectId.Parse(objectId));
}
}
// Search for _any_ object whose id starts with objectish in the packfile
bool endsWithHalfByte = objectish.Length % 2 == 1;
if (endsWithHalfByte)
{
// Add one more character so hex can be converted to bytes.
// The bit length to be compared will not consider the last four bits.
objectish += "0";
}
if (objectish.Length <= 40 && objectish.Length % 2 == 0)
{
Span <byte> decodedHex = stackalloc byte[objectish.Length / 2];
if (TryConvertHexStringToByteArray(objectish, decodedHex))
{
foreach (var pack in this.packs.Value.Span)
{
var objectId = pack.Lookup(decodedHex, endsWithHalfByte);
// It's possible for the same object to be present in both the object database and the pack files,
// or in multiple pack files.
if (objectId is not null && !possibleObjectIds.Contains(objectId.Value))
{
if (possibleObjectIds.Count > 0)
{
// If objectish already resolved to at least one object which is different from the current
// object id, objectish is not well-defined; so stop resolving and return null instead.
return(null);
}
else
{
possibleObjectIds.Add(objectId.Value);
}
}
}
}
}
}
if (possibleObjectIds.Count == 1)
{
return(possibleObjectIds[0]);
}
return(null);
}
public static Stream GetObject(GitPack pack, Stream stream, long offset, string objectType, GitPackObjectType packObjectType)
{
if (pack is null)
{
throw new ArgumentNullException(nameof(pack));
}
if (stream is null)
{
throw new ArgumentNullException(nameof(stream));
}
// Read the signature
#if DEBUG
stream.Seek(0, SeekOrigin.Begin);
Span <byte> buffer = stackalloc byte[12];
stream.ReadAll(buffer);
Debug.Assert(buffer.Slice(0, 4).SequenceEqual(Signature));
var versionNumber = BinaryPrimitives.ReadInt32BigEndian(buffer.Slice(4, 4));
Debug.Assert(versionNumber == 2);
var numberOfObjects = BinaryPrimitives.ReadInt32BigEndian(buffer.Slice(8, 4));
#endif
stream.Seek(offset, SeekOrigin.Begin);
var(type, decompressedSize) = ReadObjectHeader(stream);
if (type == GitPackObjectType.OBJ_OFS_DELTA)
{
var baseObjectRelativeOffset = ReadVariableLengthInteger(stream);
long baseObjectOffset = offset - baseObjectRelativeOffset;
var deltaStream = new ZLibStream(stream, decompressedSize);
var baseObjectStream = pack.GetObject(baseObjectOffset, objectType);
return(new GitPackDeltafiedStream(baseObjectStream, deltaStream));
}
else if (type == GitPackObjectType.OBJ_REF_DELTA)
{
Span <byte> baseObjectId = stackalloc byte[20];
stream.ReadAll(baseObjectId);
Stream baseObject = pack.GetObjectFromRepository(GitObjectId.Parse(baseObjectId), objectType) !;
var seekableBaseObject = new GitPackMemoryCacheStream(baseObject);
var deltaStream = new ZLibStream(stream, decompressedSize);
return(new GitPackDeltafiedStream(seekableBaseObject, deltaStream));
}
// Tips for handling deltas: https://github.com/choffmeister/gitnet/blob/4d907623d5ce2d79a8875aee82e718c12a8aad0b/src/GitNet/GitPack.cs
if (type != packObjectType)
{
throw new GitException($"An object of type {objectType} could not be located at offset {offset}.")
{
ErrorCode = GitException.ErrorCodes.ObjectNotFound
};
}
return(new ZLibStream(stream, decompressedSize));
}