public void CreateFiles(string rpm, string analyzerName)
{
using (Stream stream = File.OpenRead(rpm))
{
var originalPackage = RpmPackageReader.Read(stream);
using (var payloadStream = RpmPayloadReader.GetDecompressedPayloadStream(originalPackage))
using (var cpio = new CpioFile(payloadStream, false))
{
IFileAnalyzer analyzer = new FileAnalyzer();
switch (analyzerName)
{
case "plist":
analyzer = new PlistFileAnalyzer();
break;
case "dotnet":
analyzer = new DotnetFileAnalyzer();
break;
}
RpmPackageCreator creator = new RpmPackageCreator(analyzer);
ArchiveBuilder builder = new ArchiveBuilder(analyzer);
var entries = builder.FromCpio(cpio);
var files = creator.CreateFiles(entries);
var originalMetadata = new RpmMetadata(originalPackage);
var originalFiles = originalMetadata.Files.ToArray();
Assert.Equal(originalFiles.Length, files.Count);
for (int i = 0; i < originalFiles.Length; i++)
{
var originalFile = originalFiles[i];
var file = files[i];
Assert.Equal(originalFile.Class, file.Class);
Assert.Equal(originalFile.Color, file.Color);
Assert.Equal(originalFile.Requires, file.Requires);
Assert.Equal(originalFile.Provides, file.Provides);
Assert.Equal(originalFile.Device, file.Device);
Assert.Equal(originalFile.Flags, file.Flags);
Assert.Equal(originalFile.GroupName, file.GroupName);
Assert.Equal(originalFile.Inode, file.Inode);
Assert.Equal(originalFile.Lang, file.Lang);
Assert.Equal(originalFile.LinkTo, file.LinkTo);
Assert.Equal(originalFile.MD5Hash, file.MD5Hash);
Assert.Equal(originalFile.Mode, file.Mode);
Assert.Equal(originalFile.ModifiedTime, file.ModifiedTime);
Assert.Equal(originalFile.Name, file.Name);
Assert.Equal(originalFile.Rdev, file.Rdev);
Assert.Equal(originalFile.Size, file.Size);
Assert.Equal(originalFile.UserName, file.UserName);
Assert.Equal(originalFile.VerifyFlags, file.VerifyFlags);
}
}
}
}
public void ReadRpmPackageTest()
{
using (Stream stream = File.OpenRead(@"Rpm\libplist-2.0.1.151-1.1.x86_64.rpm"))
{
var package = RpmPackageReader.Read(stream);
var names = RpmPayloadReader.Read(package);
}
}
public void ReadRpmPackageTest2()
{
using (Stream stream = File.OpenRead(@"Rpm\tomcat-8.0.44-1.fc27.noarch.rpm"))
{
var package = RpmPackageReader.Read(stream);
var records = package.Header.Records;
var names = RpmPayloadReader.Read(package);
}
}
public void ReadRpmPackageTest3()
{
using (Stream stream = File.OpenRead(@"Rpm\usbmuxd-1.1.0.95-11.11.x86_64.rpm"))
{
var package = RpmPackageReader.Read(stream);
var records = package.Header.Records;
var names = RpmPayloadReader.Read(package);
}
}
public void CreatePackageTest()
{
var krgen = PgpSigner.GenerateKeyRingGenerator("dotnet", "dotnet");
var secretKeyRing = krgen.GenerateSecretKeyRing();
var privateKey = secretKeyRing.GetSecretKey().ExtractPrivateKey("dotnet".ToCharArray());
var publicKey = secretKeyRing.GetPublicKey();
using (Stream stream = File.OpenRead(@"Rpm\libplist-2.0.1.151-1.1.x86_64.rpm"))
using (var targetStream = File.Open(@"RpmPackageCreatorTests_CreateTest.rpm", FileMode.Create, FileAccess.ReadWrite, FileShare.None))
{
var originalPackage = RpmPackageReader.Read(stream);
List <ArchiveEntry> archive = null;
using (var decompressedPayloadStream = RpmPayloadReader.GetDecompressedPayloadStream(originalPackage))
using (CpioFile cpio = new CpioFile(decompressedPayloadStream, leaveOpen: false))
{
ArchiveBuilder builder = new ArchiveBuilder();
archive = builder.FromCpio(cpio);
}
using (var decompressedPayloadStream = RpmPayloadReader.GetDecompressedPayloadStream(originalPackage))
using (var payloadStream = new MemoryStream())
{
decompressedPayloadStream.CopyTo(payloadStream);
payloadStream.Position = 0;
RpmPackageCreator creator = new RpmPackageCreator(new PlistFileAnalyzer());
creator.CreatePackage(
archive,
payloadStream,
"libplist",
"2.0.1.151",
"x86_64",
"1.1",
false,
null,
false,
null,
null,
null,
(metadata) => PlistMetadata.ApplyDefaultMetadata(metadata),
privateKey,
targetStream);
}
}
using (var targetStream = File.Open(@"RpmPackageCreatorTests_CreateTest.rpm", FileMode.Open, FileAccess.Read, FileShare.None))
{
var package = RpmPackageReader.Read(targetStream);
var metadata = new RpmMetadata(package);
var signature = new RpmSignature(package);
Assert.True(signature.Verify(publicKey));
}
}
public void VerifyTest()
{
using (Stream stream = File.OpenRead(@"Rpm/libplist-2.0.1.151-1.1.x86_64.rpm"))
using (Stream pgpKey = File.OpenRead(@"Rpm/_key.pub"))
{
var package = RpmPackageReader.Read(stream);
var signature = new RpmSignature(package);
signature.Verify(pgpKey);
}
}
public void WriteRpmPackageTest()
{
using (Stream stream = File.OpenRead(@"Rpm/libplist-2.0.1.151-1.1.x86_64.rpm"))
using (Stream expected = File.OpenRead(@"Rpm/libplist-2.0.1.151-1.1.x86_64.rpm"))
using (Stream actual = new MemoryStream())
using (Stream output = new ValidatingCompositeStream(null, actual, expected))
{
var package = RpmPackageReader.Read(stream);
RpmPackageWriter.Write(output, package);
}
}
public void CalculateOffsetTest()
{
using (Stream stream = File.OpenRead(@"Rpm/libplist-2.0.1.151-1.1.x86_64.rpm"))
{
var originalPackage = RpmPackageReader.Read(stream);
using (var payloadStream = RpmPayloadReader.GetDecompressedPayloadStream(originalPackage))
using (var cpio = new CpioFile(payloadStream, false))
{
ArchiveBuilder builder = new ArchiveBuilder(new PlistFileAnalyzer());
RpmPackageCreator creator = new RpmPackageCreator(new PlistFileAnalyzer());
var entries = builder.FromCpio(cpio);
var files = creator.CreateFiles(entries);
// Core routine to populate files and dependencies
RpmPackage package = new RpmPackage();
var metadata = new PublicRpmMetadata(package);
metadata.Name = "libplist";
metadata.Version = "2.0.1.151";
metadata.Arch = "x86_64";
metadata.Release = "1.1";
creator.AddPackageProvides(metadata);
creator.AddLdDependencies(metadata);
metadata.Files = files;
creator.AddRpmDependencies(metadata, null);
PlistMetadata.ApplyDefaultMetadata(metadata);
metadata.Vendor = "obs://build.opensuse.org/home:qmfrederik";
metadata.Description = "libplist is a library for manipulating Apple Binary and XML Property Lists";
metadata.Url = "http://www.libimobiledevice.org/";
metadata.Size = 0x26e6d;
metadata.ImmutableRegionSize = -976;
creator.CalculateHeaderOffsets(package);
foreach (var record in originalPackage.Header.Records)
{
if (record.Key == IndexTag.RPMTAG_HEADERIMMUTABLE)
{
continue;
}
this.AssertTagOffsetEqual(record.Key, originalPackage, package);
}
this.AssertTagOffsetEqual(IndexTag.RPMTAG_HEADERIMMUTABLE, originalPackage, package);
}
}
}
public void SignaturePropertiesTest()
{
using (Stream stream = File.OpenRead(@"Rpm/libplist-2.0.1.151-1.1.x86_64.rpm"))
{
var package = RpmPackageReader.Read(stream);
var signature = new RpmSignature(package);
Assert.Equal(package, signature.Package);
Assert.Equal(unchecked ((long)0xed356a6f4dec2b0a), signature.HeaderAndPayloadPgpSignature.KeyId);
Assert.Equal(0xfd84, signature.HeaderAndPayloadSize);
Assert.Equal(0x27430, signature.UncompressedPayloadSize);
Assert.Equal(unchecked ((long)0xed356a6f4dec2b0a), signature.HeaderPgpSignature.KeyId);
Assert.Equal(-112, signature.ImmutableRegionSize);
Assert.Equal(new byte[] { 0xd4, 0x8e, 0x07, 0xc5, 0x68, 0xbe, 0x27, 0xe2, 0x26, 0xcb, 0xb8, 0xaf, 0x0e, 0xf7, 0x32, 0xec }, signature.MD5Hash);
Assert.Equal(new byte[] { 0xd7, 0x2d, 0x1e, 0x8a, 0x93, 0x26, 0x43, 0x14, 0x72, 0xa1, 0xe3, 0x9e, 0x1b, 0x79, 0x16, 0xad, 0x07, 0xcc, 0xc3, 0x1b }, signature.Sha1Hash);
}
}
public void CreatePackageMetadata()
{
using (Stream stream = File.OpenRead(@"Rpm/libplist-2.0.1.151-1.1.x86_64.rpm"))
{
var originalPackage = RpmPackageReader.Read(stream);
using (var payloadStream = RpmPayloadReader.GetDecompressedPayloadStream(originalPackage))
using (var cpio = new CpioFile(payloadStream, false))
{
ArchiveBuilder builder = new ArchiveBuilder(new PlistFileAnalyzer());
RpmPackageCreator creator = new RpmPackageCreator(new PlistFileAnalyzer());
var entries = builder.FromCpio(cpio);
var files = creator.CreateFiles(entries);
// Core routine to populate files and dependencies
RpmPackage package = new RpmPackage();
var metadata = new PublicRpmMetadata(package);
metadata.Name = "libplist";
metadata.Version = "2.0.1.151";
metadata.Arch = "x86_64";
metadata.Release = "1.1";
creator.AddPackageProvides(metadata);
creator.AddLdDependencies(metadata);
metadata.Files = files;
creator.AddRpmDependencies(metadata, null);
PlistMetadata.ApplyDefaultMetadata(metadata);
metadata.Size = 0x26e6d;
metadata.ImmutableRegionSize = -976;
foreach (var record in originalPackage.Header.Records)
{
this.AssertTagEqual(record.Key, originalPackage, package);
}
}
}
}
public void CreatePackageBinaryTest()
{
var pgpSignatureData = File.ReadAllBytes("Rpm/RpmSigTag_Pgp.bin");
var rsaSignatureData = File.ReadAllBytes("Rpm/RpmSigTag_Rsa.bin");
var signer = new DummySigner();
signer.Add("D72D1E8A9326431472A1E39E1B7916AD07CCC31B", rsaSignatureData);
signer.Add("A0A33779FBBED565A15FA85BAFBD1473E00F1257", pgpSignatureData);
signer.Add("5E24172F773FEB67FC0BF4831BB4E8A75B4554EF", pgpSignatureData);
using (Stream stream = File.OpenRead(@"Rpm/libplist-2.0.1.151-1.1.x86_64.rpm"))
using (var targetStream = File.Open(@"RpmPackageCreatorTests_CreateBinaryTest.rpm", FileMode.Create, FileAccess.ReadWrite, FileShare.None))
{
var originalPackage = RpmPackageReader.Read(stream);
List <ArchiveEntry> archive = null;
using (var decompressedPayloadStream = RpmPayloadReader.GetDecompressedPayloadStream(originalPackage))
using (CpioFile cpio = new CpioFile(decompressedPayloadStream, leaveOpen: false))
{
ArchiveBuilder builder = new ArchiveBuilder();
archive = builder.FromCpio(cpio);
}
using (var compressedPayloadStream = RpmPayloadReader.GetCompressedPayloadStream(originalPackage))
{
RpmPackageCreator creator = new RpmPackageCreator(new PlistFileAnalyzer());
creator.CreatePackage(
archive,
compressedPayloadStream,
"libplist",
"2.0.1.151",
"x86_64",
"1.1",
false,
null,
false,
null,
null,
null,
null,
null,
null,
null,
(metadata) => PlistMetadata.ApplyDefaultMetadata(metadata),
signer,
targetStream,
includeVersionInName: true,
payloadIsCompressed: true);
}
}
using (var originalStream = File.OpenRead(@"Rpm/libplist-2.0.1.151-1.1.x86_64.rpm"))
using (var targetStream = File.Open(@"RpmPackageCreatorTests_CreateBinaryTest.rpm", FileMode.Open, FileAccess.Read, FileShare.None))
{
var originalPackage = RpmPackageReader.Read(originalStream);
var package = RpmPackageReader.Read(targetStream);
RpmDumper.Dump(originalPackage, "RpmPackageCreatorTests_CreateBinaryTest_original.txt");
RpmDumper.Dump(package, "RpmPackageCreatorTests_CreateBinaryTest_reconstructed.txt");
var metadata = new RpmMetadata(package);
var signature = new RpmSignature(package);
foreach (var record in originalPackage.Signature.Records)
{
this.AssertTagEqual(record.Key, originalPackage, package);
}
originalStream.Position = 0;
targetStream.Position = 0;
int index = 0;
byte[] originalBuffer = new byte[1024];
byte[] targetBuffer = new byte[1024];
while (originalStream.Position < originalStream.Length)
{
originalStream.Read(originalBuffer, 0, originalBuffer.Length);
targetStream.Read(targetBuffer, 0, targetBuffer.Length);
Assert.Equal(originalBuffer, targetBuffer);
index += originalBuffer.Length;
}
}
}
public void CreatePackageTest()
{
var krgen = PgpSigner.GenerateKeyRingGenerator("dotnet", "dotnet");
var secretKeyRing = krgen.GenerateSecretKeyRing();
var privateKey = secretKeyRing.GetSecretKey().ExtractPrivateKey("dotnet".ToCharArray());
var publicKey = secretKeyRing.GetPublicKey();
const string preInstScript = "echo preinst\n";
const string postInstScript = "echo postinst\n";
const string preRemoveScript = "echo preremove\n";
const string postRemoveScript = "echo postremove\n";
const string nameString = "libplist";
const string versionString = "2.0.1.151";
const string releaseString = "1.1";
const string archString = "x86_64";
using (Stream stream = File.OpenRead($"Rpm/{nameString}-{versionString}-{releaseString}.{archString}.rpm"))
using (var targetStream = File.Open(@"RpmPackageCreatorTests_CreateTest.rpm", FileMode.Create, FileAccess.ReadWrite, FileShare.None))
{
var originalPackage = RpmPackageReader.Read(stream);
List <ArchiveEntry> archive = null;
using (var decompressedPayloadStream = RpmPayloadReader.GetDecompressedPayloadStream(originalPackage))
using (CpioFile cpio = new CpioFile(decompressedPayloadStream, leaveOpen: false))
{
ArchiveBuilder builder = new ArchiveBuilder();
archive = builder.FromCpio(cpio);
}
using (var decompressedPayloadStream = RpmPayloadReader.GetDecompressedPayloadStream(originalPackage))
using (var payloadStream = new MemoryStream())
{
decompressedPayloadStream.CopyTo(payloadStream);
payloadStream.Position = 0;
RpmPackageCreator creator = new RpmPackageCreator(new PlistFileAnalyzer());
creator.CreatePackage(
archive,
payloadStream,
nameString,
versionString,
archString,
releaseString,
false,
null,
false,
null,
null,
preInstScript,
postInstScript,
preRemoveScript,
postRemoveScript,
null,
(metadata) => PlistMetadata.ApplyDefaultMetadata(metadata),
privateKey,
targetStream);
}
}
using (var targetStream = File.Open(@"RpmPackageCreatorTests_CreateTest.rpm", FileMode.Open, FileAccess.Read, FileShare.None))
{
var package = RpmPackageReader.Read(targetStream);
var metadata = new RpmMetadata(package);
Assert.Equal(metadata.Version, versionString);
Assert.Equal(metadata.Name, nameString);
Assert.Equal(metadata.Arch, archString);
Assert.Equal(metadata.Release, releaseString);
Assert.StartsWith(preInstScript, metadata.PreIn);
Assert.StartsWith(postInstScript, metadata.PostIn);
Assert.StartsWith(preRemoveScript, metadata.PreUn);
Assert.StartsWith(postRemoveScript, metadata.PostUn);
var signature = new RpmSignature(package);
Assert.True(signature.Verify(publicKey));
}
}
public void CalculateSignatureTest()
{
using (Stream stream = File.OpenRead(@"Rpm/libplist-2.0.1.151-1.1.x86_64.rpm"))
{
var originalPackage = RpmPackageReader.Read(stream);
RpmPackageCreator creator = new RpmPackageCreator(new PlistFileAnalyzer());
Collection <RpmFile> files;
using (var payloadStream = RpmPayloadReader.GetDecompressedPayloadStream(originalPackage))
using (var cpio = new CpioFile(payloadStream, false))
{
ArchiveBuilder builder = new ArchiveBuilder(new PlistFileAnalyzer());
var entries = builder.FromCpio(cpio);
files = creator.CreateFiles(entries);
}
// Core routine to populate files and dependencies
RpmPackage package = new RpmPackage();
var metadata = new PublicRpmMetadata(package);
metadata.Name = "libplist";
metadata.Version = "2.0.1.151";
metadata.Arch = "x86_64";
metadata.Release = "1.1";
creator.AddPackageProvides(metadata);
creator.AddLdDependencies(metadata);
metadata.Files = files;
creator.AddRpmDependencies(metadata, null);
PlistMetadata.ApplyDefaultMetadata(metadata);
creator.CalculateHeaderOffsets(package);
// Make sure the header is really correct
using (Stream originalHeaderStream = new SubStream(
originalPackage.Stream,
originalPackage.HeaderOffset,
originalPackage.PayloadOffset - originalPackage.HeaderOffset,
leaveParentOpen: true,
readOnly: true))
using (Stream headerStream = creator.GetHeaderStream(package))
{
byte[] originalData = new byte[originalHeaderStream.Length];
originalHeaderStream.Read(originalData, 0, originalData.Length);
byte[] data = new byte[headerStream.Length];
headerStream.Read(data, 0, data.Length);
int delta = 0;
int dataDelta = 0;
IndexTag tag;
for (int i = 0; i < data.Length; i++)
{
if (originalData[i] != data[i])
{
delta = i;
dataDelta = delta - package.Header.Records.Count * Marshal.SizeOf <IndexHeader>();
tag = package.Header.Records.OrderBy(r => r.Value.Header.Offset).Last(r => r.Value.Header.Offset <= dataDelta).Key;
break;
}
}
Assert.Equal(originalData, data);
}
var krgen = PgpSigner.GenerateKeyRingGenerator("dotnet", "dotnet");
var secretKeyRing = krgen.GenerateSecretKeyRing();
var privateKey = secretKeyRing.GetSecretKey().ExtractPrivateKey("dotnet".ToCharArray());
using (var payload = RpmPayloadReader.GetCompressedPayloadStream(originalPackage))
{
// Header should be OK now (see previous test), so now get the signature block and the
// trailer
creator.CalculateSignature(package, privateKey, payload);
creator.CalculateSignatureOffsets(package);
foreach (var record in originalPackage.Signature.Records)
{
if (record.Key == SignatureTag.RPMTAG_HEADERSIGNATURES)
{
continue;
}
this.AssertTagEqual(record.Key, originalPackage, package);
}
this.AssertTagEqual(SignatureTag.RPMTAG_HEADERSIGNATURES, originalPackage, package);
}
}
}
public void ReadMetadataPropertiesTest()
{
using (Stream stream = File.OpenRead(@"Rpm/libplist-2.0.1.151-1.1.x86_64.rpm"))
{
var package = RpmPackageReader.Read(stream);
var metadata = new RpmMetadata(package);
var headerRecords = package.Header.Records;
Assert.Equal(package, metadata.Package);
Assert.Equal("x86_64", metadata.Arch);
Assert.Equal("lamb11", metadata.BuildHost);
Assert.Equal(new DateTimeOffset(2017, 04, 21, 20, 56, 28, TimeSpan.Zero), metadata.BuildTime);
Assert.Equal("lamb11 1492808188", metadata.Cookie);
Assert.Equal("libplist is a library for manipulating Apple Binary and XML Property Lists", metadata.Description);
Assert.Equal("home:qmfrederik / CentOS_7", metadata.Distribution);
Assert.Equal("obs://build.opensuse.org/home:qmfrederik/CentOS_7/adfeea138cd469466e6fa13a3c88fb8f-libplist", metadata.DistUrl);
Assert.Equal(PgpHashAlgo.PGPHASHALGO_SHA256, metadata.FileDigetsAlgo);
Assert.Equal("System Environment/Libraries", metadata.Group);
Assert.Equal(-976, metadata.ImmutableRegionSize);
Assert.Equal("LGPLv2+", metadata.License);
Assert.Equal(new Collection <string>()
{
"C"
}, metadata.Locales);
Assert.Equal("libplist", metadata.Name);
Assert.Equal("-O2 -g -pipe -Wall -Wp,-D_FORTIFY_SOURCE=2 -fexceptions -fstack-protector-strong --param=ssp-buffer-size=4 -grecord-gcc-switches -m64 -mtune=generic", metadata.OptFlags);
Assert.Equal("linux", metadata.Os);
Assert.Equal("xz", metadata.PayloadCompressor);
Assert.Equal("2", metadata.PayloadFlags);
Assert.Equal("cpio", metadata.PayloadFormat);
Assert.Equal("x86_64-redhat-linux-gnu", metadata.Platform);
Assert.Equal("/sbin/ldconfig", metadata.PostInProg);
Assert.Equal("/sbin/ldconfig", metadata.PostUnProg);
Assert.Equal("1.1", metadata.Release);
Assert.Equal("4.11.3", metadata.RpmVersion);
Assert.Equal(0x26e6d, metadata.Size);
Assert.Equal(new byte[] { 0x45, 0xc0, 0x86, 0x80, 0x77, 0x4e, 0xf4, 0xc0, 0x37, 0xf1, 0x1e, 0xb1, 0xd3, 0x47, 0xf0, 0xbf }, metadata.SourcePkgId);
Assert.Equal("libplist-2.0.1.151-1.1.src.rpm", metadata.SourceRpm);
Assert.Equal("Library for manipulating Apple Binary and XML Property Lists", metadata.Summary);
Assert.Equal("http://www.libimobiledevice.org/", metadata.Url);
Assert.Equal("obs://build.opensuse.org/home:qmfrederik", metadata.Vendor);
Assert.Equal("2.0.1.151", metadata.Version);
var entries = metadata.ChangelogEntries.ToArray();
Assert.Equal(0x21, entries.Length);
Assert.Equal(new DateTimeOffset(2014, 1, 24, 12, 0, 0, TimeSpan.Zero), entries[0].Date);
Assert.Equal("Daniel Mach <*****@*****.**> - 1.10-4", entries[0].Name);
Assert.Equal("- Mass rebuild 2014-01-24", entries[0].Text);
var files = metadata.Files.ToArray();
Assert.Equal(9, files.Length);
Assert.Equal("ELF 64-bit LSB executable, x86-64, version 1 (SYSV), dynamically linked (uses shared libs), for GNU/Linux 2.6.32, BuildID[sha1]=44864a4aec49ec94f3dc1486068ff0d308e3ae37, stripped", files[0].Class);
Assert.Equal(RpmFileColor.RPMFC_ELF64, files[0].Color);
Assert.Equal(6, files[0].Requires.Count);
Assert.Equal("libpthread.so.0(GLIBC_2.2.5)(64bit)", files[0].Requires[0].Name);
Assert.Equal(RpmSense.RPMSENSE_FIND_REQUIRES, files[0].Requires[0].Flags);
Assert.Equal(string.Empty, files[0].Requires[0].Version);
Assert.Equal(1, files[0].Device);
Assert.Equal(RpmFileFlags.None, files[0].Flags);
Assert.Equal("root", files[0].GroupName);
Assert.Equal(1, files[0].Inode);
Assert.Equal(string.Empty, files[0].Lang);
Assert.Equal(string.Empty, files[0].LinkTo);
Assert.Equal(new byte[] { 0xf5, 0x17, 0x06, 0x2e, 0xe2, 0x60, 0xd9, 0x30, 0x4e, 0x74, 0xef, 0xed, 0xbb, 0x51, 0xf2, 0x53, 0x21, 0xde, 0xd8, 0x71, 0xcb, 0xb7, 0xcc, 0x68, 0x0c, 0xa2, 0x9b, 0x48, 0x0a, 0x11, 0x03, 0xbd }, files[0].MD5Hash);
Assert.Equal(LinuxFileMode.S_IXOTH | LinuxFileMode.S_IROTH | LinuxFileMode.S_IXGRP | LinuxFileMode.S_IRGRP | LinuxFileMode.S_IXUSR | LinuxFileMode.S_IWUSR | LinuxFileMode.S_IRUSR | LinuxFileMode.S_IFREG, files[0].Mode);
Assert.Equal(new DateTimeOffset(2017, 4, 21, 20, 56, 27, TimeSpan.Zero), files[0].ModifiedTime);
Assert.Equal(0, files[0].Rdev);
Assert.Equal(0x2ca0, files[0].Size);
Assert.Equal("root", files[0].UserName);
Assert.Equal(RpmVerifyFlags.RPMVERIFY_ALL, files[0].VerifyFlags);
Assert.Equal("/usr/bin/plistutil", files[0].Name);
var dependencies = metadata.Dependencies.ToArray();
Assert.Equal(0x13, dependencies.Length);
Assert.Equal(RpmSense.RPMSENSE_INTERP | RpmSense.RPMSENSE_SCRIPT_POST, dependencies[0].Flags);
Assert.Equal(string.Empty, dependencies[0].Version);
Assert.Equal("/sbin/ldconfig", dependencies[0].Name);
var provides = metadata.Provides.ToArray();
Assert.Equal(4, provides.Length);
Assert.Equal(RpmSense.RPMSENSE_EQUAL, provides[0].Flags);
Assert.Equal("2.0.1.151-1.1", provides[0].Version);
Assert.Equal("libplist", provides[0].Name);
}
}
public void SetFilesTest()
{
using (Stream stream = File.OpenRead(@"Rpm/libplist-2.0.1.151-1.1.x86_64.rpm"))
{
var originalPackage = RpmPackageReader.Read(stream);
var package = new RpmPackage();
using (var payloadStream = RpmPayloadReader.GetDecompressedPayloadStream(originalPackage))
using (var cpio = new CpioFile(payloadStream, false))
{
ArchiveBuilder builder = new ArchiveBuilder(new PlistFileAnalyzer());
RpmPackageCreator creator = new RpmPackageCreator(new PlistFileAnalyzer());
var entries = builder.FromCpio(cpio);
var files = creator.CreateFiles(entries);
var metadata = new PublicRpmMetadata(package);
metadata.Name = "libplist";
metadata.Version = "2.0.1.151";
metadata.Arch = "x86_64";
metadata.Release = "1.1";
creator.AddPackageProvides(metadata);
creator.AddLdDependencies(metadata);
metadata.Files = files;
creator.AddRpmDependencies(metadata, null);
this.AssertTagEqual(IndexTag.RPMTAG_FILESIZES, originalPackage, package);
this.AssertTagEqual(IndexTag.RPMTAG_FILEMODES, originalPackage, package);
this.AssertTagEqual(IndexTag.RPMTAG_FILERDEVS, originalPackage, package);
this.AssertTagEqual(IndexTag.RPMTAG_FILEMTIMES, originalPackage, package);
this.AssertTagEqual(IndexTag.RPMTAG_FILEDIGESTS, originalPackage, package);
this.AssertTagEqual(IndexTag.RPMTAG_FILELINKTOS, originalPackage, package);
this.AssertTagEqual(IndexTag.RPMTAG_FILEFLAGS, originalPackage, package);
this.AssertTagEqual(IndexTag.RPMTAG_FILEUSERNAME, originalPackage, package);
this.AssertTagEqual(IndexTag.RPMTAG_FILEGROUPNAME, originalPackage, package);
this.AssertTagEqual(IndexTag.RPMTAG_FILEVERIFYFLAGS, originalPackage, package);
this.AssertTagEqual(IndexTag.RPMTAG_FILEDEVICES, originalPackage, package);
this.AssertTagEqual(IndexTag.RPMTAG_FILEINODES, originalPackage, package);
this.AssertTagEqual(IndexTag.RPMTAG_FILELANGS, originalPackage, package);
this.AssertTagEqual(IndexTag.RPMTAG_FILECOLORS, originalPackage, package);
this.AssertTagEqual(IndexTag.RPMTAG_FILECLASS, originalPackage, package);
this.AssertTagEqual(IndexTag.RPMTAG_CLASSDICT, originalPackage, package);
this.AssertTagEqual(IndexTag.RPMTAG_BASENAMES, originalPackage, package);
this.AssertTagEqual(IndexTag.RPMTAG_DIRINDEXES, originalPackage, package);
this.AssertTagEqual(IndexTag.RPMTAG_DIRNAMES, originalPackage, package);
// The require and provides records contain file dependencies, as well as package dependencies.
// That's why there's a call to AddLdDependencies and AddRpmDependencies, to make sure
// these dependencies are written out in order.
this.AssertTagEqual(IndexTag.RPMTAG_REQUIRENAME, originalPackage, package);
this.AssertTagEqual(IndexTag.RPMTAG_REQUIREFLAGS, originalPackage, package);
this.AssertTagEqual(IndexTag.RPMTAG_REQUIREVERSION, originalPackage, package);
this.AssertTagEqual(IndexTag.RPMTAG_PROVIDENAME, originalPackage, package);
this.AssertTagEqual(IndexTag.RPMTAG_PROVIDEFLAGS, originalPackage, package);
this.AssertTagEqual(IndexTag.RPMTAG_REQUIREVERSION, originalPackage, package);
this.AssertTagEqual(IndexTag.RPMTAG_FILEDEPENDSN, originalPackage, package);
this.AssertTagEqual(IndexTag.RPMTAG_FILEDEPENDSX, originalPackage, package);
this.AssertTagEqual(IndexTag.RPMTAG_DEPENDSDICT, originalPackage, package);
}
}
}
