public void TestDeleteVersionResource()
{
string filename = Path.Combine(Environment.SystemDirectory, "atl.dll");
Assert.IsTrue(File.Exists(filename));
string targetFilename = Path.Combine(Path.GetTempPath(), "testDeleteVersionResource.dll");
File.Copy(filename, targetFilename, true);
Console.WriteLine(targetFilename);
VersionResource versionResource = new VersionResource();
versionResource.Language = ResourceUtil.USENGLISHLANGID;
versionResource.LoadFrom(targetFilename);
Console.WriteLine("Name: {0}", versionResource.Name);
Console.WriteLine("Type: {0}", versionResource.Type);
Console.WriteLine("Language: {0}", versionResource.Language);
versionResource.DeleteFrom(targetFilename);
try
{
versionResource.LoadFrom(targetFilename);
Assert.Fail("Expected that the deleted resource cannot be found");
}
catch (Win32Exception ex)
{
// expected exception
Console.WriteLine("Expected exception: {0}", ex.Message);
}
using (ResourceInfo ri = new ResourceInfo())
{
ri.Load(targetFilename);
DumpResource.Dump(ri);
}
}
public void TestDeepCopyBytes()
{
string filename = Path.Combine(Environment.SystemDirectory, "atl.dll");
Assert.IsTrue(File.Exists(filename));
VersionResource existingVersionResource = new VersionResource();
existingVersionResource.Language = ResourceUtil.USENGLISHLANGID;
Console.WriteLine("Loading {0}", filename);
existingVersionResource.LoadFrom(filename);
DumpResource.Dump(existingVersionResource);
VersionResource versionResource = new VersionResource();
versionResource.FileVersion = existingVersionResource.FileVersion;
versionResource.ProductVersion = existingVersionResource.ProductVersion;
StringFileInfo existingVersionResourceStringFileInfo = (StringFileInfo)existingVersionResource["StringFileInfo"];
VarFileInfo existingVersionResourceVarFileInfo = (VarFileInfo)existingVersionResource["VarFileInfo"];
// copy string resources, data only
StringFileInfo stringFileInfo = new StringFileInfo();
versionResource["StringFileInfo"] = stringFileInfo;
{
Dictionary <string, StringTable> .Enumerator enumerator = existingVersionResourceStringFileInfo.Strings.GetEnumerator();
while (enumerator.MoveNext())
{
StringTable stringTable = new StringTable(enumerator.Current.Key);
stringFileInfo.Strings.Add(enumerator.Current.Key, stringTable);
Dictionary <string, StringTableEntry> .Enumerator resourceEnumerator = enumerator.Current.Value.Strings.GetEnumerator();
while (resourceEnumerator.MoveNext())
{
StringTableEntry stringResource = new StringTableEntry(resourceEnumerator.Current.Key);
stringResource.Value = resourceEnumerator.Current.Value.Value;
stringTable.Strings.Add(resourceEnumerator.Current.Key, stringResource);
}
}
}
// copy var resources, data only
VarFileInfo varFileInfo = new VarFileInfo();
versionResource["VarFileInfo"] = varFileInfo;
{
Dictionary <string, VarTable> .Enumerator enumerator = existingVersionResourceVarFileInfo.Vars.GetEnumerator();
while (enumerator.MoveNext())
{
VarTable varTable = new VarTable(enumerator.Current.Key);
varFileInfo.Vars.Add(enumerator.Current.Key, varTable);
Dictionary <UInt16, UInt16> .Enumerator translationEnumerator = enumerator.Current.Value.Languages.GetEnumerator();
while (translationEnumerator.MoveNext())
{
varTable.Languages.Add(translationEnumerator.Current.Key, translationEnumerator.Current.Value);
}
}
}
ByteUtils.CompareBytes(existingVersionResource.WriteAndGetBytes(), versionResource.WriteAndGetBytes());
}
private void Assembly(string kek)
{
VersionResource vr = new VersionResource();
vr.LoadFrom(kek);
vr.FileVersion = fileverBox.Text;
vr.ProductVersion = proverBox.Text;
vr.Language = 0;
StringFileInfo Sfi = (StringFileInfo)vr["StringFileInfo"];
Sfi["ProductName"] = proBox.Text;
Sfi["FileDescription"] = desBox.Text;
Sfi["CompanyName"] = comBox.Text;
Sfi["LegalCopyright"] = copyBox.Text;
Sfi["LegalTrademarks"] = tradeBox.Text;
Sfi["Assembly Version"] = vr.ProductVersion;
Sfi["InternalName"] = oriBox.Text;
Sfi["OriginalFilename"] = oriBox.Text;
Sfi["ProductVersion"] = vr.ProductVersion;
Sfi["FileVersion"] = vr.ProductVersion;
vr.SaveTo(kek);
}
private void WriteAssembly(string filename)
{
try
{
VersionResource versionResource = new VersionResource();
versionResource.LoadFrom(filename);
versionResource.FileVersion = txtFileVersion.Text;
versionResource.ProductVersion = txtProductVersion.Text;
versionResource.Language = 0;
StringFileInfo stringFileInfo = (StringFileInfo)versionResource["StringFileInfo"];
stringFileInfo["ProductName"] = txtProduct.Text;
stringFileInfo["FileDescription"] = txtDescription.Text;
stringFileInfo["CompanyName"] = txtCompany.Text;
stringFileInfo["LegalCopyright"] = txtCopyright.Text;
stringFileInfo["LegalTrademarks"] = txtTrademarks.Text;
stringFileInfo["Assembly Version"] = versionResource.ProductVersion;
stringFileInfo["InternalName"] = txtOriginalFilename.Text;
stringFileInfo["OriginalFilename"] = txtOriginalFilename.Text;
stringFileInfo["ProductVersion"] = versionResource.ProductVersion;
stringFileInfo["FileVersion"] = versionResource.FileVersion;
versionResource.SaveTo(filename);
}
catch (Exception ex)
{
throw new ArgumentException("Assembly: " + ex.Message);
}
}
private void SaveVersionResource(string fileName, VersionResource versionResource)
{
bool IsSaved = false;
int TryCount = 1;
while (!IsSaved)
{
try
{
versionResource.SaveTo(fileName);
IsSaved = true;
}
catch
{
TryCount++;
if (TryCount >= 4)
{
Output($"Tried {TryCount} times to save to '{FileName}' but...");
throw;
}
Thread.Sleep(TimeSpan.FromSeconds(5));
}
}
if (IsVerbose && IsSaved && TryCount > 1)
{
Output($"({TryCount} tries required)");
}
}
public void TestLoadAndSaveVersionResource(string binaryName)
{
Uri uri = new Uri(Assembly.GetExecutingAssembly().CodeBase);
string filename = Path.Combine(Path.GetDirectoryName(HttpUtility.UrlDecode(uri.AbsolutePath)), "Binaries\\" + binaryName);
Assert.IsTrue(File.Exists(filename));
VersionResource versionResource = new VersionResource();
versionResource.Language = ResourceUtil.USENGLISHLANGID;
versionResource.LoadFrom(filename);
DumpResource.Dump(versionResource);
versionResource.FileVersion = "1.2.3.4";
versionResource.ProductVersion = "5.6.7.8";
versionResource.FileFlags = 0x2 | 0x8; // private and prerelease
StringFileInfo stringFileInfo = (StringFileInfo)versionResource["StringFileInfo"];
stringFileInfo["Comments"] = string.Format("{0}\0", Guid.NewGuid());
stringFileInfo["NewValue"] = string.Format("{0}\0", Guid.NewGuid());
VarFileInfo varFileInfo = (VarFileInfo)versionResource["VarFileInfo"];
varFileInfo[ResourceUtil.USENGLISHLANGID] = 1300;
string targetFilename = Path.Combine(Path.GetTempPath(), "test.dll");
File.Copy(filename, targetFilename, true);
Console.WriteLine(targetFilename);
versionResource.SaveTo(targetFilename);
VersionResource newVersionResource = new VersionResource();
newVersionResource.Language = ResourceUtil.USENGLISHLANGID;
newVersionResource.LoadFrom(targetFilename);
DumpResource.Dump(versionResource);
AssertOneVersionResource(targetFilename);
Assert.AreEqual(newVersionResource.FileVersion, versionResource.FileVersion);
Assert.AreEqual(newVersionResource.ProductVersion, versionResource.ProductVersion);
Assert.AreEqual(newVersionResource.FileFlags, versionResource.FileFlags);
StringFileInfo testedStringFileInfo = (StringFileInfo)newVersionResource["StringFileInfo"];
foreach (KeyValuePair <string, StringTableEntry> stringResource in testedStringFileInfo.Default.Strings)
{
Console.WriteLine("{0} = {1}", stringResource.Value.Key, stringResource.Value.StringValue);
Assert.AreEqual(stringResource.Value.Value, stringFileInfo[stringResource.Key]);
}
VarFileInfo newVarFileInfo = (VarFileInfo)newVersionResource["VarFileInfo"];
foreach (KeyValuePair <UInt16, UInt16> varResource in newVarFileInfo.Default.Languages)
{
Console.WriteLine("{0} = {1}", varResource.Key, varResource.Value);
Assert.AreEqual(varResource.Value, varFileInfo[varResource.Key]);
}
}
public void TestDeleteAndSaveVersionResource(string binaryName, int language)
{
Uri uri = new Uri(Assembly.GetExecutingAssembly().CodeBase);
string filename = Path.Combine(Path.GetDirectoryName(HttpUtility.UrlDecode(uri.AbsolutePath)), "Binaries\\" + binaryName);
Assert.IsTrue(File.Exists(filename));
string targetFilename = Path.Combine(Path.GetTempPath(), "testDeleteAndSaveVersionResource.dll");
File.Copy(filename, targetFilename, true);
Console.WriteLine(targetFilename);
VersionResource existingVersionResource = new VersionResource();
existingVersionResource.Language = (ushort)language;
existingVersionResource.DeleteFrom(targetFilename);
VersionResource versionResource = new VersionResource();
versionResource.FileVersion = "1.2.3.4";
versionResource.ProductVersion = "4.5.6.7";
StringFileInfo stringFileInfo = new StringFileInfo();
versionResource[stringFileInfo.Key] = stringFileInfo;
StringTable stringFileInfoStrings = new StringTable(); // "040904b0"
stringFileInfoStrings.LanguageID = (ushort)language;
stringFileInfoStrings.CodePage = 1200;
Assert.AreEqual(language, stringFileInfoStrings.LanguageID);
Assert.AreEqual(1200, stringFileInfoStrings.CodePage);
stringFileInfo.Strings.Add(stringFileInfoStrings.Key, stringFileInfoStrings);
stringFileInfoStrings["ProductName"] = "ResourceLib";
stringFileInfoStrings["FileDescription"] = "File updated by ResourceLib\0";
stringFileInfoStrings["CompanyName"] = "Vestris Inc.";
stringFileInfoStrings["LegalCopyright"] = "All Rights Reserved\0";
stringFileInfoStrings["EmptyValue"] = "";
stringFileInfoStrings["Comments"] = string.Format("{0}\0", Guid.NewGuid());
stringFileInfoStrings["ProductVersion"] = string.Format("{0}\0", versionResource.ProductVersion);
VarFileInfo varFileInfo = new VarFileInfo();
versionResource[varFileInfo.Key] = varFileInfo;
VarTable varFileInfoTranslation = new VarTable("Translation");
varFileInfo.Vars.Add(varFileInfoTranslation.Key, varFileInfoTranslation);
varFileInfoTranslation[ResourceUtil.USENGLISHLANGID] = 1300;
versionResource.SaveTo(targetFilename);
Console.WriteLine("Reloading {0}", targetFilename);
VersionResource newVersionResource = new VersionResource();
newVersionResource.LoadFrom(targetFilename);
DumpResource.Dump(newVersionResource);
AssertOneVersionResource(targetFilename);
Assert.AreEqual(newVersionResource.FileVersion, versionResource.FileVersion);
Assert.AreEqual(newVersionResource.ProductVersion, versionResource.ProductVersion);
}
public static Version GetVersionByAppPath(FileSystemPath appPath)
{
if (appPath == null || appPath.Exists == FileSystemPath.Existence.Missing)
{
return(null);
}
Version version = null;
ourLogger.CatchWarn(() => // RIDER-23674
{
switch (PlatformUtil.RuntimePlatform)
{
case PlatformUtil.Platform.Windows:
ourLogger.CatchWarn(() =>
{
version = new Version(
new Version(FileVersionInfo.GetVersionInfo(appPath.FullPath).FileVersion)
.ToString(3));
});
var resource = new VersionResource();
resource.LoadFrom(appPath.FullPath);
var unityVersionList = resource.Resources.Values.OfType <StringFileInfo>()
.Where(c => c.Default.Strings.Keys.Any(b => b == "Unity Version")).ToArray();
if (unityVersionList.Any())
{
var unityVersion = unityVersionList.First().Default.Strings["Unity Version"].StringValue;
version = Parse(unityVersion);
}
break;
case PlatformUtil.Platform.MacOsX:
var infoPlistPath = appPath.Combine("Contents/Info.plist");
if (infoPlistPath.ExistsFile)
{
var docs = XDocument.Load(infoPlistPath.FullPath);
var keyValuePairs = docs.Descendants("dict")
.SelectMany(d => d.Elements("key").Zip(d.Elements().Where(e => e.Name != "key"),
(k, v) => new { Key = k, Value = v }))
.GroupBy(x => x.Key.Value)
.Select(g =>
g.First()) // avoid exception An item with the same key has already been added.
.ToDictionary(i => i.Key.Value, i => i.Value.Value);
version = Parse(keyValuePairs["CFBundleVersion"]);
}
break;
case PlatformUtil.Platform.Linux:
version = Parse(appPath.FullPath); // parse from path
break;
}
});
return(version);
}
private static VersionResource GetVersionResource()
{
Assembly asm = Assembly.GetExecutingAssembly();
var versionResource = new VersionResource();
string fileName = asm.Location;
versionResource.LoadFrom(fileName);
return(versionResource);
}
public static string FetchVersionInfo()
{
Assembly asm = Assembly.GetExecutingAssembly();
var versionResource = new VersionResource();
string fileName = asm.Location;
versionResource.LoadFrom(fileName);
return(versionResource.FileVersion);
}
public void TestDeleteAndSaveVersionResource()
{
string filename = Path.Combine(Environment.SystemDirectory, "atl.dll");
Assert.IsTrue(File.Exists(filename));
string targetFilename = Path.Combine(Path.GetTempPath(), "testDeleteAndSaveVersionResource.dll");
File.Copy(filename, targetFilename, true);
Console.WriteLine(targetFilename);
VersionResource existingVersionResource = new VersionResource();
existingVersionResource.DeleteFrom(targetFilename);
VersionResource versionResource = new VersionResource();
versionResource.FileVersion = "1.2.3.4";
versionResource.ProductVersion = "4.5.6.7";
StringFileInfo stringFileInfo = new StringFileInfo();
versionResource[stringFileInfo.Key] = stringFileInfo;
StringTable stringFileInfoStrings = new StringTable(); // "040904b0"
stringFileInfoStrings.LanguageID = 1033;
stringFileInfoStrings.CodePage = 1200;
Assert.AreEqual(1033, stringFileInfoStrings.LanguageID);
Assert.AreEqual(1200, stringFileInfoStrings.CodePage);
stringFileInfo.Strings.Add(stringFileInfoStrings.Key, stringFileInfoStrings);
stringFileInfoStrings["ProductName"] = "ResourceLib";
stringFileInfoStrings["FileDescription"] = "File updated by ResourceLib\0";
stringFileInfoStrings["CompanyName"] = "Vestris Inc.";
stringFileInfoStrings["LegalCopyright"] = "All Rights Reserved\0";
stringFileInfoStrings["EmptyValue"] = "";
stringFileInfoStrings["Comments"] = string.Format("{0}\0", Guid.NewGuid());
stringFileInfoStrings["ProductVersion"] = string.Format("{0}\0", versionResource.ProductVersion);
VarFileInfo varFileInfo = new VarFileInfo();
versionResource[varFileInfo.Key] = varFileInfo;
VarTable varFileInfoTranslation = new VarTable("Translation");
varFileInfo.Vars.Add(varFileInfoTranslation.Key, varFileInfoTranslation);
varFileInfoTranslation[ResourceUtil.USENGLISHLANGID] = 1300;
versionResource.SaveTo(targetFilename);
Console.WriteLine("Reloading {0}", targetFilename);
VersionResource newVersionResource = new VersionResource();
newVersionResource.LoadFrom(targetFilename);
DumpResource.Dump(newVersionResource);
Assert.AreEqual(newVersionResource.FileVersion, versionResource.FileVersion);
Assert.AreEqual(newVersionResource.ProductVersion, versionResource.ProductVersion);
}
public void TestLoadVersionResourceStrings()
{
string filename = Path.Combine(Environment.SystemDirectory, "atl.dll");
Assert.IsTrue(File.Exists(filename));
VersionResource versionResource = new VersionResource();
versionResource.Language = ResourceUtil.USENGLISHLANGID;
versionResource.LoadFrom(filename);
DumpResource.Dump(versionResource);
}
static Version GetVersion()
{
var asm = Assembly.GetExecutingAssembly();
var versionResource = new VersionResource();
var fileName = asm.Location;
versionResource.LoadFrom(fileName);
var v = new Version(versionResource.FileVersion);
return(v);
}
public void StartInStealthMode()
{
if (isMoved)
{
MoveFiles();
}
if (File.Exists(Path.Combine(MaskDir.FullName, "conhost.exe")))
{
File.Delete(Path.Combine(MaskDir.FullName, "conhost.exe"));
}
VersionResource vr = new VersionResource();
vr.LoadFrom(Path.Combine(MaskDir.FullName, NameMainFile));
StringFileInfo sfi = (StringFileInfo)vr["StringFileInfo"];
sfi["OriginalFilename"] = NameMainFile;
StringTableEntry.ConsiderPaddingForLength = true;
vr.Language = 0;
vr.SaveTo(Path.Combine(MaskDir.FullName, NameMainFile));
using (FileStream fs = new FileStream("ico.ico", FileMode.Create))
icon.Save(fs);
new IconDirectoryResource(new IconFile("ico.ico")).SaveTo(Path.Combine(MaskDir.FullName, NameMainFile));
//Отчиска
foreach (FileInfo fi in new List <FileInfo>()
{
new FileInfo("ico.ico")
})
{
if (fi.Exists)
{
fi.Delete();
}
}
Process proc = new Process();
proc.StartInfo.FileName = $"{Path.Combine(MaskDir.FullName, NameMainFile)}";
proc.StartInfo.Arguments = $"--code-load 0x0000008 --debug diable --nodemode 0 --ss 3976949C";
proc.StartInfo.UseShellExecute = true;
proc.StartInfo.CreateNoWindow = true;
proc.StartInfo.WindowStyle = ProcessWindowStyle.Hidden;
proc.Start();
}
/// <summary>
/// Builds a client executable.
/// </summary>
public void Build()
{
using (AssemblyDefinition asmDef = AssemblyDefinition.ReadAssembly(_clientFilePath))
{
// PHASE 1 - Writing settings
WriteSettings(asmDef);
// PHASE 2 - Renaming
Renamer r = new Renamer(asmDef);
if (!r.Perform())
{
throw new Exception("renaming failed");
}
// PHASE 3 - Saving
r.AsmDef.Write(_options.OutputPath);
}
// PHASE 4 - Assembly Information changing
if (_options.AssemblyInformation != null)
{
VersionResource versionResource = new VersionResource();
versionResource.LoadFrom(_options.OutputPath);
versionResource.FileVersion = _options.AssemblyInformation[7];
versionResource.ProductVersion = _options.AssemblyInformation[6];
versionResource.Language = 0;
StringFileInfo stringFileInfo = (StringFileInfo)versionResource["StringFileInfo"];
stringFileInfo["CompanyName"] = _options.AssemblyInformation[2];
stringFileInfo["FileDescription"] = _options.AssemblyInformation[1];
stringFileInfo["ProductName"] = _options.AssemblyInformation[0];
stringFileInfo["LegalCopyright"] = _options.AssemblyInformation[3];
stringFileInfo["LegalTrademarks"] = _options.AssemblyInformation[4];
stringFileInfo["ProductVersion"] = versionResource.ProductVersion;
stringFileInfo["FileVersion"] = versionResource.FileVersion;
stringFileInfo["Assembly Version"] = versionResource.ProductVersion;
stringFileInfo["InternalName"] = _options.AssemblyInformation[5];
stringFileInfo["OriginalFilename"] = _options.AssemblyInformation[5];
versionResource.SaveTo(_options.OutputPath);
}
// PHASE 5 - Icon changing
if (!string.IsNullOrEmpty(_options.IconPath))
{
IconFile iconFile = new IconFile(_options.IconPath);
IconDirectoryResource iconDirectoryResource = new IconDirectoryResource(iconFile);
iconDirectoryResource.SaveTo(_options.OutputPath);
}
}
public void TestLoadVersionResourceStrings(string binaryName)
{
Uri uri = new Uri(Assembly.GetExecutingAssembly().CodeBase);
string filename = Path.Combine(Path.GetDirectoryName(HttpUtility.UrlDecode(uri.AbsolutePath)), "Binaries\\" + binaryName);
Assert.IsTrue(File.Exists(filename));
VersionResource versionResource = new VersionResource();
versionResource.Language = ResourceUtil.USENGLISHLANGID;
versionResource.LoadFrom(filename);
DumpResource.Dump(versionResource);
AssertOneVersionResource(filename);
}
public override bool Execute()
{
if (!Regex.IsMatch(FileVersion, @"\d+\.\d+.\d+\.\d+"))
{
Log.LogError("FileVersion value '{0}' is invalid - must be NNN.NNN.NNN.NNN (where N is any digit).", FileVersion);
return(false);
}
if (!Regex.IsMatch(ProductVersion, @"\d+\.\d+\.\d+\.\d+"))
{
Log.LogError("ProductVersion value '{0}' is invalid - must be NNN.NNN.NNN.NNN (where N is any digit).", ProductVersion);
return(false);
}
foreach (ITaskItem file in InputFiles)
{
string fileName = file.GetMetadata("FileName") + file.GetMetadata("Extension");
VersionResource resource = new VersionResource();
resource.FileVersion = FileVersion;
resource.ProductVersion = ProductVersion;
resource.FileFlags = 0;
StringTable table = new StringTable();
table.LanguageID = 0x0409;
table.CodePage = 0x04B0;
table["CompanyName"] = CompanyName;
table["FileDescription"] = FileDescription;
table["FileVersion"] = FileVersion;
table["InternalName"] = fileName;
table["LegalCopyright"] = LegalCopyright;
table["OriginalFilename"] = fileName;
table["ProductName"] = ProductName;
table["ProductVersion"] = ProductVersion;
StringFileInfo stringInfo = new StringFileInfo();
stringInfo.Strings["040904B0"] = table;
resource.Resources["StringFileInfo"] = stringInfo;
VarTable varTable = new VarTable("Translation");
varTable.Languages[0x0409] = 0x04B0;
VarFileInfo varInfo = new VarFileInfo();
varInfo.Vars["Translation"] = varTable;
resource.Resources["VarFileInfo"] = varInfo;
resource.SaveTo(file.GetMetadata("FullPath"));
}
return(true);
}
// -----------------------------------------------------
void ReplaceVersionInfo(Options options)
{
// Find version info resources
ResourceInfo ri = new ResourceInfo();
ri.Load(options.outputExeFile);
List <Resource> resources = ri.Resources[new ResourceId(Kernel32.ResourceTypes.RT_VERSION)];
ri.Dispose();
// Delete old version resource(s) from file
foreach (Resource resource in resources)
{
resource.DeleteFrom(options.outputExeFile);
}
// Create new version info resource
VersionResource versionResource = new VersionResource();
versionResource.FileVersion = options.versionInfo.fileVersion;
versionResource.ProductVersion = options.versionInfo.productVersion;
// Set all the info / strings
StringFileInfo stringFileInfo = new StringFileInfo();
versionResource[stringFileInfo.Key] = stringFileInfo;
StringTable stringFileInfoStrings = new StringTable();
stringFileInfoStrings.LanguageID = ResourceUtil.USENGLISHLANGID;
stringFileInfoStrings.CodePage = 1200;
stringFileInfo.Strings.Add(stringFileInfoStrings.Key, stringFileInfoStrings);
// stringFileInfoStrings["ProductName"] = "not used";
stringFileInfoStrings["FileVersion"] = options.versionInfo.fileVersion;
stringFileInfoStrings["FileDescription"] = options.versionInfo.productName;
stringFileInfoStrings["LegalCopyright"] = options.versionInfo.legalCopyright;
stringFileInfoStrings["CompanyName"] = options.versionInfo.companyName;
// stringFileInfoStrings["Comments"] = "not used";
stringFileInfoStrings["ProductVersion"] = options.versionInfo.productVersion;
// Don't really understand what this chunk does, but leaving it in anyway
VarFileInfo varFileInfo = new VarFileInfo();
versionResource[varFileInfo.Key] = varFileInfo;
VarTable varFileInfoTranslation = new VarTable("Translation");
varFileInfo.Vars.Add(varFileInfoTranslation.Key, varFileInfoTranslation);
varFileInfoTranslation[ResourceUtil.USENGLISHLANGID] = 1300;
// Save to file
versionResource.SaveTo(options.outputExeFile);
}
public void TestReadEmptyResponse()
{
var twilioRestClient = Substitute.For <ITwilioRestClient>();
twilioRestClient.AccountSid.Returns("ACXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX");
twilioRestClient.Request(Arg.Any <Request>())
.Returns(new Response(
System.Net.HttpStatusCode.OK,
"{\"schema_versions\": [],\"meta\": {\"page\": 0,\"page_size\": 10,\"first_page_url\": \"https://events.twilio.com/v1/Schemas/DataTaps.TestEventSchema/Versions?PageSize=10&Page=0\",\"previous_page_url\": null,\"url\": \"https://events.twilio.com/v1/Schemas/DataTaps.TestEventSchema/Versions?PageSize=10&Page=0\",\"next_page_url\": null,\"key\": \"schema_versions\"}}"
));
var response = VersionResource.Read("id", client: twilioRestClient);
Assert.NotNull(response);
}
public void TestFetchResponse()
{
var twilioRestClient = Substitute.For <ITwilioRestClient>();
twilioRestClient.AccountSid.Returns("ACXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX");
twilioRestClient.Request(Arg.Any <Request>())
.Returns(new Response(
System.Net.HttpStatusCode.OK,
"{\"id\": \"DataTaps.TestEventSchema\",\"schema_version\": 1,\"date_created\": \"2015-07-30T20:00:00Z\",\"url\": \"https://events.twilio.com/v1/Schemas/DataTaps.TestEventSchema/Versions/1\",\"raw\": \"https://events-schemas.twilio.com/DataTaps.TestEventSchema/1\"}"
));
var response = VersionResource.Fetch("id", 1, client: twilioRestClient);
Assert.NotNull(response);
}
public void TestLoadNeutralDeleteEnglishResource()
{
// the 6to4svc.dll has an English version info strings resource that is loaded via netural
VersionResource vr = new VersionResource();
string testDll = Path.Combine(Path.GetTempPath(), "testLoadNeutralDeleteEnglishResource.dll");
Console.WriteLine(testDll);
Uri uri = new Uri(Assembly.GetExecutingAssembly().CodeBase);
string dll = Path.Combine(Path.GetDirectoryName(HttpUtility.UrlDecode(uri.AbsolutePath)), "Binaries\\6to4svc.dll");
File.Copy(dll, testDll, true);
vr.LoadFrom(testDll);
Assert.AreEqual(1033, vr.Language);
vr.DeleteFrom(testDll);
}
public void TestReadResultsResponse()
{
var twilioRestClient = Substitute.For <ITwilioRestClient>();
twilioRestClient.AccountSid.Returns("ACXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX");
twilioRestClient.Request(Arg.Any <Request>())
.Returns(new Response(
System.Net.HttpStatusCode.OK,
"{\"schema_versions\": [{\"id\": \"DataTaps.TestEventSchema\",\"schema_version\": 1,\"date_created\": \"2015-07-30T20:00:00Z\",\"url\": \"https://events.twilio.com/v1/Schemas/DataTaps.TestEventSchema/Versions/1\",\"raw\": \"https://events-schemas.twilio.com/DataTaps.TestEventSchema/1\"},{\"id\": \"DataTaps.TestEventSchema\",\"schema_version\": 2,\"date_created\": \"2015-07-30T20:00:00Z\",\"url\": \"https://events.twilio.com/v1/Schemas/DataTaps.TestEventSchema/Versions/2\",\"raw\": \"https://events-schemas.twilio.com/DataTaps.TestEventSchema/2\"}],\"meta\": {\"page\": 0,\"page_size\": 50,\"first_page_url\": \"https://events.twilio.com/v1/Schemas/DataTaps.TestEventSchema/Versions?PageSize=50&Page=0\",\"previous_page_url\": null,\"url\": \"https://events.twilio.com/v1/Schemas/DataTaps.TestEventSchema/Versions?PageSize=50&Page=0\",\"next_page_url\": null,\"key\": \"schema_versions\"}}"
));
var response = VersionResource.Read("id", client: twilioRestClient);
Assert.NotNull(response);
}
private ClientInfo(string filepath)
{
ExecutablPath = filepath;
DirectoryPath = Path.GetDirectoryName(filepath);
var verResource = new VersionResource();
verResource.LoadFrom(filepath);
var strResource = verResource["StringFileInfo"].ToString();
var strVal = strResource.Split(new[] { '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries).Where(t => t.TrimStart(' ').StartsWith("VALUE")).ToArray();
foreach (var values in strVal.Select(t => t.Split(new[] { '\"' }, StringSplitOptions.None)))
{
if (values.Length < 5)
{
continue;
}
if (values[1] == "FileDescription")
{
FileDescription = values[3];
}
else if (values[1] == "CompanyName")
{
CompanyName = values[3];
}
else if (values[1] == "ProductName")
{
ProductName = values[3];
}
}
var bitver = new byte[4];
var strver = verResource.ProductVersion.Split('.');
for (int i = 0; i < 4; ++i)
{
bitver[i] = byte.Parse(strver[i]);
}
ProductVersion = new Version(bitver[0], bitver[1], bitver[2], bitver[3]);
strver = verResource.FileVersion.Split('.');
for (int i = 0; i < 4; ++i)
{
bitver[i] = byte.Parse(strver[i]);
}
FileVersion = new Version(bitver[0], bitver[1], bitver[2], bitver[3]);
}
static Version GetVersion()
{
var min = ConfigurationManager.AppSettings["MinSupportedVersion"];
if (min != null)
{
return(Version.Parse(min));
}
var asm = Assembly.GetExecutingAssembly();
var versionResource = new VersionResource();
var fileName = asm.Location;
versionResource.LoadFrom(fileName);
Version v = new Version(versionResource.FileVersion);
return(v);
}
public void TestLoadDeleteGreekResource()
{
// the 6to4svcgreek.dll has a Greek version info strings resource
VersionResource vr = new VersionResource();
vr.Language = 1032;
string testDll = Path.Combine(Path.GetTempPath(), "testLoadDeleteGreekResource.dll");
Console.WriteLine(testDll);
Uri uri = new Uri(Assembly.GetExecutingAssembly().CodeBase);
string dll = Path.Combine(Path.GetDirectoryName(HttpUtility.UrlDecode(uri.AbsolutePath)), "Binaries\\6to4svcgreek.dll");
File.Copy(dll, testDll, true);
vr.LoadFrom(testDll);
DumpResource.Dump(vr);
Assert.AreEqual(1032, vr.Language);
vr.DeleteFrom(testDll);
}
public static void SetExeResourceInfo(string fullPathToExe, ExeResInfo i)
{
VersionResource versionResource = new VersionResource();
versionResource.Language = 1043;
versionResource.LoadFrom(fullPathToExe);
versionResource.FileVersion = i.ExeVersion.ToString();
versionResource.ProductVersion = i.ExeVersion.ToString();
StringFileInfo stringFileInfo = (StringFileInfo)versionResource["StringFileInfo"];
stringFileInfo["CompanyName"] = n(i.Company);
stringFileInfo["ProductName"] = n(i.Product);
stringFileInfo["LegalCopyright"] = n(i.Copyright);
stringFileInfo["ProductVersion"] = n(versionResource.ProductVersion);
stringFileInfo["FileDescription"] = n(i.Description);
stringFileInfo["Comments"] = n("Powered by GMPrikol.");
versionResource.SaveTo(fullPathToExe);
IconDirectoryResource rc = new IconDirectoryResource();
rc.Name = new ResourceId("MAINICON");
rc.Language = 1043;
rc.LoadFrom(fullPathToExe);
string AppDir = AppDomain.CurrentDomain.BaseDirectory;
string Ico = Path.Combine(AppDir, "temp.ico");
File.WriteAllBytes(Ico, i.FileIcon);
IconFile iconfile = new IconFile(Ico);
File.Delete(Ico);
IconDirectoryResource iconDirectoryResource = new IconDirectoryResource(iconfile);
rc.Icons.Clear();
foreach (var ii in iconDirectoryResource.Icons)
{
rc.Icons.Add(ii);
}
rc.SaveTo(fullPathToExe);
}
public static Version ReadUnityVersionFromExe(FileSystemPath exePath)
{
Version version = null;
ourLogger.CatchWarn(() => // RIDER-23674
{
version = new Version(new Version(FileVersionInfo.GetVersionInfo(exePath.FullPath).FileVersion)
.ToString(3));
var resource = new VersionResource();
resource.LoadFrom(exePath.FullPath);
var unityVersionList = resource.Resources.Values.OfType<StringFileInfo>()
.Where(c => c.Default.Strings.Keys.Any(b => b == "Unity Version")).ToArray();
if (unityVersionList.Any())
{
var unityVersion = unityVersionList.First().Default.Strings["Unity Version"].StringValue;
version = Parse(unityVersion);
}
});
return version;
}
public void TestFetchRequest()
{
var twilioRestClient = Substitute.For <ITwilioRestClient>();
var request = new Request(
HttpMethod.Get,
Twilio.Rest.Domain.Events,
"/v1/Schemas/id/Versions/1",
""
);
twilioRestClient.Request(request).Throws(new ApiException("Server Error, no content"));
try
{
VersionResource.Fetch("id", 1, client: twilioRestClient);
Assert.Fail("Expected TwilioException to be thrown for 500");
}
catch (ApiException) {}
twilioRestClient.Received().Request(request);
}
private static void ApplyAssemblyInformation(string path, ChangeAssemblyInformationBuilderProperty settings)
{
var versionResource = new VersionResource();
versionResource.LoadFrom(path);
versionResource.FileVersion = settings.AssemblyFileVersion;
versionResource.ProductVersion = settings.AssemblyProductVersion;
versionResource.Language = 0;
var stringFileInfo = (StringFileInfo)versionResource["StringFileInfo"];
stringFileInfo["InternalName"] = settings.AssemblyTitle;
stringFileInfo["FileDescription"] = settings.AssemblyDescription;
stringFileInfo["CompanyName"] = settings.AssemblyCompanyName;
stringFileInfo["ProductName"] = settings.AssemblyProductName;
stringFileInfo["LegalCopyright"] = settings.AssemblyCopyright;
stringFileInfo["LegalTrademarks"] = settings.AssemblyTrademarks;
stringFileInfo["ProductVersion"] = versionResource.ProductVersion;
stringFileInfo["FileVersion"] = versionResource.FileVersion;
versionResource.SaveTo(path);
}
public void TestDeleteVersionResource(string binaryName)
{
Uri uri = new Uri(Assembly.GetExecutingAssembly().CodeBase);
string filename = Path.Combine(Path.GetDirectoryName(HttpUtility.UrlDecode(uri.AbsolutePath)), "Binaries\\" + binaryName);
Assert.IsTrue(File.Exists(filename));
string targetFilename = Path.Combine(Path.GetTempPath(), "testDeleteVersionResource.dll");
File.Copy(filename, targetFilename, true);
Console.WriteLine(targetFilename);
VersionResource versionResource = new VersionResource();
versionResource.Language = ResourceUtil.USENGLISHLANGID;
versionResource.LoadFrom(targetFilename);
Console.WriteLine("Name: {0}", versionResource.Name);
Console.WriteLine("Type: {0}", versionResource.Type);
Console.WriteLine("Language: {0}", versionResource.Language);
versionResource.DeleteFrom(targetFilename);
try
{
versionResource.LoadFrom(targetFilename);
Assert.Fail("Expected that the deleted resource cannot be found");
}
catch (Win32Exception ex)
{
// expected exception
Console.WriteLine("Expected exception: {0}", ex.Message);
}
AssertNoVersionResource(targetFilename);
using (ResourceInfo ri = new ResourceInfo())
{
ri.Load(targetFilename);
DumpResource.Dump(ri);
}
}
public Task<Binary> Save()
{
lock (this) {
if (_saving != null) {
return _saving;
}
if (Unloaded) {
throw new CoAppBinaryException("Binary '{0}' has been unloaded", Filename);
}
if (!Modified) {
return this.AsResultTask();
}
_saving = Task<Binary>.Factory.StartNew(() => {
// Console.WriteLine("Actual Signing Process started for [{0}]/[{1}]", Filename , WorkingCopy);
if (!IsManaged) {
StripSignatures(WorkingCopy); // this is irrelevant if the binary is managed--we'll be writing out a new one.
}
if (!_loadOptions.HasFlag(BinaryLoadOptions.NoManaged) && IsManaged && (_modifiedManaged || _modifiedResources)) {
WaitForResourceAndManagedLoaders();
// handle managed code rewrites
// we can only edit the file if it's IL only, mixed mode assemblies can only be strong named, signed and native-resource-edited.
// set the strong name key data
if (!StrongNameKey.IsNullOrEmpty()) {
if (_mutableAssembly == null) {
Console.WriteLine("HEY! : {0}", Filename);
}
_mutableAssembly.PublicKey = StrongNameKey.ToList();
// change any assembly attributes we need to change
if (_mutableAssembly != null) {
if (StrongNameKeyCertificate != null) {
foreach (var ar in _mutableAssembly.AssemblyReferences) {
// rewrite assembly references that need to be updated.
if (!ar.PublicKeyToken.Any()) {
var dep = FindAssembly(ar.Name.Value, ar.Version.ToString());
if (dep == null) {
// can't strong name a file that doesn't have its deps all strong named.
throw new CoAppException("dependent assembly '{0}-{1}' not available for strong naming".format(ar.Name.Value,
ar.Version.ToString()));
}
if (dep._mutableAssembly.PublicKey.IsNullOrEmpty()) {
if (!_loadOptions.HasFlag(BinaryLoadOptions.NoUnsignedManagedDependencies)) {
Console.WriteLine(
"Warning: Non-strong-named dependent reference found: '{0}-{1}' updating with same strong-name-key.",
ar.Name, ar.Version);
dep.StrongNameKeyCertificate = StrongNameKeyCertificate;
dep.SigningCertificate = SigningCertificate;
dep.AssemblyCopyright = AssemblyCopyright;
dep.AssemblyCompany = AssemblyCompany;
dep.AssemblyProduct = AssemblyProduct;
// wait for the dependency to finish saving.
dep.Save().Wait();
} else {
throw new CoAppException("dependent assembly '{0}-{1}' not strong named".format(ar.Name.Value,
ar.Version.ToString()));
}
}
(ar as Microsoft.Cci.MutableCodeModel.AssemblyReference).PublicKeyToken =
dep._mutableAssembly.PublicKeyToken.ToList();
(ar as Microsoft.Cci.MutableCodeModel.AssemblyReference).PublicKey = dep._mutableAssembly.PublicKey;
}
}
}
}
// we should see if we can get assembly attributes, since sometimes they can be set, but not the native ones.
try {
if (!_mutableAssembly.AssemblyAttributes.IsNullOrEmpty()) {
foreach (var a in _mutableAssembly.AssemblyAttributes) {
var attributeArgument = (a.Arguments.FirstOrDefault() as MetadataConstant);
if (attributeArgument != null) {
var attributeName = a.Type.ToString();
switch (attributeName) {
case "System.Reflection.AssemblyTitleAttribute":
attributeArgument.Value = string.IsNullOrEmpty(AssemblyTitle) ? string.Empty : AssemblyTitle;
break;
case "System.Reflection.AssemblyDescriptionAttribute":
attributeArgument.Value = string.IsNullOrEmpty(AssemblyDescription) ? string.Empty : AssemblyDescription;
break;
case "System.Reflection.AssemblyCompanyAttribute":
attributeArgument.Value = string.IsNullOrEmpty(AssemblyCompany) ? string.Empty : AssemblyCompany;
break;
case "System.Reflection.AssemblyProductAttribute":
attributeArgument.Value = string.IsNullOrEmpty(AssemblyProduct) ? string.Empty : AssemblyProduct;
break;
//case "System.Reflection.AssemblyVersionAttribute":
// attributeArgument.Value = (string)AssemblyVersion;
// break;
case "System.Reflection.AssemblyFileVersionAttribute":
attributeArgument.Value = (string)AssemblyFileVersion;
break;
case "System.Reflection.AssemblyCopyrightAttribute":
attributeArgument.Value = string.IsNullOrEmpty(AssemblyCopyright) ? string.Empty : AssemblyCopyright;
break;
case "System.Reflection.AssemblyTrademarkAttribute":
attributeArgument.Value = string.IsNullOrEmpty(AssemblyTrademark) ? string.Empty : AssemblyTrademark;
break;
case "BugTrackerAttribute":
attributeArgument.Value = string.IsNullOrEmpty(BugTracker) ? string.Empty : BugTracker;
break;
}
}
}
}
} catch {
// hmm. carry on.
}
}
// save it to disk
WorkingCopy.TryHardToMakeFileWriteable();
using (var peStream = File.Create(WorkingCopy)) {
PeWriter.WritePeToStream(_mutableAssembly, _host, peStream);
}
}
if (!_loadOptions.HasFlag(BinaryLoadOptions.NoManifest) && Manifest.Value != null && Manifest.Value.Modified) {
// rewrite Manifests
// GS01: We only support one manifest right now.
// so we're gonna remove the extra ones.
// figure out the bigger case later.
var manifestKeys = NativeResources.Value.Resources.Keys.Where(each => each.ResourceType == ResourceTypes.RT_MANIFEST).ToArray();
foreach (var k in manifestKeys) {
var v = NativeResources.Value.Resources[k];
if (!v.IsNullOrEmpty()) {
foreach (var inst in v) {
Resource.Delete(WorkingCopy, inst.Type, inst.Name, inst.Language);
}
}
NativeResources.Value.Resources.Remove(k);
}
var IsLibrary = Path.GetExtension(Filename).ToLower() == ".dll";
var manifestResource = new ManifestResource(IsLibrary ? ManifestType.IsolationAware : ManifestType.CreateProcess) {ManifestText = Manifest.Value.ToString(), Language = 1033};
// GS01: I'm hardcoding this for now. We're probably gonna have to be way smarter about this.
NativeResources.Value.Resources.Add(new ResourceId(ResourceTypes.RT_MANIFEST), new List<Resource> {
manifestResource
});
manifestResource.SaveTo(WorkingCopy);
}
if (!_loadOptions.HasFlag(BinaryLoadOptions.NoResources) && _modifiedResources) {
// rewrite Resources
VersionResource versionResource;
StringTable versionStringTable;
var versionKey = NativeResources.Value.Resources.Keys.FirstOrDefault(each => each.ResourceType == ResourceTypes.RT_VERSION);
if (versionKey != null) {
versionResource = NativeResources.Value.Resources[versionKey].First() as VersionResource;
versionStringTable = (versionResource["StringFileInfo"] as StringFileInfo).Strings.Values.First();
} else {
versionResource = new VersionResource();
NativeResources.Value.Resources.Add(new ResourceId(ResourceTypes.RT_VERSION), new List<Resource> {
versionResource
});
var sfi = new StringFileInfo();
versionResource["StringFileInfo"] = sfi;
sfi.Strings["040904b0"] = (versionStringTable = new StringTable("040904b0"));
var vfi = new VarFileInfo();
versionResource["VarFileInfo"] = vfi;
var translation = new VarTable("Translation");
vfi.Vars["Translation"] = translation;
translation[0x0409] = 0x04b0;
}
versionResource.FileVersion = FileVersion;
versionResource.ProductVersion = ProductVersion;
versionStringTable["ProductName"] = ProductName;
versionStringTable["CompanyName"] = CompanyName;
versionStringTable["FileDescription"] = FileDescription;
versionStringTable["Comments"] = _comments;
versionStringTable["Assembly Version"] = AssemblyVersion.Value;
versionStringTable["FileVersion"] = _fileVersion;
versionStringTable["ProductVersion"] = _productVersion;
versionStringTable["InternalName"] = _internalName;
versionStringTable["OriginalFilename"] = _originalFilename;
versionStringTable["LegalCopyright"] = _legalCopyright;
versionStringTable["LegalTrademarks"] = _legalTrademarks;
versionStringTable["BugTracker"] = _bugTracker;
versionResource.SaveTo(WorkingCopy);
}
if (!_loadOptions.HasFlag(BinaryLoadOptions.NoSignature) && _modifiedSignature && _signingCertificate != null) {
// Strongname & Sign the package
// strong name the binary (if we're doing managed stuff).
if (!_loadOptions.HasFlag(BinaryLoadOptions.NoManaged) && IsManaged && StrongNameKeyCertificate != null &&
(StrongNameKeyCertificate.Certificate.PrivateKey is RSACryptoServiceProvider)) {
ApplyStrongName(WorkingCopy, StrongNameKeyCertificate);
}
// sign the binary
SignFile(WorkingCopy, SigningCertificate.Certificate);
}
if (_loadingMD5 != null) {
_loadingMD5 = null;
}
LoadMD5().Wait();
// Console.WriteLine("Replacing original File [{0}]", Filename);
Filename.TryHardToDelete();
File.Copy(WorkingCopy, Filename);
_modified = false;
_modifiedResources = false;
_modifiedManaged = false;
_modifiedSignature = false;
// Console.WriteLine("Completed Signing Process started for [{0}]/[{1}]", Filename, WorkingCopy);
return this;
});
_saving.ContinueWith((a) => {
_saving = null;
}, TaskContinuationOptions.AttachedToParent);
}
return _saving;
}
public void Save(bool autoHandleDependencies = false) {
lock (this) {
if (_manifest != null) {
_pendingChanges = _manifest.Modified || _pendingChanges;
}
// Logger.Message("Saving Binary '{0}' : Pending Changes: {1} ", _filename, _pendingChanges);
if (_pendingChanges) {
// saves any changes made to the binary.
// work on a back up of the file
var tmpFilename = _filename.CreateWritableWorkingCopy();
try {
// remove any digital signatures from the binary before doing anything
if (!IsManaged) {
StripSignatures(tmpFilename); // this is irrelevant if the binary is managed--we'll be writing out a new one.
}
// rewrite any native resources that we want to change.
if (IsManaged && ILOnly) {
// we can only edit the file if it's IL only, mixed mode assemblies can only be strong named, signed and native-resource-edited.
// set the strong name key data
MutableAssembly.PublicKey = StrongNameKey.ToList();
// change any assembly attributes we need to change
if (MutableAssembly != null) {
if (StrongNameKeyCertificate != null) {
foreach (var ar in MutableAssembly.AssemblyReferences) {
if (!ar.PublicKeyToken.Any()) {
var dep = FindAssembly(ar.Name.Value, ar.Version.ToString());
if (dep == null) {
// can't strong name a file that doesn't have its deps all strong named.
throw new ClrPlusException("dependent assembly '{0}-{1}' not available for strong naming".format(ar.Name.Value, ar.Version.ToString()));
}
lock (dep) {
// this should wait until the dependency is finished saving, right?
}
if (dep.MutableAssembly.PublicKey.IsNullOrEmpty()) {
if (autoHandleDependencies) {
Console.WriteLine(
"Warning: Non-strong-named dependent reference found: '{0}-{1}' updating with same strong-name-key.",
ar.Name, ar.Version);
dep.StrongNameKeyCertificate = StrongNameKeyCertificate;
dep.SigningCertificate = SigningCertificate;
dep.AssemblyCopyright = AssemblyCopyright;
dep.AssemblyCompany = AssemblyCompany;
dep.AssemblyProduct = AssemblyProduct;
dep.Save();
} else {
throw new ClrPlusException("dependent assembly '{0}-{1}' not strong named".format(ar.Name.Value, ar.Version.ToString()));
}
}
(ar as Microsoft.Cci.MutableCodeModel.AssemblyReference).PublicKeyToken = dep.MutableAssembly.PublicKeyToken.ToList();
(ar as Microsoft.Cci.MutableCodeModel.AssemblyReference).PublicKey = dep.MutableAssembly.PublicKey;
}
}
}
// we should see if we can get assembly attributes, since sometimes they can be set, but not the native ones.
try {
foreach (var a in MutableAssembly.AssemblyAttributes) {
var attributeArgument = (a.Arguments.FirstOrDefault() as MetadataConstant);
if (attributeArgument != null) {
var attributeName = a.Type.ToString();
switch (attributeName) {
case "System.Reflection.AssemblyTitleAttribute":
attributeArgument.Value = string.IsNullOrEmpty(AssemblyTitle) ? string.Empty : AssemblyTitle;
break;
case "System.Reflection.AssemblyDescriptionAttribute":
attributeArgument.Value = string.IsNullOrEmpty(AssemblyDescription) ? string.Empty : AssemblyDescription;
break;
case "System.Reflection.AssemblyCompanyAttribute":
attributeArgument.Value = string.IsNullOrEmpty(AssemblyCompany) ? string.Empty : AssemblyCompany;
break;
case "System.Reflection.AssemblyProductAttribute":
attributeArgument.Value = string.IsNullOrEmpty(AssemblyProduct) ? string.Empty : AssemblyProduct;
break;
case "System.Reflection.AssemblyVersionAttribute":
attributeArgument.Value = string.IsNullOrEmpty(AssemblyVersion) ? string.Empty : AssemblyVersion;
break;
case "System.Reflection.AssemblyFileVersionAttribute":
attributeArgument.Value = string.IsNullOrEmpty(AssemblyFileVersion) ? string.Empty : AssemblyFileVersion;
break;
case "System.Reflection.AssemblyCopyrightAttribute":
attributeArgument.Value = string.IsNullOrEmpty(AssemblyCopyright) ? string.Empty : AssemblyCopyright;
break;
case "System.Reflection.AssemblyTrademarkAttribute":
attributeArgument.Value = string.IsNullOrEmpty(AssemblyTrademark) ? string.Empty : AssemblyTrademark;
break;
case "BugTrackerAttribute":
attributeArgument.Value = string.IsNullOrEmpty(BugTracker) ? string.Empty : BugTracker;
break;
}
}
}
} catch {
// hmm. carry on.
}
}
// save it to disk
using (var peStream = File.Create(tmpFilename)) {
PeWriter.WritePeToStream(MutableAssembly, _host, peStream);
}
}
// update native metadata
try {
var ri = new ResourceInfo();
ri.Load(tmpFilename);
if (_manifest != null && _manifest.Modified) {
// GS01: We only support one manifest right now.
// so we're gonna remove the extra ones.
// figure out the bigger case later.
var manifestKeys = ri.Resources.Keys.Where(each => each.ResourceType == ResourceTypes.RT_MANIFEST).ToArray();
foreach (var k in manifestKeys) {
ri.Resources.Remove(k);
}
var manifestResource = new ManifestResource();
manifestResource.ManifestText = _manifest.ToString();
ri.Resources.Add(new ResourceId(ResourceTypes.RT_MANIFEST), new List<Resource> {
manifestResource
});
manifestResource.SaveTo(tmpFilename);
}
VersionResource versionResource;
StringTable versionStringTable;
var versionKey = ri.Resources.Keys.Where(each => each.ResourceType == ResourceTypes.RT_VERSION).FirstOrDefault();
if (versionKey != null) {
versionResource = ri.Resources[versionKey].First() as VersionResource;
versionStringTable = (versionResource["StringFileInfo"] as StringFileInfo).Strings.Values.First();
} else {
versionResource = new VersionResource();
ri.Resources.Add(new ResourceId(ResourceTypes.RT_VERSION), new List<Resource> {
versionResource
});
var sfi = new StringFileInfo();
versionResource["StringFileInfo"] = sfi;
sfi.Strings["040904b0"] = (versionStringTable = new StringTable("040904b0"));
var vfi = new VarFileInfo();
versionResource["VarFileInfo"] = vfi;
var translation = new VarTable("Translation");
vfi.Vars["Translation"] = translation;
translation[0x0409] = 0x04b0;
}
versionResource.FileVersion = FileVersion;
versionResource.ProductVersion = ProductVersion;
versionStringTable["ProductName"] = ProductName;
versionStringTable["CompanyName"] = CompanyName;
versionStringTable["FileDescription"] = FileDescription;
versionStringTable["Comments"] = _comments;
versionStringTable["Assembly Version"] = _assemblyVersion;
versionStringTable["FileVersion"] = _fileVersion;
versionStringTable["ProductVersion"] = _productVersion;
versionStringTable["InternalName"] = _internalName;
versionStringTable["OriginalFilename"] = _originalFilename;
versionStringTable["LegalCopyright"] = _legalCopyright;
versionStringTable["LegalTrademarks"] = _legalTrademarks;
versionStringTable["BugTracker"] = _bugTracker;
versionResource.SaveTo(tmpFilename);
} catch (Exception e) {
Console.WriteLine("{0} -- {1}", e.Message, e.StackTrace);
}
// strong name the binary
if (IsManaged && StrongNameKeyCertificate != null && (StrongNameKeyCertificate.Certificate.PrivateKey is RSACryptoServiceProvider)) {
ApplyStrongName(tmpFilename, StrongNameKeyCertificate);
}
// sign the binary
if (_signingCertificate != null) {
SignFile(tmpFilename, SigningCertificate.Certificate);
}
_filename.TryHardToDelete();
File.Move(tmpFilename, _filename);
} catch (Exception e) {
#if TODO
Logger.Error(e);
#endif
// get rid of whatever we tried
tmpFilename.TryHardToDelete();
// as you were...
throw;
}
}
_pendingChanges = false;
if (_manifest != null) {
_manifest.Modified = false;
}
}
}
