/// ------------------------------------------------------------------------------------ /// <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); }