public void SHA1_ByteAmount()
{
var sha = SHA1Value.ComputeFileSHA1(ThisFile);
sha.GetBytes().Count.Should().Be(20);
sha.ToString().Length.Should().Be(40);
}
/// <summary>
/// Initializes a new <see cref="StObjEngineConfiguration"/> from a <see cref="XElement"/>.
/// </summary>
/// <param name="e">The xml element.</param>
public StObjEngineConfiguration(XElement e)
{
Throw.CheckNotNullArgument(e);
// Global options.
BasePath = (string?)e.Element(xBasePath);
GeneratedAssemblyName = (string?)e.Element(xGeneratedAssemblyName);
TraceDependencySorterInput = (bool?)e.Element(xTraceDependencySorterInput) ?? false;
TraceDependencySorterOutput = (bool?)e.Element(xTraceDependencySorterOutput) ?? false;
RevertOrderingNames = (bool?)e.Element(xRevertOrderingNames) ?? false;
InformationalVersion = (string?)e.Element(xInformationalVersion);
var sha1 = (string?)e.Element(xBaseSHA1);
BaseSHA1 = sha1 != null?SHA1Value.Parse(sha1) : SHA1Value.Zero;
ForceRun = (bool?)e.Element(xForceRun) ?? false;
GlobalExcludedTypes = new HashSet <string>(FromXml(e, xGlobalExcludedTypes, xType));
// BinPaths.
BinPaths = e.Elements(xBinPaths).Elements(xBinPath).Select(e => new BinPathConfiguration(e)).ToList();
// Aspects.
Aspects = new List <IStObjEngineAspectConfiguration>();
foreach (var a in e.Elements(xAspect))
{
string type = (string)a.AttributeRequired(xType);
Type? tAspect = SimpleTypeFinder.WeakResolver(type, true);
Debug.Assert(tAspect != null);
IStObjEngineAspectConfiguration aspect = (IStObjEngineAspectConfiguration)Activator.CreateInstance(tAspect, a) !;
Aspects.Add(aspect);
}
}
public void SHA1_ToString_and_Parse()
{
var sha = SHA1Value.ComputeFileSHA1(GetFilePath());
var s = sha.ToString();
var shaBis = SHA1Value.Parse(s);
shaBis.Should().Be(sha);
}
public static (ulong d0, ulong d1, uint d2) ToStorage(SHA1Value value)
{
var d = value.Data;
var d0 = BitConverter.ToUInt64(d, 0);
var d1 = BitConverter.ToUInt64(d, 8);
var d2 = BitConverter.ToUInt32(d, 16);
return(d0, d1, d2);
}
/// <summary>
/// Tries to extract a SHA1 signature from an existing directory: the <see cref="SignatureFileName"/> is read if it exists.
/// <para>
/// This can be overridden to detect the signature differently.
/// </para>
/// </summary>
/// <param name="monitor">The monitor to use.</param>
/// <returns><see cref="SHA1Value.Zero"/> if not found.</returns>
protected virtual SHA1Value DoGetSignature(IActivityMonitor monitor)
{
var f = Path.AppendPart(SignatureFileName);
if (File.Exists(f) && SHA1Value.TryParse(File.ReadAllText(f), out var signature))
{
return(signature);
}
return(SHA1Value.Zero);
}
/// <summary>
/// Overridden to read the signature file.
/// </summary>
/// <param name="monitor">The monitor to use.</param>
/// <returns>The signature or <see cref="SHA1Value.Zero"/> if it can't be read.</returns>
protected override SHA1Value DoGetSignature(IActivityMonitor monitor)
{
var firstLine = SafeReadFirstLine(monitor, _signatureFile);
if (firstLine != null && SHA1Value.TryParse(firstLine, out var signature))
{
return(signature);
}
return(SHA1Value.Zero);
}
internal static IAsyncOperationWithProgress <FileSearchResult, HttpProgress> SearchAsync(string keyword, Category category, StorageFile file, bool searchSimilar, bool onlyCovers, bool searchExpunged)
{
if (file is null)
{
throw new ArgumentNullException(nameof(file));
}
if (searchSimilar)
{
return(AsyncInfo.Run <FileSearchResult, HttpProgress>(async(token, progress) =>
{
var read = FileIO.ReadBufferAsync(file);
HttpStringContent contentOf(bool v) => new HttpStringContent(v ? "1" : "0");
var data = new HttpMultipartFormDataContent
{
{ contentOf(true), "fs_similar" },
{ contentOf(onlyCovers), "fs_covers" },
{ contentOf(searchExpunged), "fs_exp" }
};
var buf = await read;
data.Add(new HttpBufferContent(buf), "sfile", file.Name);
await data.BufferAllAsync();
var post = Client.Current.HttpClient.PostAsync(Client.Current.Uris.FileSearchUri, data);
post.Progress = (s, p) => progress.Report(p);
var r = await post;
var uri = r.RequestMessage.RequestUri;
var query = uri.Query.Split("?&".ToCharArray(), StringSplitOptions.RemoveEmptyEntries);
var hashstr = query.Single(s => s.StartsWith("f_shash=")).Substring(8).Split(';');
var info = hashstr.FirstOrDefault(value => value.Length != 40);
switch (info)
{
case "monotone":
throw new InvalidOperationException(LocalizedStrings.Resources.UnsupportedMonotone);
case "corrupt":
throw new InvalidOperationException(LocalizedStrings.Resources.UnsupportedFile);
case null:
break;
default:
throw new InvalidOperationException(info);
}
return new FileSearchResult(keyword, category, hashstr.Select(SHA1Value.Parse), file.Name, true, onlyCovers, searchExpunged);
}));
}
else
{
return(AsyncInfo.Run <FileSearchResult, HttpProgress>(async(token, progress) =>
{
var hash = await SHA1Value.ComputeAsync(file);
return new FileSearchResult(keyword, category, Enumerable.Repeat(hash, 1), file.Name, false, onlyCovers, searchExpunged);
}));
}
}
internal RunningBinPathGroup(string generatedAssemblyName, BinPathConfiguration head, BinPathConfiguration[] similars, SHA1Value sha)
{
Debug.Assert(generatedAssemblyName != null && generatedAssemblyName.StartsWith(StObjContextRoot.GeneratedAssemblyName));
Debug.Assert(similars != null && similars.Length > 0 && similars[0] == head);
_generatedDllName = $"{generatedAssemblyName}-{head.Name}.dll";
Configuration = head;
SimilarConfigurations = similars;
RunSignature = sha;
GeneratedSource = CreateG0(head);
GeneratedAssembly = CreateAssembly(head);
_names = similars.Select(c => c.Name).Concatenate();
}
/// <summary>
/// Tries to extract a SHA1 signature from a file: the first valid SHA value that appears in the <see cref="NormalizedPath.Parts"/> (split by dot '.')
/// form the end to start of the <see cref="Path"/>.
/// <para>
/// This can be overridden to detect the signature differently.
/// </para>
/// </summary>
/// <param name="monitor">The monitor to use.</param>
/// <returns><see cref="SHA1Value.Zero"/> if not found.</returns>
protected virtual SHA1Value DoGetSignature(IActivityMonitor monitor)
{
foreach (var part in Path.Parts.Reverse())
{
foreach (var p in part.Split('.').Reverse())
{
if (SHA1Value.TryParse(p, out var signature))
{
return(signature);
}
}
}
return(SHA1Value.Zero);
}
public void SHA1_CompareTo(string v1, string v2, char cmp)
{
var s1 = SHA1Value.Parse(v1);
var s2 = SHA1Value.Parse(v2);
switch (cmp)
{
case '>': s1.CompareTo(s2).Should().BeGreaterThan(0); break;
case '<': s1.CompareTo(s2).Should().BeLessThan(0); break;
default: s1.CompareTo(s2).Should().Be(0); break;
}
}
/// <summary>
/// Overridden to match [assembly: CK.StObj.Signature( "..." )] SHA1 attribute in the first line.
/// </summary>
/// <param name="monitor"></param>
/// <returns></returns>
protected override SHA1Value DoGetSignature(IActivityMonitor monitor)
{
var firstLine = SafeReadFirstLine(monitor, Path);
if (firstLine != null)
{
var m = Regex.Match(firstLine, @"\s*\[\s*assembly\s*:\s*CK.StObj.Signature\s*\(\s*@?""(?<1>.*?)""");
if (m.Success && SHA1Value.TryParse(m.Groups[1].Value, out var signature))
{
return(signature);
}
}
monitor.Warn($"Unable to read [assembly: CK.StObj.Signature( \"...\" )] attribute from '{Path}'.");
return(SHA1Value.Zero);
}
private IAsyncAction loadImageUriAndHash()
{
return(Run(async token =>
{
var loadPageUri = default(Uri);
if (this.failToken != null)
{
loadPageUri = new Uri(this.PageUri, $"?{this.failToken}");
}
else
{
loadPageUri = this.PageUri;
}
var doc = await Client.Current.HttpClient.GetDocumentAsync(loadPageUri);
this.imageUri = new Uri(doc.GetElementbyId("img").GetAttributeValue("src", "").DeEntitize());
var originalNode = doc.GetElementbyId("i7").Element("a");
if (originalNode == null)
{
this.originalImageUri = null;
}
else
{
this.originalImageUri = new Uri(originalNode.GetAttributeValue("href", "").DeEntitize());
}
var hashNode = doc.GetElementbyId("i6").Element("a");
this.ImageHash = SHA1Value.Parse(hashMatcher.Match(hashNode.GetAttributeValue("href", "").DeEntitize()).Groups[1].Value);
var loadFail = doc.GetElementbyId("loadfail").GetAttributeValue("onclick", "").DeEntitize();
var oft = this.failToken;
var nft = failTokenMatcher.Match(loadFail).Groups[1].Value;
if (oft == null)
{
this.failToken = $"nl={nft}";
}
else
{
this.failToken = $"{oft}&nl={nft}";
}
}));
}
public async Task SHA1_from_file_async()
{
var sha = SHA1Value.ComputeFileSHA1(GetFilePath());
var sha2 = await SHA1Value.ComputeFileSHA1Async(GetFilePath());
sha2.Should().Be(sha);
using (var compressedPath = new TemporaryFile())
{
using (var input = new FileStream(GetFilePath(), FileMode.Open, FileAccess.Read, FileShare.Read, 4096, FileOptions.SequentialScan | FileOptions.Asynchronous))
using (var compressed = new FileStream(compressedPath.Path, FileMode.Truncate, FileAccess.Write, FileShare.None, 4096, FileOptions.SequentialScan | FileOptions.Asynchronous))
{
var writer = GetCompressShellAsync(w => input.CopyToAsync(w));
await writer(compressed);
}
var shaCompressed = await SHA1Value.ComputeFileSHA1Async(compressedPath.Path);
shaCompressed.Should().NotBe(sha);
var localSha = await SHA1Value.ComputeFileSHA1Async(compressedPath.Path, r => new GZipStream(r, CompressionMode.Decompress, true));
localSha.Should().Be(sha);
}
}
public static Expression <Func <GalleryImageModel, bool> > FKEquals(SHA1Value value)
{
var(d0, d1, d2) = ImageModel.ToStorage(value);
return(m => m.Data0 == d0 && m.Data1 == d1 && m.Data2 == d2);
}
public void SHA1_invalid_parse(int offset, string s, bool success)
{
SHA1Value v;
SHA1Value.TryParse(s, offset, out v).Should().Be(success);
}
internal RunningBinPathGroup(string generatedAssemblyName, BinPathConfiguration head, SHA1Value sha)
: this(generatedAssemblyName, head, new[] { head }, sha)
{
}
/// <summary>
/// Writes a SHA1 signature for this directory.
/// </summary>
/// <param name="signature">The signature to write.</param>
public void CreateOrUpdateSignatureFile(SHA1Value signature)
{
File.WriteAllText(Path.AppendPart(SignatureFileName), signature.ToString());
}
/// <summary>
/// Writes the SHA1 file signature for this file.
/// </summary>
/// <param name="signature">The signature to write.</param>
public void CreateOrUpdateSignatureFile(SHA1Value signature)
{
File.WriteAllText(_signatureFile, signature.ToString());
}
