/// ------------------------------------------------------------------------------------
/// <summary>
/// Executes the task.
/// </summary>
/// ------------------------------------------------------------------------------------
public override bool Execute()
{
Log.LogMessage(MessageImportance.Normal, "Registering {0}", Path.GetFileName(Dll));
if (File.Exists(Dll))
{
using (var regHelper = new RegHelper(Log))
{
return regHelper.Register(Dll, false, RegisterTypeLibrary);
}
}
return true;
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Executes the task.
/// </summary>
/// ------------------------------------------------------------------------------------
public override bool Execute()
{
Log.LogMessage(MessageImportance.Normal, "Registering {0}", Path.GetFileName(Dll));
if (File.Exists(Dll))
{
using (var regHelper = new RegHelper(Log, "win32"))
{
return(regHelper.Register(Dll, false, RegisterTypeLibrary));
}
}
return(true);
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Processes one type info. We get the necessary information from the type library
/// and also from the registry.
/// </summary>
/// <param name="parent">The parent element.</param>
/// <param name="tlbGuid">The guid of the type library.</param>
/// <param name="typeInfo">The type info.</param>
/// ------------------------------------------------------------------------------------
private void ProcessTypeInfo(XmlNode parent, Guid tlbGuid, ITypeInfo typeInfo)
{
try
{
IntPtr pTypeAttr;
typeInfo.GetTypeAttr(out pTypeAttr);
var typeAttr = (TYPEATTR)Marshal.PtrToStructure(pTypeAttr, typeof(TYPEATTR));
typeInfo.ReleaseTypeAttr(pTypeAttr);
if (typeAttr.typekind == TYPEKIND.TKIND_COCLASS)
{
var clsId = typeAttr.guid.ToString("B");
string keyString = string.Format(@"CLSID\{0}", clsId);
RegistryKey typeKey = Registry.ClassesRoot.OpenSubKey(keyString);
if (typeKey == null)
{
return;
}
RegistryKey inprocServer = typeKey.OpenSubKey("InprocServer32");
if (inprocServer == null)
{
return;
}
// Try to get the file element for the server
var bldr = new StringBuilder(255);
RegHelper.GetLongPathName((string)inprocServer.GetValue(null), bldr, 255);
string serverFullPath = bldr.ToString();
string server = Path.GetFileName(serverFullPath);
if (!File.Exists(serverFullPath) &&
!File.Exists(Path.Combine(_baseDirectory, server)))
{
if (!_nonExistingServers.Contains(server))
{
_log.LogMessage(MessageImportance.Low, "{0} is referenced in the TLB but is not in current directory", server);
_nonExistingServers.Add(server);
}
return;
}
XmlElement file = GetOrCreateFileNode(parent, server);
//// Check to see that the DLL we're processing is really the DLL that can
//// create this class. Otherwise we better not claim that we know how to do it!
//if (keyString == null || keyString == string.Empty ||
// server.ToLower() != Path.GetFileName(m_FileName))
//{
// return;
//}
if (!_coClasses.ContainsKey(clsId))
{
var description = (string)typeKey.GetValue(string.Empty);
var threadingModel = (string)inprocServer.GetValue("ThreadingModel");
var progId = GetDefaultValueForKey(typeKey, "ProgID");
AddOrReplaceCoClass(file, clsId, threadingModel, description, tlbGuid.ToString("B"), progId);
_log.LogMessage(MessageImportance.Low, string.Format(@"Coclass: clsid=""{0}"", threadingModel=""{1}"", tlbid=""{2}"", progid=""{3}""",
clsId, threadingModel, tlbGuid, progId));
}
}
}
catch (Exception e)
{
_log.LogMessage(MessageImportance.High, "Failed to process the type info for {0}", tlbGuid);
_log.LogMessage(MessageImportance.High, e.StackTrace);
}
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Creates the entries for the type library and all classes defined in this type
/// library. We can get the necessary information for the file element (file name and
/// size) directly from the file. We get the information for the type library from
/// the type library itself.
/// </summary>
/// <param name="parent">The parent node.</param>
/// <param name="fileName">Name (and path) of the file.</param>
/// ------------------------------------------------------------------------------------
public void ProcessTypeLibrary(XmlElement parent, string fileName)
{
_baseDirectory = Path.GetDirectoryName(fileName);
_fileName = fileName.ToLower();
try
{
_log.LogMessage(MessageImportance.Low, "\tProcessing type library {0}", fileName);
XmlNode oldChild;
ITypeLib typeLib;
RegHelper.LoadTypeLib(_fileName, out typeLib);
IntPtr pLibAttr;
typeLib.GetLibAttr(out pLibAttr);
var libAttr = (TYPELIBATTR)
Marshal.PtrToStructure(pLibAttr, typeof(TYPELIBATTR));
typeLib.ReleaseTLibAttr(pLibAttr);
string flags = string.Empty;
if ((libAttr.wLibFlags & LIBFLAGS.LIBFLAG_FHASDISKIMAGE) == LIBFLAGS.LIBFLAG_FHASDISKIMAGE)
{
flags = "HASDISKIMAGE";
}
// <file name="FwKernel.dll" asmv2:size="1507328">
var file = GetOrCreateFileNode(parent, fileName);
// <typelib tlbid="{2f0fccc0-c160-11d3-8da2-005004defec4}" version="1.0" helpdir=""
// resourceid="0" flags="HASDISKIMAGE" />
if (_tlbGuids.ContainsKey(libAttr.guid))
{
_log.LogWarning("Type library with GUID {0} is defined in {1} and {2}",
libAttr.guid, _tlbGuids[libAttr.guid], Path.GetFileName(fileName));
}
else
{
_tlbGuids.Add(libAttr.guid, Path.GetFileName(fileName));
XmlElement elem = _doc.CreateElement("typelib", UrnAsmv1);
elem.SetAttribute("tlbid", libAttr.guid.ToString("B"));
elem.SetAttribute("version", string.Format("{0}.{1}", libAttr.wMajorVerNum,
libAttr.wMinorVerNum));
elem.SetAttribute("helpdir", string.Empty);
elem.SetAttribute("resourceid", "0");
elem.SetAttribute("flags", flags);
oldChild = file.SelectSingleNode(string.Format("asmv1:typelib[asmv1:tlbid='{0}']",
libAttr.guid.ToString("B")), _nsManager);
if (oldChild != null)
{
file.ReplaceChild(elem, oldChild);
}
else
{
file.AppendChild(elem);
}
}
Debug.WriteLine(@"typelib tlbid=""{0}"" version=""{1}.{2}"" helpdir="""" resourceid=""0"" flags=""{3}""",
libAttr.guid, libAttr.wMajorVerNum, libAttr.wMinorVerNum, flags);
int count = typeLib.GetTypeInfoCount();
_log.LogMessage(MessageImportance.Low, "\t\tTypelib has {0} types", count);
for (int i = 0; i < count; i++)
{
ITypeInfo typeInfo;
typeLib.GetTypeInfo(i, out typeInfo);
ProcessTypeInfo(parent, libAttr.guid, typeInfo);
}
oldChild = parent.SelectSingleNode(string.Format("asmv1:file[asmv1:name='{0}']",
Path.GetFileName(fileName)), _nsManager);
if (oldChild != null)
{
parent.ReplaceChild(file, oldChild);
}
else
{
parent.AppendChild(file);
}
}
catch (Exception)
{
// just ignore if this isn't a type library
_log.LogMessage(MessageImportance.Normal, "Can't load type library {0}", fileName);
}
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Executes the task.
/// </summary>
/// ------------------------------------------------------------------------------------
public override bool Execute()
{
Log.LogMessage(MessageImportance.Normal, "RegFree processing {0}",
Path.GetFileName(Executable));
StringCollection dllPaths = GetFilesFrom(Dlls);
if (dllPaths.Count == 0)
{
string ext = Path.GetExtension(Executable);
if (ext != null && ext.Equals(".dll", StringComparison.InvariantCultureIgnoreCase))
{
dllPaths.Add(Executable);
}
}
string manifestFile = string.IsNullOrEmpty(Output) ? Executable + ".manifest" : Output;
try
{
var doc = new XmlDocument {
PreserveWhitespace = true
};
using (XmlReader reader = new XmlTextReader(manifestFile))
{
if (reader.MoveToElement())
{
doc.ReadNode(reader);
}
}
// Register all DLLs temporarily
using (var regHelper = new RegHelper(Log, Platform))
{
regHelper.RedirectRegistry(!UserIsAdmin);
var creator = new RegFreeCreator(doc, Log);
var filesToRemove = dllPaths.Cast <string>().Where(fileName => !File.Exists(fileName)).ToList();
foreach (var file in filesToRemove)
{
dllPaths.Remove(file);
}
foreach (string fileName in dllPaths)
{
Log.LogMessage(MessageImportance.Low, "\tRegistering library {0}", Path.GetFileName(fileName));
try
{
regHelper.Register(fileName, true, false);
}
catch (Exception e)
{
Log.LogMessage(MessageImportance.High, "Failed to register library {0}", fileName);
Log.LogMessage(MessageImportance.High, e.StackTrace);
}
}
string assemblyName = Path.GetFileNameWithoutExtension(manifestFile);
Debug.Assert(assemblyName != null);
// The C++ test programs won't run if an assemblyIdentity element exists.
//if (assemblyName.StartsWith("test"))
// assemblyName = null;
string assemblyVersion = null;
try
{
assemblyVersion = FileVersionInfo.GetVersionInfo(Executable).FileVersion;
}
catch
{
// just ignore
}
if (string.IsNullOrEmpty(assemblyVersion))
{
assemblyVersion = "1.0.0.0";
}
XmlElement root = creator.CreateExeInfo(assemblyName, assemblyVersion, Platform);
foreach (string fileName in dllPaths)
{
if (NoTypeLib.Count(f => f.ItemSpec == fileName) != 0)
{
continue;
}
Log.LogMessage(MessageImportance.Low, "\tProcessing library {0}", Path.GetFileName(fileName));
creator.ProcessTypeLibrary(root, fileName);
}
creator.ProcessClasses(root);
creator.ProcessInterfaces(root);
foreach (string fragmentName in GetFilesFrom(Fragments))
{
Log.LogMessage(MessageImportance.Low, "\tAdding fragment {0}", Path.GetFileName(fragmentName));
creator.AddFragment(root, fragmentName);
}
foreach (string fragmentName in GetFilesFrom(AsIs))
{
Log.LogMessage(MessageImportance.Low, "\tAdding as-is fragment {0}", Path.GetFileName(fragmentName));
creator.AddAsIs(root, fragmentName);
}
foreach (string assemblyFileName in GetFilesFrom(DependentAssemblies))
{
Log.LogMessage(MessageImportance.Low, "\tAdding dependent assembly {0}", Path.GetFileName(assemblyFileName));
creator.AddDependentAssembly(root, assemblyFileName);
}
var settings = new XmlWriterSettings
{
OmitXmlDeclaration = false,
NewLineOnAttributes = false,
NewLineChars = Environment.NewLine,
Indent = true,
IndentChars = "\t"
};
using (XmlWriter writer = XmlWriter.Create(manifestFile, settings))
{
doc.WriteContentTo(writer);
}
// Unregister DLLs
if (Unregister)
{
foreach (string fileName in dllPaths)
{
Log.LogMessage(MessageImportance.Low, "\tUnregistering library {0}",
Path.GetFileName(fileName));
regHelper.Unregister(fileName, true);
}
}
}
}
catch (Exception e)
{
Log.LogErrorFromException(e, true, true, null);
return(false);
}
return(true);
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Executes the task.
/// </summary>
/// ------------------------------------------------------------------------------------
public override bool Execute()
{
Log.LogMessage(MessageImportance.Normal, "RegFree processing {0}",
Path.GetFileName(Executable));
StringCollection dllPaths = IdlImp.GetFilesFrom(Dlls);
if (dllPaths.Count == 0)
{
string ext = Path.GetExtension(Executable);
if (ext != null && ext.Equals(".dll", StringComparison.InvariantCultureIgnoreCase))
dllPaths.Add(Executable);
}
string manifestFile = string.IsNullOrEmpty(Output) ? Executable + ".manifest" : Output;
try
{
var doc = new XmlDocument { PreserveWhitespace = true };
using (XmlReader reader = new XmlTextReader(manifestFile))
{
if (reader.MoveToElement())
doc.ReadNode(reader);
}
// Register all DLLs temporarily
using (var regHelper = new RegHelper(Log))
{
regHelper.RedirectRegistry(!UserIsAdmin);
var creator = new RegFreeCreator(doc, Log);
var filesToRemove = dllPaths.Cast<string>().Where(fileName => !File.Exists(fileName)).ToList();
foreach (var file in filesToRemove)
dllPaths.Remove(file);
foreach (string fileName in dllPaths)
{
Log.LogMessage(MessageImportance.Low, "\tRegistering library {0}", Path.GetFileName(fileName));
try
{
regHelper.Register(fileName, true, false);
}
catch (Exception e)
{
Log.LogMessage(MessageImportance.High, "Failed to register library {0}", fileName);
Log.LogMessage(MessageImportance.High, e.StackTrace);
}
}
string assemblyName = Path.GetFileNameWithoutExtension(manifestFile);
Debug.Assert(assemblyName != null);
// The C++ test programs won't run if an assemblyIdentity element exists.
//if (assemblyName.StartsWith("test"))
// assemblyName = null;
string assemblyVersion = null;
try
{
assemblyVersion = FileVersionInfo.GetVersionInfo(Executable).FileVersion;
}
catch
{
// just ignore
}
if (string.IsNullOrEmpty(assemblyVersion))
assemblyVersion = "1.0.0.0";
XmlElement root = creator.CreateExeInfo(assemblyName, assemblyVersion);
foreach (string fileName in dllPaths)
{
if (NoTypeLib.Count(f => f.ItemSpec == fileName) != 0)
continue;
Log.LogMessage(MessageImportance.Low, "\tProcessing library {0}", Path.GetFileName(fileName));
creator.ProcessTypeLibrary(root, fileName);
}
creator.ProcessClasses(root);
creator.ProcessInterfaces(root);
foreach (string fragmentName in IdlImp.GetFilesFrom(Fragments))
{
Log.LogMessage(MessageImportance.Low, "\tAdding fragment {0}", Path.GetFileName(fragmentName));
creator.AddFragment(root, fragmentName);
}
foreach (string fragmentName in IdlImp.GetFilesFrom(AsIs))
{
Log.LogMessage(MessageImportance.Low, "\tAdding as-is fragment {0}", Path.GetFileName(fragmentName));
creator.AddAsIs(root, fragmentName);
}
foreach (string assemblyFileName in IdlImp.GetFilesFrom(DependentAssemblies))
{
Log.LogMessage(MessageImportance.Low, "\tAdding dependent assembly {0}", Path.GetFileName(assemblyFileName));
creator.AddDependentAssembly(root, assemblyFileName);
}
var settings = new XmlWriterSettings
{
OmitXmlDeclaration = false,
NewLineOnAttributes = false,
NewLineChars = Environment.NewLine,
Indent = true,
IndentChars = "\t"
};
using (XmlWriter writer = XmlWriter.Create(manifestFile, settings))
{
doc.WriteContentTo(writer);
}
// Unregister DLLs
if (Unregister)
{
foreach (string fileName in dllPaths)
{
Log.LogMessage(MessageImportance.Low, "\tUnregistering library {0}",
Path.GetFileName(fileName));
regHelper.Unregister(fileName, true);
}
}
}
}
catch (Exception e)
{
Log.LogErrorFromException(e, true, true, null);
return false;
}
return true;
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Executes the task.
/// </summary>
/// ------------------------------------------------------------------------------------
public override bool Execute()
{
Log.LogMessage(MessageImportance.Normal, "RegFree processing {0}",
Path.GetFileName(Executable));
var manifestFile = string.IsNullOrEmpty(Output) ? Executable + ".manifest" : Output;
try
{
var doc = new XmlDocument {
PreserveWhitespace = true
};
using (XmlReader reader = new XmlTextReader(manifestFile))
{
if (reader.MoveToElement())
{
doc.ReadNode(reader);
}
}
// Register all DLLs temporarily
using (var regHelper = new RegHelper(Log))
{
regHelper.RedirectRegistry();
var creator = new RegFreeCreator(doc, Log);
var dllPaths = IdlImp.GetFilesFrom(Dlls);
var filesToRemove = dllPaths.Cast <string>().Where(fileName => !File.Exists(fileName)).ToList();
foreach (var file in filesToRemove)
{
dllPaths.Remove(file);
}
foreach (string fileName in dllPaths)
{
Log.LogMessage(MessageImportance.Low, "\tRegistering library {0}", Path.GetFileName(fileName));
try
{
regHelper.Register(fileName, UserIsAdmin, NoTypeLib.Count(f => f.ItemSpec == fileName) == 0);
}
catch (Exception e)
{
Log.LogMessage(MessageImportance.High, "Failed to register library {0}", fileName);
Log.LogMessage(MessageImportance.High, e.StackTrace);
}
}
XmlElement root = creator.CreateExeInfo(Executable);
foreach (string fileName in dllPaths)
{
if (NoTypeLib.Count(f => f.ItemSpec == fileName) != 0)
{
continue;
}
Log.LogMessage(MessageImportance.Low, "\tProcessing library {0}", Path.GetFileName(fileName));
creator.ProcessTypeLibrary(root, fileName);
}
creator.ProcessClasses(root);
creator.ProcessInterfaces(root);
foreach (string fragmentName in IdlImp.GetFilesFrom(Fragments))
{
Log.LogMessage(MessageImportance.Low, "\tAdding fragment {0}", Path.GetFileName(fragmentName));
creator.AddFragment(root, fragmentName);
}
foreach (string fragmentName in IdlImp.GetFilesFrom(AsIs))
{
Log.LogMessage(MessageImportance.Low, "\tAdding as-is fragment {0}", Path.GetFileName(fragmentName));
creator.AddAsIs(root, fragmentName);
}
var settings = new XmlWriterSettings
{
OmitXmlDeclaration = false,
NewLineOnAttributes = false,
NewLineChars = Environment.NewLine,
Indent = true,
IndentChars = "\t"
};
using (XmlWriter writer = XmlWriter.Create(manifestFile, settings))
{
doc.WriteContentTo(writer);
}
// Unregister DLLs
if (Unregister)
{
foreach (string fileName in dllPaths)
{
Log.LogMessage(MessageImportance.Low, "\tUnregistering library {0}",
Path.GetFileName(fileName));
regHelper.Unregister(fileName, UserIsAdmin);
}
}
}
}
catch (Exception e)
{
Log.LogErrorFromException(e, true, true, null);
return(false);
}
return(true);
}
