/// <summary> /// Given a class path, and a ManagementClass class definition, this /// function will create the class if it does not exist, replace the /// class if it exists but is different, or do nothing if the class /// exists and is identical. This is useful for performance reasons /// since it can be expensive to delete an existing class and replace /// it. /// </summary> /// <param name="classPath">WMI path to class</param> /// <param name="newClass">Class to create or replace</param> static void ReplaceClassIfNecessary(string classPath, ManagementClass newClass) { try { ManagementClass oldClass = SafeGetClass(classPath); if (null == oldClass) { newClass.Put(); } else { // if (newClass.GetText(TextFormat.Mof) != oldClass.GetText(TextFormat.Mof)) { // oldClass.Delete(); newClass.Put(); } } } catch (ManagementException e) { string strformat = RC.GetString("CLASS_NOTREPLACED_EXCEPT") + "\r\n{0}\r\n{1}"; throw new ArgumentException(String.Format(strformat, classPath, newClass.GetText(TextFormat.Mof)), e); } }
/// <summary> /// Given a class path, and a ManagementClass class definition, this /// function will create the class if it does not exist, replace the /// class if it exists but is different, or do nothing if the class /// exists and is identical. This is useful for performance reasons /// since it can be expensive to delete an existing class and replace /// it. /// </summary> /// <param name="classPath">WMI path to class</param> /// <param name="newClass">Class to create or replace</param> static void ReplaceClassIfNecessary(string classPath, ManagementClass newClass) { try { ManagementClass oldClass = SafeGetClass(classPath); if (null == oldClass) { newClass.Put(); } else { // TODO: Figure Out Why CompareTo does not work!!! // if(false == newClass.CompareTo(newClass, ComparisonSettings.IgnoreCase | ComparisonSettings.IgnoreObjectSource)) if (newClass.GetText(TextFormat.Mof) != oldClass.GetText(TextFormat.Mof)) { // TODO: Log to context? oldClass.Delete(); newClass.Put(); } } } catch (ManagementException e) { string strformat = RC.GetString("CLASS_NOTREPLACED_EXCEPT") + "\r\n{0}\r\n{1}"; throw new ArgumentException(String.Format(strformat, classPath, newClass.GetText(TextFormat.Mof)), e); } }
private static void Initialize(Assembly assembly) { lock (Instrumentation.instrumentedAssemblies) { if (!Instrumentation.instrumentedAssemblies.ContainsKey(assembly)) { SchemaNaming schemaNaming = SchemaNaming.GetSchemaNaming(assembly); if (schemaNaming != null) { if (!schemaNaming.IsAssemblyRegistered()) { if (WMICapabilities.IsUserAdmin()) { schemaNaming.DecoupledProviderInstanceName = AssemblyNameUtility.UniqueToAssemblyFullVersion(assembly); schemaNaming.RegisterNonAssemblySpecificSchema(null); schemaNaming.RegisterAssemblySpecificSchema(); } else { throw new Exception(RC.GetString("ASSEMBLY_NOT_REGISTERED")); } } InstrumentedAssembly instrumentedAssembly = new InstrumentedAssembly(assembly, schemaNaming); Instrumentation.instrumentedAssemblies.Add(assembly, instrumentedAssembly); } } } }
public override void Install(IDictionary savedState) { FileIOPermission fileIOPermission = new FileIOPermission(FileIOPermissionAccess.Read, base.Context.Parameters["assemblypath"]); fileIOPermission.Demand(); base.Install(savedState); base.Context.LogMessage(RC.GetString("WMISCHEMA_INSTALLATIONSTART")); string item = base.Context.Parameters["assemblypath"]; Assembly assembly = Assembly.LoadFrom(item); SchemaNaming schemaNaming = SchemaNaming.GetSchemaNaming(assembly); schemaNaming.DecoupledProviderInstanceName = AssemblyNameUtility.UniqueToAssemblyFullVersion(assembly); if (schemaNaming != null) { if (!schemaNaming.IsAssemblyRegistered() || base.Context.Parameters.ContainsKey("force") || base.Context.Parameters.ContainsKey("f")) { base.Context.LogMessage(string.Concat(RC.GetString("REGESTRING_ASSEMBLY"), " ", schemaNaming.DecoupledProviderInstanceName)); schemaNaming.RegisterNonAssemblySpecificSchema(base.Context); schemaNaming.RegisterAssemblySpecificSchema(); } this.mof = schemaNaming.Mof; base.Context.LogMessage(RC.GetString("WMISCHEMA_INSTALLATIONEND")); return; } else { return; } }
private static void Initialize(Assembly assembly) { lock (instrumentedAssemblies) { if (instrumentedAssemblies.ContainsKey(assembly)) { return; } SchemaNaming naming = SchemaNaming.GetSchemaNaming(assembly); if (naming == null) { return; } if (false == naming.IsAssemblyRegistered()) { // If we are not an administrator, don't try to JIT install the schema if (!WMICapabilities.IsUserAdmin()) { throw new Exception(RC.GetString("ASSEMBLY_NOT_REGISTERED")); } naming.RegisterNonAssemblySpecificSchema(null); naming.RegisterAssemblySpecificSchema(); } InstrumentedAssembly instrumentedAssembly = new InstrumentedAssembly(assembly, naming); instrumentedAssemblies.Add(assembly, instrumentedAssembly); } }
/// <summary> /// <para>Installs the assembly.</para> /// </summary> /// <param name='savedState'>The state of the assembly.</param> public override void Install(IDictionary savedState) { base.Install(savedState); // TODO: Localize Context.LogMessage(RC.GetString("WMISCHEMA_INSTALLATIONSTART")); string assemblyPath = Context.Parameters["assemblypath"]; Assembly assembly = Assembly.LoadFrom(assemblyPath); SchemaNaming naming = SchemaNaming.GetSchemaNaming(assembly); // See if this assembly provides instrumentation if (null == naming) { return; } // // [RAID: 123895] // If the force parameter is present, we update registration information independent if it already // exists. // if ((naming.IsAssemblyRegistered() == false) || (Context.Parameters.ContainsKey("force")) || (Context.Parameters.ContainsKey("f"))) { Context.LogMessage(RC.GetString("REGESTRING_ASSEMBLY") + " " + naming.DecoupledProviderInstanceName); naming.RegisterNonAssemblySpecificSchema(Context); naming.RegisterAssemblySpecificSchema(); } mof = naming.Mof; Context.LogMessage(RC.GetString("WMISCHEMA_INSTALLATIONEND")); }
public InstrumentedAssembly(Assembly assembly, SchemaNaming naming) { this.mapTypeToTypeInfo = new Hashtable(); SecurityHelper.UnmanagedCode.Demand(); this.naming = naming; Assembly precompiledAssembly = naming.PrecompiledAssembly; if (null == precompiledAssembly) { CSharpCodeProvider cSharpCodeProvider = new CSharpCodeProvider(); CompilerParameters compilerParameter = new CompilerParameters(); compilerParameter.GenerateInMemory = true; compilerParameter.ReferencedAssemblies.Add(assembly.Location); compilerParameter.ReferencedAssemblies.Add(typeof(BaseEvent).Assembly.Location); compilerParameter.ReferencedAssemblies.Add(typeof(Component).Assembly.Location); Type[] types = assembly.GetTypes(); for (int i = 0; i < (int)types.Length; i++) { Type type = types[i]; if (this.IsInstrumentedType(type)) { this.FindReferences(type, compilerParameter); } } string[] code = new string[1]; code[0] = naming.Code; CompilerResults compilerResult = cSharpCodeProvider.CompileAssemblyFromSource(compilerParameter, code); foreach (CompilerError error in compilerResult.Errors) { Console.WriteLine(error.ToString()); } if (!compilerResult.Errors.HasErrors) { precompiledAssembly = compilerResult.CompiledAssembly; } else { throw new Exception(RC.GetString("FAILED_TO_BUILD_GENERATED_ASSEMBLY")); } } Type type1 = precompiledAssembly.GetType("WMINET_Converter"); this.mapTypeToConverter = (Hashtable)type1.GetField("mapTypeToConverter").GetValue(null); if (MTAHelper.IsNoContextMTA()) { this.InitEventSource(this); return; } else { ThreadDispatch threadDispatch = new ThreadDispatch(new ThreadDispatch.ThreadWorkerMethodWithParam(this.InitEventSource)); threadDispatch.Parameter = this; threadDispatch.Start(); return; } }
public void IndicateEvents(int length, IntPtr[] objects) { if (pSinkMTA == null) { return; } // // Checking for MTA is not enough. We need to make sure we are not in a COM+ Context // if (MTAHelper.IsNoContextMTA()) { // Sink lives in MTA int hresult = pSinkMTA.Indicate_(length, objects); if (hresult < 0) { if ((hresult & 0xfffff000) == 0x80041000) { ManagementException.ThrowWithExtendedInfo((ManagementStatus)hresult); } else { Marshal.ThrowExceptionForHR(hresult); } } } else { MTARequest myReq = new MTARequest(length, objects); int ndx; lock (critSec) { // Do it from worker thread if (workerThreadInitialized == false) { // We've never created worker thread Thread thread = new Thread(new ThreadStart(MTAWorkerThread2)); thread.IsBackground = true; thread.SetApartmentState(ApartmentState.MTA); thread.Start(); workerThreadInitialized = true; } ndx = reqList.Add(myReq); if (doIndicate.Set() == false) //SetEvent(hDoIndicate); { reqList.RemoveAt(ndx); throw new ManagementException(RC.GetString("WORKER_THREAD_WAKEUP_FAILED")); } } myReq.doneIndicate.WaitOne(); //WaitForSingleObject(hDoneIndicate, -1); if (myReq.exception != null) { throw myReq.exception; } } GC.KeepAlive(this); }
public void IndicateEvents(int length, IntPtr[] objects) { if (this.pSinkMTA != null) { if (!MTAHelper.IsNoContextMTA()) { EventSource.MTARequest mTARequest = new EventSource.MTARequest(length, objects); lock (this.critSec) { if (!this.workerThreadInitialized) { Thread thread = new Thread(new ThreadStart(this.MTAWorkerThread2)); thread.IsBackground = true; thread.SetApartmentState(ApartmentState.MTA); thread.Start(); this.workerThreadInitialized = true; } int num = this.reqList.Add(mTARequest); if (!this.doIndicate.Set()) { this.reqList.RemoveAt(num); throw new ManagementException(RC.GetString("WORKER_THREAD_WAKEUP_FAILED")); } } mTARequest.doneIndicate.WaitOne(); if (mTARequest.exception != null) { throw mTARequest.exception; } } else { int num1 = this.pSinkMTA.Indicate_(length, objects); if (num1 < 0) { if (((long)num1 & (long)-4096) != (long)-2147217408) { Marshal.ThrowExceptionForHR(num1); } else { ManagementException.ThrowWithExtendedInfo((ManagementStatus)num1); } } } GC.KeepAlive(this); return; } else { return; } }
public void IndicateEvents(int length, IntPtr[] objects) { if (this.pSinkMTA != null) { if (MTAHelper.IsNoContextMTA()) { int errorCode = this.pSinkMTA.Indicate_(length, objects); if (errorCode < 0) { if ((errorCode & 0xfffff000L) == 0x80041000L) { ManagementException.ThrowWithExtendedInfo((ManagementStatus)errorCode); } else { Marshal.ThrowExceptionForHR(errorCode); } } } else { MTARequest request = new MTARequest(length, objects); lock (this.critSec) { if (!this.workerThreadInitialized) { Thread thread = new Thread(new ThreadStart(this.MTAWorkerThread2)) { IsBackground = true }; thread.SetApartmentState(ApartmentState.MTA); thread.Start(); this.workerThreadInitialized = true; } int index = this.reqList.Add(request); if (!this.doIndicate.Set()) { this.reqList.RemoveAt(index); throw new ManagementException(RC.GetString("WORKER_THREAD_WAKEUP_FAILED")); } } request.doneIndicate.WaitOne(); if (request.exception != null) { throw request.exception; } } GC.KeepAlive(this); } }
public InstrumentedAssembly(Assembly assembly, SchemaNaming naming) { SecurityHelper.UnmanagedCode.Demand(); this.naming = naming; Assembly precompiledAssembly = naming.PrecompiledAssembly; if (null == precompiledAssembly) { CSharpCodeProvider provider = new CSharpCodeProvider(); CompilerParameters parameters = new CompilerParameters { GenerateInMemory = true }; parameters.ReferencedAssemblies.Add(assembly.Location); parameters.ReferencedAssemblies.Add(typeof(BaseEvent).Assembly.Location); parameters.ReferencedAssemblies.Add(typeof(Component).Assembly.Location); foreach (Type type in assembly.GetTypes()) { if (this.IsInstrumentedType(type)) { this.FindReferences(type, parameters); } } CompilerResults results = provider.CompileAssemblyFromSource(parameters, new string[] { naming.Code }); foreach (CompilerError error in results.Errors) { Console.WriteLine(error.ToString()); } if (results.Errors.HasErrors) { throw new Exception(RC.GetString("FAILED_TO_BUILD_GENERATED_ASSEMBLY")); } precompiledAssembly = results.CompiledAssembly; } Type type2 = precompiledAssembly.GetType("WMINET_Converter"); this.mapTypeToConverter = (Hashtable)type2.GetField("mapTypeToConverter").GetValue(null); if (!MTAHelper.IsNoContextMTA()) { new ThreadDispatch(new ThreadDispatch.ThreadWorkerMethodWithParam(this.InitEventSource)) { Parameter = this }.Start(); } else { this.InitEventSource(this); } }
/// <summary> /// <para>Commits the assembly to the operation.</para> /// </summary> /// <param name='savedState'>The state of the assembly.</param> public override void Commit(IDictionary savedState) { base.Commit(savedState); // See if we were asked to generate a MOF file if (Context.Parameters.ContainsKey("mof")) { string mofFile = Context.Parameters["mof"]; // bug#62252 - Pick a default MOF file name if (mofFile == null || mofFile.Length == 0) { mofFile = Context.Parameters["assemblypath"]; if (mofFile == null || mofFile.Length == 0) { mofFile = "defaultmoffile"; } else { mofFile = Path.GetFileName(mofFile); } } // Append '.mof' in necessary if (mofFile.Length < 4) { mofFile += ".mof"; } else { string end = mofFile.Substring(mofFile.Length - 4, 4); end.ToLower(CultureInfo.InvariantCulture); if (end != ".mof") { mofFile += ".mof"; } } Context.LogMessage(RC.GetString("MOFFILE_GENERATING") + " " + mofFile); using (StreamWriter log = new StreamWriter(mofFile, false, Encoding.Unicode)) { log.WriteLine("//**************************************************************************"); log.WriteLine("//* {0}", mofFile); log.WriteLine("//**************************************************************************"); log.WriteLine(mof); } } }
static void EnsureNamespace(InstallLogWrapper context, string namespaceName) { context.LogMessage(RC.GetString("NAMESPACE_ENSURE") + " " + namespaceName); string fullNamespace = null; foreach (string name in namespaceName.Split(new char[] { '\\' })) { if (fullNamespace == null) { fullNamespace = name; continue; } EnsureNamespace(fullNamespace, name); fullNamespace += "\\" + name; } }
private static void EnsureClassExists(InstallLogWrapper context, string classPath, ClassMaker classMakerFunction) { try { context.LogMessage(RC.GetString("CLASS_ENSURE") + " " + classPath); new ManagementClass(classPath).Get(); } catch (ManagementException exception) { if (exception.ErrorCode != ManagementStatus.NotFound) { throw exception; } context.LogMessage(RC.GetString("CLASS_ENSURECREATE") + " " + classPath); classMakerFunction().Put(); } }
public override void Commit(IDictionary savedState) { base.Commit(savedState); // See if we were asked to generate a MOF file if (Context.Parameters.ContainsKey("mof")) { string mofFile = Context.Parameters["mof"]; // if (mofFile == null || mofFile.Length == 0) { mofFile = Context.Parameters["assemblypath"]; if (mofFile == null || mofFile.Length == 0) { mofFile = "defaultmoffile"; } else { mofFile = Path.GetFileName(mofFile); } } // Append '.mof' in necessary if (mofFile.Length < 4) { mofFile += ".mof"; } else { if (String.Compare(mofFile.Substring(mofFile.Length - 4, 4), ".mof", StringComparison.OrdinalIgnoreCase) != 0) { mofFile += ".mof"; } } Context.LogMessage(RC.GetString("MOFFILE_GENERATING") + " " + mofFile); using (StreamWriter log = new StreamWriter(mofFile, false, Encoding.Unicode)) { log.WriteLine("//**************************************************************************"); log.WriteLine("//* {0}", mofFile); log.WriteLine("//**************************************************************************"); log.WriteLine(mof); } } }
private static void EnsureNamespace(InstallLogWrapper context, string namespaceName) { context.LogMessage(RC.GetString("NAMESPACE_ENSURE") + " " + namespaceName); string baseNamespace = null; foreach (string str2 in namespaceName.Split(new char[] { '\\' })) { if (baseNamespace == null) { baseNamespace = str2; } else { EnsureNamespace(baseNamespace, str2); baseNamespace = baseNamespace + @"\" + str2; } } }
public override void Install(IDictionary savedState) { // Demand IO permission required for LoadFrom FXCop 191096 FileIOPermission ioPermission = new FileIOPermission(FileIOPermissionAccess.Read, (string)Context.Parameters["assemblypath"]); ioPermission.Demand(); base.Install(savedState); // Context.LogMessage(RC.GetString("WMISCHEMA_INSTALLATIONSTART")); string assemblyPath = Context.Parameters["assemblypath"]; Assembly assembly = Assembly.LoadFrom(assemblyPath); SchemaNaming naming = SchemaNaming.GetSchemaNaming(assembly); // // We always use the full version number for Whidbey. // naming.DecoupledProviderInstanceName = AssemblyNameUtility.UniqueToAssemblyFullVersion(assembly); // See if this assembly provides instrumentation if (null == naming) { return; } // // [RAID: 123895] // If the force parameter is present, we update registration information independent if it already // exists. // if ((naming.IsAssemblyRegistered() == false) || (Context.Parameters.ContainsKey("force")) || (Context.Parameters.ContainsKey("f"))) { Context.LogMessage(RC.GetString("REGESTRING_ASSEMBLY") + " " + naming.DecoupledProviderInstanceName); naming.RegisterNonAssemblySpecificSchema(Context); naming.RegisterAssemblySpecificSchema(); } mof = naming.Mof; Context.LogMessage(RC.GetString("WMISCHEMA_INSTALLATIONEND")); }
private static void ReplaceClassIfNecessary(string classPath, ManagementClass newClass) { try { ManagementClass class2 = SafeGetClass(classPath); if (class2 == null) { newClass.Put(); } else if (newClass.GetText(TextFormat.Mof) != class2.GetText(TextFormat.Mof)) { class2.Delete(); newClass.Put(); } } catch (ManagementException exception) { throw new ArgumentException(string.Format(RC.GetString("CLASS_NOTREPLACED_EXCEPT") + "\r\n{0}\r\n{1}", classPath, newClass.GetText(TextFormat.Mof)), exception); } }
public override void Commit(IDictionary savedState) { base.Commit(savedState); if (base.Context.Parameters.ContainsKey("mof")) { string item = base.Context.Parameters["mof"]; if (item == null || item.Length == 0) { item = base.Context.Parameters["assemblypath"]; if (item == null || item.Length == 0) { item = "defaultmoffile"; } else { item = Path.GetFileName(item); } } if (item.Length >= 4) { if (string.Compare(item.Substring(item.Length - 4, 4), ".mof", StringComparison.OrdinalIgnoreCase) != 0) { item = string.Concat(item, ".mof"); } } else { item = string.Concat(item, ".mof"); } base.Context.LogMessage(string.Concat(RC.GetString("MOFFILE_GENERATING"), " ", item)); using (StreamWriter streamWriter = new StreamWriter(item, false, Encoding.Unicode)) { streamWriter.WriteLine("//**************************************************************************"); streamWriter.WriteLine("//* {0}", item); streamWriter.WriteLine("//**************************************************************************"); streamWriter.WriteLine(this.mof); } } }
static void EnsureClassExists(InstallLogWrapper context, string classPath, ClassMaker classMakerFunction) { try { context.LogMessage(RC.GetString("CLASS_ENSURE") + " " + classPath); ManagementClass theClass = new ManagementClass(classPath); theClass.Get(); } catch (ManagementException e) { if (e.ErrorCode == ManagementStatus.NotFound) { // The class does not exist. Create it. context.LogMessage(RC.GetString("CLASS_ENSURECREATE") + " " + classPath); ManagementClass theClass = classMakerFunction(); theClass.Put(); } else { throw e; } } }
public override void Commit(IDictionary savedState) { base.Commit(savedState); if (base.Context.Parameters.ContainsKey("mof")) { string path = base.Context.Parameters["mof"]; if ((path == null) || (path.Length == 0)) { path = base.Context.Parameters["assemblypath"]; if ((path == null) || (path.Length == 0)) { path = "defaultmoffile"; } else { path = Path.GetFileName(path); } } if (path.Length < 4) { path = path + ".mof"; } else if (string.Compare(path.Substring(path.Length - 4, 4), ".mof", StringComparison.OrdinalIgnoreCase) != 0) { path = path + ".mof"; } base.Context.LogMessage(RC.GetString("MOFFILE_GENERATING") + " " + path); using (StreamWriter writer = new StreamWriter(path, false, Encoding.Unicode)) { writer.WriteLine("//**************************************************************************"); writer.WriteLine("//* {0}", path); writer.WriteLine("//**************************************************************************"); writer.WriteLine(this.mof); } } }
private static void Initialize(Assembly assembly) { lock (instrumentedAssemblies) { if (instrumentedAssemblies.ContainsKey(assembly)) { return; } SchemaNaming naming = SchemaNaming.GetSchemaNaming(assembly); if (naming == null) { return; } if (false == naming.IsAssemblyRegistered()) { // If we are not an administrator, don't try to JIT install the schema if (!WMICapabilities.IsUserAdmin()) { throw new Exception(RC.GetString("ASSEMBLY_NOT_REGISTERED")); } // // We always use the full version number for Whidbey. // naming.DecoupledProviderInstanceName = AssemblyNameUtility.UniqueToAssemblyFullVersion(assembly); naming.RegisterNonAssemblySpecificSchema(null); naming.RegisterAssemblySpecificSchema(); } InstrumentedAssembly instrumentedAssembly = new InstrumentedAssembly(assembly, naming); instrumentedAssemblies.Add(assembly, instrumentedAssembly); } }
public SchemaMapping(Type type, SchemaNaming naming, Hashtable mapTypeToConverterClassName) { codeClassName = (string)mapTypeToConverterClassName[type]; classType = type; bool hasGenericEmbeddedObject = false; string baseClassName = ManagedNameAttribute.GetBaseClassName(type); className = ManagedNameAttribute.GetMemberName(type); instrumentationType = InstrumentationClassAttribute.GetAttribute(type).InstrumentationType; classPath = naming.NamespaceName + ":" + className; if (null == baseClassName) { newClass = new ManagementClass(naming.NamespaceName, "", null); newClass.SystemProperties ["__CLASS"].Value = className; } else { ManagementClass baseClass = new ManagementClass(naming.NamespaceName + ":" + baseClassName); if (instrumentationType == InstrumentationType.Instance) { bool baseAbstract = false; try { QualifierData o = baseClass.Qualifiers["abstract"]; if (o.Value is bool) { baseAbstract = (bool)o.Value; } } catch (ManagementException e) { if (e.ErrorCode != ManagementStatus.NotFound) { throw; } } if (!baseAbstract) { throw new Exception(RC.GetString("CLASSINST_EXCEPT")); } } newClass = baseClass.Derive(className); } // Create the converter class CodeWriter codeClass = code.AddChild("public class " + codeClassName + " : IWmiConverter"); // Create code block for one line Members CodeWriter codeOneLineMembers = codeClass.AddChild(new CodeWriter()); codeOneLineMembers.Line("static ManagementClass managementClass = new ManagementClass(@\"" + classPath + "\");"); codeOneLineMembers.Line("static IntPtr classWbemObjectIP;"); codeOneLineMembers.Line("static Guid iidIWbemObjectAccess = new Guid(\"49353C9A-516B-11D1-AEA6-00C04FB68820\");"); codeOneLineMembers.Line("internal ManagementObject instance = managementClass.CreateInstance();"); codeOneLineMembers.Line("object reflectionInfoTempObj = null ; "); codeOneLineMembers.Line("FieldInfo reflectionIWbemClassObjectField = null ; "); codeOneLineMembers.Line("IntPtr emptyWbemObject = IntPtr.Zero ; "); // // Reuters VSQFE#: 750 [marioh] see comments above // Used as a temporary pointer to the newly created instance that we create to avoid re-using the same // object causing unbound memory usage in IWbemClassObject implementation. codeOneLineMembers.Line("IntPtr theClone = IntPtr.Zero;"); codeOneLineMembers.Line("public static ManagementObject emptyInstance = managementClass.CreateInstance();"); // TODO: Make these non-public codeOneLineMembers.Line("public IntPtr instWbemObjectAccessIP;"); // Create static constructor to initialize handles CodeWriter codeCCTOR = codeClass.AddChild("static " + codeClassName + "()"); codeCCTOR.Line("classWbemObjectIP = (IntPtr)managementClass;"); codeCCTOR.Line("IntPtr wbemObjectAccessIP;"); codeCCTOR.Line("Marshal.QueryInterface(classWbemObjectIP, ref iidIWbemObjectAccess, out wbemObjectAccessIP);"); codeCCTOR.Line("int cimType;"); // Create constructor CodeWriter codeCTOR = codeClass.AddChild("public " + codeClassName + "()"); codeCTOR.Line("IntPtr wbemObjectIP = (IntPtr)instance;"); codeCTOR.Line("Marshal.QueryInterface(wbemObjectIP, ref iidIWbemObjectAccess, out instWbemObjectAccessIP);"); // // Reuters VSQFE#: 750 [marioh] // In the CCTOR we set things up only once: // 1. We get the IWbemClassObjectFreeThreaded object '_wbemObject' from the ManagementObject instance // 2. We then get the actual IntPtr to the underlying WMI object // 3. Finally, the simple cast to IntPtr from the ManagementObject instance // These fields will be used later during the ToWMI call. codeCTOR.Line("FieldInfo tempField = instance.GetType().GetField ( \"_wbemObject\", BindingFlags.Instance | BindingFlags.NonPublic );"); codeCTOR.Line("if ( tempField == null )"); codeCTOR.Line("{"); codeCTOR.Line(" tempField = instance.GetType().GetField ( \"wbemObject\", BindingFlags.Instance | BindingFlags.NonPublic ) ;"); codeCTOR.Line("}"); codeCTOR.Line("reflectionInfoTempObj = tempField.GetValue (instance) ;"); codeCTOR.Line("reflectionIWbemClassObjectField = reflectionInfoTempObj.GetType().GetField (\"pWbemClassObject\", BindingFlags.Instance | BindingFlags.NonPublic );"); codeCTOR.Line("emptyWbemObject = (IntPtr) emptyInstance;"); // Create destructor that will be called at process cleanup CodeWriter codeDTOR = codeClass.AddChild("~" + codeClassName + "()"); codeDTOR.AddChild("if(instWbemObjectAccessIP != IntPtr.Zero)").Line("Marshal.Release(instWbemObjectAccessIP);"); // Create method to convert from managed code to WMI CodeWriter codeToWMI = codeClass.AddChild("public void ToWMI(object obj)"); // // Reuters VSQFE#: 750 [marioh] see comments above // Ensure the release of the WbemObjectAccess interface pointer. codeToWMI.Line("if(instWbemObjectAccessIP != IntPtr.Zero)"); codeToWMI.Line("{"); codeToWMI.Line(" Marshal.Release(instWbemObjectAccessIP);"); codeToWMI.Line(" instWbemObjectAccessIP = IntPtr.Zero;"); codeToWMI.Line("}"); codeToWMI.Line("if(theClone != IntPtr.Zero)"); codeToWMI.Line("{"); codeToWMI.Line(" Marshal.Release(theClone);"); codeToWMI.Line(" theClone = IntPtr.Zero;"); codeToWMI.Line("}"); codeToWMI.Line("IWOA.Clone_f(12, emptyWbemObject, out theClone) ;"); codeToWMI.Line("Marshal.QueryInterface(theClone, ref iidIWbemObjectAccess, out instWbemObjectAccessIP) ;"); codeToWMI.Line("reflectionIWbemClassObjectField.SetValue ( reflectionInfoTempObj, theClone ) ;"); codeToWMI.Line(String.Format("{0} instNET = ({0})obj;", type.FullName.Replace('+', '.'))); // bug#92918 - watch for nested classes // Explicit cast to IntPtr CodeWriter codeIntPtrCast = codeClass.AddChild("public static explicit operator IntPtr(" + codeClassName + " obj)"); codeIntPtrCast.Line("return obj.instWbemObjectAccessIP;"); // Add GetInstance codeOneLineMembers.Line("public ManagementObject GetInstance() {return instance;}"); PropertyDataCollection props = newClass.Properties; // type specific info switch (instrumentationType) { case InstrumentationType.Event: break; case InstrumentationType.Instance: props.Add("ProcessId", CimType.String, false); props.Add("InstanceId", CimType.String, false); props["ProcessId"].Qualifiers.Add("key", true); props["InstanceId"].Qualifiers.Add("key", true); newClass.Qualifiers.Add("dynamic", true, false, false, false, true); newClass.Qualifiers.Add("provider", naming.DecoupledProviderInstanceName, false, false, false, true); break; case InstrumentationType.Abstract: newClass.Qualifiers.Add("abstract", true, false, false, false, true); break; default: break; } int propCount = 0; bool needsNullObj = false; foreach (MemberInfo field in type.GetMembers()) { if (!(field is FieldInfo || field is PropertyInfo)) { continue; } if (field.GetCustomAttributes(typeof(IgnoreMemberAttribute), false).Length > 0) { continue; } if (field is FieldInfo) { FieldInfo fi = field as FieldInfo; // We ignore statics if (fi.IsStatic) { ThrowUnsupportedMember(field); } } else if (field is PropertyInfo) { PropertyInfo pi = field as PropertyInfo; // We must have a 'get' property accessor if (!pi.CanRead) { ThrowUnsupportedMember(field); } // We ignore static properties MethodInfo mi = pi.GetGetMethod(); if (null == mi || mi.IsStatic) { ThrowUnsupportedMember(field); } // We don't support parameters on properties if (mi.GetParameters().Length > 0) { ThrowUnsupportedMember(field); } } String propName = ManagedNameAttribute.GetMemberName(field); #if SUPPORTS_ALTERNATE_WMI_PROPERTY_TYPE Type t2 = ManagedTypeAttribute.GetManagedType(field); #else Type t2; if (field is FieldInfo) { t2 = (field as FieldInfo).FieldType; } else { t2 = (field as PropertyInfo).PropertyType; } #endif bool isArray = false; if (t2.IsArray) { // We only support one dimensional arrays in this version if (t2.GetArrayRank() != 1) { ThrowUnsupportedMember(field); } isArray = true; t2 = t2.GetElementType(); } string embeddedTypeName = null; string embeddedConverterName = null; if (mapTypeToConverterClassName.Contains(t2)) { embeddedConverterName = (string)mapTypeToConverterClassName[t2]; embeddedTypeName = ManagedNameAttribute.GetMemberName(t2); } bool isGenericEmbeddedObject = false; if (t2 == typeof(object)) { isGenericEmbeddedObject = true; if (hasGenericEmbeddedObject == false) { hasGenericEmbeddedObject = true; // Add map codeOneLineMembers.Line("static Hashtable mapTypeToConverter = new Hashtable();"); foreach (DictionaryEntry entry in mapTypeToConverterClassName) { codeCCTOR.Line(String.Format("mapTypeToConverter[typeof({0})] = typeof({1});", ((Type)entry.Key).FullName.Replace('+', '.'), (string)entry.Value)); // bug#92918 - watch for nested classes } } } string propFieldName = "prop_" + (propCount); string handleFieldName = "handle_" + (propCount++); // Add handle for field, which is static accross all instances codeOneLineMembers.Line("static int " + handleFieldName + ";"); codeCCTOR.Line(String.Format("IWOA.GetPropertyHandle_f27(27, wbemObjectAccessIP, \"{0}\", out cimType, out {1});", propName, handleFieldName)); // Add PropertyData for field, which is specific to each instance codeOneLineMembers.Line("PropertyData " + propFieldName + ";"); codeCTOR.Line(String.Format("{0} = instance.Properties[\"{1}\"];", propFieldName, propName)); if (isGenericEmbeddedObject) { CodeWriter codeNotNull = codeToWMI.AddChild(String.Format("if(instNET.{0} != null)", field.Name)); CodeWriter codeElse = codeToWMI.AddChild("else"); codeElse.Line(String.Format("{0}.Value = null;", propFieldName)); if (isArray) { codeNotNull.Line(String.Format("int len = instNET.{0}.Length;", field.Name)); codeNotNull.Line("ManagementObject[] embeddedObjects = new ManagementObject[len];"); codeNotNull.Line("IWmiConverter[] embeddedConverters = new IWmiConverter[len];"); CodeWriter codeForLoop = codeNotNull.AddChild("for(int i=0;i<len;i++)"); CodeWriter codeFoundType = codeForLoop.AddChild(String.Format("if((instNET.{0}[i] != null) && mapTypeToConverter.Contains(instNET.{0}[i].GetType()))", field.Name)); codeFoundType.Line(String.Format("Type type = (Type)mapTypeToConverter[instNET.{0}[i].GetType()];", field.Name)); codeFoundType.Line("embeddedConverters[i] = (IWmiConverter)Activator.CreateInstance(type);"); codeFoundType.Line(String.Format("embeddedConverters[i].ToWMI(instNET.{0}[i]);", field.Name)); codeFoundType.Line("embeddedObjects[i] = embeddedConverters[i].GetInstance();"); codeForLoop.AddChild("else").Line(String.Format("embeddedObjects[i] = SafeAssign.GetManagementObject(instNET.{0}[i]);", field.Name)); codeNotNull.Line(String.Format("{0}.Value = embeddedObjects;", propFieldName)); } else { CodeWriter codeFoundType = codeNotNull.AddChild(String.Format("if(mapTypeToConverter.Contains(instNET.{0}.GetType()))", field.Name)); codeFoundType.Line(String.Format("Type type = (Type)mapTypeToConverter[instNET.{0}.GetType()];", field.Name)); codeFoundType.Line("IWmiConverter converter = (IWmiConverter)Activator.CreateInstance(type);"); codeFoundType.Line(String.Format("converter.ToWMI(instNET.{0});", field.Name)); codeFoundType.Line(String.Format("{0}.Value = converter.GetInstance();", propFieldName)); codeNotNull.AddChild("else").Line(String.Format("{0}.Value = SafeAssign.GetInstance(instNET.{1});", propFieldName, field.Name)); } } else if (embeddedTypeName != null) { // If this is an embedded struct, it cannot be null CodeWriter codeNotNull; if (t2.IsValueType) { codeNotNull = codeToWMI; } else { codeNotNull = codeToWMI.AddChild(String.Format("if(instNET.{0} != null)", field.Name)); CodeWriter codeElse = codeToWMI.AddChild("else"); codeElse.Line(String.Format("{0}.Value = null;", propFieldName)); } if (isArray) { codeNotNull.Line(String.Format("int len = instNET.{0}.Length;", field.Name)); codeNotNull.Line("ManagementObject[] embeddedObjects = new ManagementObject[len];"); codeNotNull.Line(String.Format("{0}[] embeddedConverters = new {0}[len];", embeddedConverterName)); CodeWriter codeForLoop = codeNotNull.AddChild("for(int i=0;i<len;i++)"); codeForLoop.Line(String.Format("embeddedConverters[i] = new {0}();", embeddedConverterName)); // If this is a struct array, the elements are never null if (t2.IsValueType) { codeForLoop.Line(String.Format("embeddedConverters[i].ToWMI(instNET.{0}[i]);", field.Name)); } else { CodeWriter codeArrayElementNotNull = codeForLoop.AddChild(String.Format("if(instNET.{0}[i] != null)", field.Name)); codeArrayElementNotNull.Line(String.Format("embeddedConverters[i].ToWMI(instNET.{0}[i]);", field.Name)); } codeForLoop.Line("embeddedObjects[i] = embeddedConverters[i].instance;"); codeNotNull.Line(String.Format("{0}.Value = embeddedObjects;", propFieldName)); } else { // We cannot create an instance of 'embeddedConverterName' because it may be the // same type as we are defining (in other words, a cyclic loop, such as class XXX // having an instance of an XXX as a member). To prevent an infinite loop of constructing // converter classes, we create a 'lazy' variable that is initialized to NULL, and the first // time it is used, we set it to a 'new embeddedConverterName'. codeOneLineMembers.Line(String.Format("{0} lazy_embeddedConverter_{1} = null;", embeddedConverterName, propFieldName)); CodeWriter codeConverterProp = codeClass.AddChild(String.Format("{0} embeddedConverter_{1}", embeddedConverterName, propFieldName)); CodeWriter codeGet = codeConverterProp.AddChild("get"); CodeWriter codeIf = codeGet.AddChild(String.Format("if(null == lazy_embeddedConverter_{0})", propFieldName)); codeIf.Line(String.Format("lazy_embeddedConverter_{0} = new {1}();", propFieldName, embeddedConverterName)); codeGet.Line(String.Format("return lazy_embeddedConverter_{0};", propFieldName)); codeNotNull.Line(String.Format("embeddedConverter_{0}.ToWMI(instNET.{1});", propFieldName, field.Name)); codeNotNull.Line(String.Format("{0}.Value = embeddedConverter_{0}.instance;", propFieldName)); } } else if (!isArray) { if (t2 == typeof(Byte) || t2 == typeof(SByte)) { codeToWMI.Line(String.Format("IWOA.WritePropertyValue_f28(28, instWbemObjectAccessIP, {0}, 1, ref instNET.{1});", handleFieldName, field.Name)); } else if (t2 == typeof(Int16) || t2 == typeof(UInt16) || t2 == typeof(Char)) { codeToWMI.Line(String.Format("IWOA.WritePropertyValue_f28(28, instWbemObjectAccessIP, {0}, 2, ref instNET.{1});", handleFieldName, field.Name)); } else if (t2 == typeof(UInt32) || t2 == typeof(Int32) || t2 == typeof(Single)) { codeToWMI.Line(String.Format("IWOA.WriteDWORD_f31(31, instWbemObjectAccessIP, {0}, instNET.{1});", handleFieldName, field.Name)); } else if (t2 == typeof(UInt64) || t2 == typeof(Int64) || t2 == typeof(Double)) { codeToWMI.Line(String.Format("IWOA.WriteQWORD_f33(33, instWbemObjectAccessIP, {0}, instNET.{1});", handleFieldName, field.Name)); } else if (t2 == typeof(Boolean)) { // TODO: Fix this to use IWOA // codeToWMI.Line(String.Format("{0}.Value = instNET.{1};", propFieldName, field.Name)); codeToWMI.Line(String.Format("if(instNET.{0})", field.Name)); codeToWMI.Line(String.Format(" IWOA.WritePropertyValue_f28(28, instWbemObjectAccessIP, {0}, 2, ref SafeAssign.boolTrue);", handleFieldName)); codeToWMI.Line("else"); codeToWMI.Line(String.Format(" IWOA.WritePropertyValue_f28(28, instWbemObjectAccessIP, {0}, 2, ref SafeAssign.boolFalse);", handleFieldName)); } else if (t2 == typeof(String)) { CodeWriter codeQuickString = codeToWMI.AddChild(String.Format("if(null != instNET.{0})", field.Name)); codeQuickString.Line(String.Format("IWOA.WritePropertyValue_f28(28, instWbemObjectAccessIP, {0}, (instNET.{1}.Length+1)*2, instNET.{1});", handleFieldName, field.Name)); // codeToWMI.AddChild("else").Line(String.Format("{0}.Value = instNET.{1};", propFieldName, field.Name)); codeToWMI.AddChild("else").Line(String.Format("IWOA.Put_f5(5, instWbemObjectAccessIP, \"{0}\", 0, ref nullObj, 8);", propName)); if (needsNullObj == false) { needsNullObj = true; // Bug#111623 - This line used to say 'nullObj = null;' When nullObj was passed // to IWOA.Put, this did NOT set the value of a string variable to NULL. The correct // thing to do was to pass a reference to DBNull.Value to IWOA.Put instead. codeOneLineMembers.Line("object nullObj = DBNull.Value;"); } } else if (t2 == typeof(DateTime) || t2 == typeof(TimeSpan)) { codeToWMI.Line(String.Format("IWOA.WritePropertyValue_f28(28, instWbemObjectAccessIP, {0}, 52, SafeAssign.WMITimeToString(instNET.{1}));", handleFieldName, field.Name)); // codeToWMI.Line(String.Format("{0}.Value = SafeAssign.DateTimeToString(instNET.{1});", propFieldName, field.Name)); } else { codeToWMI.Line(String.Format("{0}.Value = instNET.{1};", propFieldName, field.Name)); } } else { // We have an array type if (t2 == typeof(DateTime) || t2 == typeof(TimeSpan)) { codeToWMI.AddChild(String.Format("if(null == instNET.{0})", field.Name)).Line(String.Format("{0}.Value = null;", propFieldName)); codeToWMI.AddChild("else").Line(String.Format("{0}.Value = SafeAssign.WMITimeArrayToStringArray(instNET.{1});", propFieldName, field.Name)); } else { // This handles arrays of all primative types codeToWMI.Line(String.Format("{0}.Value = instNET.{1};", propFieldName, field.Name)); } } CimType cimtype = CimType.String; if (field.DeclaringType != type) { continue; } #if REQUIRES_EXPLICIT_DECLARATION_OF_INHERITED_PROPERTIES if (InheritedPropertyAttribute.GetAttribute(field) != null) { continue; } #else // See if this field already exists on the WMI class // In other words, is it inherited from a base class // TODO: Make this more efficient // - If we have a null base class name, all property names // should be new // - We could get all base class property names into a // hashtable, and look them up from there bool propertyExists = true; try { PropertyData prop = newClass.Properties[propName]; // HACK for bug#96863 - The above line used to throw a // not found exception. This was changed with a recent // checkin. If this functionality is not reverted, the // following statement should force the necessary 'not // found' exception that we are looking for. CimType cimType = prop.Type; // Make sure that if the property exists, it is inherited // If it is local, they probably named two properties with // the same name if (prop.IsLocal) { throw new ArgumentException(String.Format(RC.GetString("MEMBERCONFLILCT_EXCEPT"), field.Name), field.Name); } } catch (ManagementException e) { if (e.ErrorCode != ManagementStatus.NotFound) { throw; } else { propertyExists = false; } } if (propertyExists) { continue; } #endif if (embeddedTypeName != null) { cimtype = CimType.Object; } else if (isGenericEmbeddedObject) { cimtype = CimType.Object; } else if (t2 == typeof(ManagementObject)) { cimtype = CimType.Object; } else if (t2 == typeof(SByte)) { cimtype = CimType.SInt8; } else if (t2 == typeof(Byte)) { cimtype = CimType.UInt8; } else if (t2 == typeof(Int16)) { cimtype = CimType.SInt16; } else if (t2 == typeof(UInt16)) { cimtype = CimType.UInt16; } else if (t2 == typeof(Int32)) { cimtype = CimType.SInt32; } else if (t2 == typeof(UInt32)) { cimtype = CimType.UInt32; } else if (t2 == typeof(Int64)) { cimtype = CimType.SInt64; } else if (t2 == typeof(UInt64)) { cimtype = CimType.UInt64; } else if (t2 == typeof(Single)) { cimtype = CimType.Real32; } else if (t2 == typeof(Double)) { cimtype = CimType.Real64; } else if (t2 == typeof(Boolean)) { cimtype = CimType.Boolean; } else if (t2 == typeof(String)) { cimtype = CimType.String; } else if (t2 == typeof(Char)) { cimtype = CimType.Char16; } else if (t2 == typeof(DateTime)) { cimtype = CimType.DateTime; } else if (t2 == typeof(TimeSpan)) { cimtype = CimType.DateTime; } else { ThrowUnsupportedMember(field); } // HACK: The following line cause a strange System.InvalidProgramException when run through InstallUtil // throw new Exception("Unsupported type for event member - " + t2.Name); // TODO: if(t2 == typeof(Decimal)) #if SUPPORTS_WMI_DEFAULT_VAULES Object defaultValue = ManagedDefaultValueAttribute.GetManagedDefaultValue(field); // TODO: Is it safe to make this one line? if (null == defaultValue) { props.Add(propName, cimtype, false); } else { props.Add(propName, defaultValue, cimtype); } #else try { props.Add(propName, cimtype, isArray); } catch (ManagementException e) { ThrowUnsupportedMember(field, e); } #endif // Must at 'interval' SubType on TimeSpans if (t2 == typeof(TimeSpan)) { PropertyData prop = props[propName]; prop.Qualifiers.Add("SubType", "interval", false, true, true, true); } if (embeddedTypeName != null) { PropertyData prop = props[propName]; prop.Qualifiers["CIMTYPE"].Value = "object:" + embeddedTypeName; } } codeCCTOR.Line("Marshal.Release(wbemObjectAccessIP);"); // codeToWMI.Line("Console.WriteLine(instance.GetText(TextFormat.Mof));"); }
static public void ThrowUnsupportedMember(MemberInfo mi, Exception innerException) { throw new ArgumentException(String.Format(RC.GetString("UNSUPPORTEDMEMBER_EXCEPT"), mi.Name), mi.Name, innerException); }
public SchemaMapping(Type type, SchemaNaming naming, Hashtable mapTypeToConverterClassName) { this.codeClassName = (string)mapTypeToConverterClassName[type]; this.classType = type; bool flag = false; string baseClassName = ManagedNameAttribute.GetBaseClassName(type); this.className = ManagedNameAttribute.GetMemberName(type); this.instrumentationType = InstrumentationClassAttribute.GetAttribute(type).InstrumentationType; this.classPath = naming.NamespaceName + ":" + this.className; if (baseClassName == null) { this.newClass = new ManagementClass(naming.NamespaceName, "", null); this.newClass.SystemProperties["__CLASS"].Value = this.className; } else { ManagementClass class2 = new ManagementClass(naming.NamespaceName + ":" + baseClassName); if (this.instrumentationType == System.Management.Instrumentation.InstrumentationType.Instance) { bool flag2 = false; try { QualifierData data = class2.Qualifiers["abstract"]; if (data.Value is bool) { flag2 = (bool)data.Value; } } catch (ManagementException exception) { if (exception.ErrorCode != ManagementStatus.NotFound) { throw; } } if (!flag2) { throw new Exception(RC.GetString("CLASSINST_EXCEPT")); } } this.newClass = class2.Derive(this.className); } CodeWriter writer = this.code.AddChild("public class " + this.codeClassName + " : IWmiConverter"); CodeWriter writer2 = writer.AddChild(new CodeWriter()); writer2.Line("static ManagementClass managementClass = new ManagementClass(@\"" + this.classPath + "\");"); writer2.Line("static IntPtr classWbemObjectIP;"); writer2.Line("static Guid iidIWbemObjectAccess = new Guid(\"49353C9A-516B-11D1-AEA6-00C04FB68820\");"); writer2.Line("internal ManagementObject instance = managementClass.CreateInstance();"); writer2.Line("object reflectionInfoTempObj = null ; "); writer2.Line("FieldInfo reflectionIWbemClassObjectField = null ; "); writer2.Line("IntPtr emptyWbemObject = IntPtr.Zero ; "); writer2.Line("IntPtr originalObject = IntPtr.Zero ; "); writer2.Line("bool toWmiCalled = false ; "); writer2.Line("IntPtr theClone = IntPtr.Zero;"); writer2.Line("public static ManagementObject emptyInstance = managementClass.CreateInstance();"); writer2.Line("public IntPtr instWbemObjectAccessIP;"); CodeWriter writer3 = writer.AddChild("static " + this.codeClassName + "()"); writer3.Line("classWbemObjectIP = (IntPtr)managementClass;"); writer3.Line("IntPtr wbemObjectAccessIP;"); writer3.Line("Marshal.QueryInterface(classWbemObjectIP, ref iidIWbemObjectAccess, out wbemObjectAccessIP);"); writer3.Line("int cimType;"); CodeWriter writer4 = writer.AddChild("public " + this.codeClassName + "()"); writer4.Line("IntPtr wbemObjectIP = (IntPtr)instance;"); writer4.Line("originalObject = (IntPtr)instance;"); writer4.Line("Marshal.QueryInterface(wbemObjectIP, ref iidIWbemObjectAccess, out instWbemObjectAccessIP);"); writer4.Line("FieldInfo tempField = instance.GetType().GetField ( \"_wbemObject\", BindingFlags.Instance | BindingFlags.NonPublic );"); writer4.Line("if ( tempField == null )"); writer4.Line("{"); writer4.Line(" tempField = instance.GetType().GetField ( \"wbemObject\", BindingFlags.Instance | BindingFlags.NonPublic ) ;"); writer4.Line("}"); writer4.Line("reflectionInfoTempObj = tempField.GetValue (instance) ;"); writer4.Line("reflectionIWbemClassObjectField = reflectionInfoTempObj.GetType().GetField (\"pWbemClassObject\", BindingFlags.Instance | BindingFlags.NonPublic );"); writer4.Line("emptyWbemObject = (IntPtr) emptyInstance;"); CodeWriter writer5 = writer.AddChild("~" + this.codeClassName + "()"); writer5.AddChild("if(instWbemObjectAccessIP != IntPtr.Zero)").Line("Marshal.Release(instWbemObjectAccessIP);"); writer5.Line("if ( toWmiCalled == true )"); writer5.Line("{"); writer5.Line("\tMarshal.Release (originalObject);"); writer5.Line("}"); CodeWriter writer6 = writer.AddChild("public void ToWMI(object obj)"); writer6.Line("toWmiCalled = true ;"); writer6.Line("if(instWbemObjectAccessIP != IntPtr.Zero)"); writer6.Line("{"); writer6.Line(" Marshal.Release(instWbemObjectAccessIP);"); writer6.Line(" instWbemObjectAccessIP = IntPtr.Zero;"); writer6.Line("}"); writer6.Line("if(theClone != IntPtr.Zero)"); writer6.Line("{"); writer6.Line(" Marshal.Release(theClone);"); writer6.Line(" theClone = IntPtr.Zero;"); writer6.Line("}"); writer6.Line("IWOA.Clone_f(12, emptyWbemObject, out theClone) ;"); writer6.Line("Marshal.QueryInterface(theClone, ref iidIWbemObjectAccess, out instWbemObjectAccessIP) ;"); writer6.Line("reflectionIWbemClassObjectField.SetValue ( reflectionInfoTempObj, theClone ) ;"); writer6.Line(string.Format("{0} instNET = ({0})obj;", type.FullName.Replace('+', '.'))); writer.AddChild("public static explicit operator IntPtr(" + this.codeClassName + " obj)").Line("return obj.instWbemObjectAccessIP;"); writer2.Line("public ManagementObject GetInstance() {return instance;}"); PropertyDataCollection properties = this.newClass.Properties; switch (this.instrumentationType) { case System.Management.Instrumentation.InstrumentationType.Instance: properties.Add("ProcessId", CimType.String, false); properties.Add("InstanceId", CimType.String, false); properties["ProcessId"].Qualifiers.Add("key", true); properties["InstanceId"].Qualifiers.Add("key", true); this.newClass.Qualifiers.Add("dynamic", true, false, false, false, true); this.newClass.Qualifiers.Add("provider", naming.DecoupledProviderInstanceName, false, false, false, true); break; case System.Management.Instrumentation.InstrumentationType.Abstract: this.newClass.Qualifiers.Add("abstract", true, false, false, false, true); break; } int num = 0; bool flag3 = false; foreach (MemberInfo info in type.GetMembers()) { if (((info is FieldInfo) || (info is PropertyInfo)) && (info.GetCustomAttributes(typeof(IgnoreMemberAttribute), false).Length <= 0)) { Type fieldType; if (info is FieldInfo) { FieldInfo info2 = info as FieldInfo; if (info2.IsStatic) { ThrowUnsupportedMember(info); } } else if (info is PropertyInfo) { PropertyInfo info3 = info as PropertyInfo; if (!info3.CanRead) { ThrowUnsupportedMember(info); } MethodInfo getMethod = info3.GetGetMethod(); if ((null == getMethod) || getMethod.IsStatic) { ThrowUnsupportedMember(info); } if (getMethod.GetParameters().Length > 0) { ThrowUnsupportedMember(info); } } string memberName = ManagedNameAttribute.GetMemberName(info); if (info is FieldInfo) { fieldType = (info as FieldInfo).FieldType; } else { fieldType = (info as PropertyInfo).PropertyType; } bool isArray = false; if (fieldType.IsArray) { if (fieldType.GetArrayRank() != 1) { ThrowUnsupportedMember(info); } isArray = true; fieldType = fieldType.GetElementType(); } string str3 = null; string str4 = null; if (mapTypeToConverterClassName.Contains(fieldType)) { str4 = (string)mapTypeToConverterClassName[fieldType]; str3 = ManagedNameAttribute.GetMemberName(fieldType); } bool flag5 = false; if (fieldType == typeof(object)) { flag5 = true; if (!flag) { flag = true; writer2.Line("static Hashtable mapTypeToConverter = new Hashtable();"); foreach (DictionaryEntry entry in mapTypeToConverterClassName) { string introduced55 = ((Type)entry.Key).FullName.Replace('+', '.'); writer3.Line(string.Format("mapTypeToConverter[typeof({0})] = typeof({1});", introduced55, (string)entry.Value)); } } } string str5 = "prop_" + num; string str6 = "handle_" + num++; writer2.Line("static int " + str6 + ";"); writer3.Line(string.Format("IWOA.GetPropertyHandle_f27(27, wbemObjectAccessIP, \"{0}\", out cimType, out {1});", memberName, str6)); writer2.Line("PropertyData " + str5 + ";"); writer4.Line(string.Format("{0} = instance.Properties[\"{1}\"];", str5, memberName)); if (flag5) { CodeWriter writer8 = writer6.AddChild(string.Format("if(instNET.{0} != null)", info.Name)); writer6.AddChild("else").Line(string.Format("{0}.Value = null;", str5)); if (isArray) { writer8.Line(string.Format("int len = instNET.{0}.Length;", info.Name)); writer8.Line("ManagementObject[] embeddedObjects = new ManagementObject[len];"); writer8.Line("IWmiConverter[] embeddedConverters = new IWmiConverter[len];"); CodeWriter writer10 = writer8.AddChild("for(int i=0;i<len;i++)"); CodeWriter writer11 = writer10.AddChild(string.Format("if((instNET.{0}[i] != null) && mapTypeToConverter.Contains(instNET.{0}[i].GetType()))", info.Name)); writer11.Line(string.Format("Type type = (Type)mapTypeToConverter[instNET.{0}[i].GetType()];", info.Name)); writer11.Line("embeddedConverters[i] = (IWmiConverter)Activator.CreateInstance(type);"); writer11.Line(string.Format("embeddedConverters[i].ToWMI(instNET.{0}[i]);", info.Name)); writer11.Line("embeddedObjects[i] = embeddedConverters[i].GetInstance();"); writer10.AddChild("else").Line(string.Format("embeddedObjects[i] = SafeAssign.GetManagementObject(instNET.{0}[i]);", info.Name)); writer8.Line(string.Format("{0}.Value = embeddedObjects;", str5)); } else { CodeWriter writer12 = writer8.AddChild(string.Format("if(mapTypeToConverter.Contains(instNET.{0}.GetType()))", info.Name)); writer12.Line(string.Format("Type type = (Type)mapTypeToConverter[instNET.{0}.GetType()];", info.Name)); writer12.Line("IWmiConverter converter = (IWmiConverter)Activator.CreateInstance(type);"); writer12.Line(string.Format("converter.ToWMI(instNET.{0});", info.Name)); writer12.Line(string.Format("{0}.Value = converter.GetInstance();", str5)); writer8.AddChild("else").Line(string.Format("{0}.Value = SafeAssign.GetInstance(instNET.{1});", str5, info.Name)); } } else if (str3 != null) { CodeWriter writer13; if (fieldType.IsValueType) { writer13 = writer6; } else { writer13 = writer6.AddChild(string.Format("if(instNET.{0} != null)", info.Name)); writer6.AddChild("else").Line(string.Format("{0}.Value = null;", str5)); } if (isArray) { writer13.Line(string.Format("int len = instNET.{0}.Length;", info.Name)); writer13.Line("ManagementObject[] embeddedObjects = new ManagementObject[len];"); writer13.Line(string.Format("{0}[] embeddedConverters = new {0}[len];", str4)); CodeWriter writer15 = writer13.AddChild("for(int i=0;i<len;i++)"); writer15.Line(string.Format("embeddedConverters[i] = new {0}();", str4)); if (fieldType.IsValueType) { writer15.Line(string.Format("embeddedConverters[i].ToWMI(instNET.{0}[i]);", info.Name)); } else { writer15.AddChild(string.Format("if(instNET.{0}[i] != null)", info.Name)).Line(string.Format("embeddedConverters[i].ToWMI(instNET.{0}[i]);", info.Name)); } writer15.Line("embeddedObjects[i] = embeddedConverters[i].instance;"); writer13.Line(string.Format("{0}.Value = embeddedObjects;", str5)); } else { writer2.Line(string.Format("{0} lazy_embeddedConverter_{1} = null;", str4, str5)); CodeWriter writer18 = writer.AddChild(string.Format("{0} embeddedConverter_{1}", str4, str5)).AddChild("get"); writer18.AddChild(string.Format("if(null == lazy_embeddedConverter_{0})", str5)).Line(string.Format("lazy_embeddedConverter_{0} = new {1}();", str5, str4)); writer18.Line(string.Format("return lazy_embeddedConverter_{0};", str5)); writer13.Line(string.Format("embeddedConverter_{0}.ToWMI(instNET.{1});", str5, info.Name)); writer13.Line(string.Format("{0}.Value = embeddedConverter_{0}.instance;", str5)); } } else if (!isArray) { if ((fieldType == typeof(byte)) || (fieldType == typeof(sbyte))) { writer6.Line(string.Format("{0} instNET_{1} = instNET.{1} ;", fieldType, info.Name)); writer6.Line(string.Format("IWOA.WritePropertyValue_f28(28, instWbemObjectAccessIP, {0}, 1, ref instNET_{1});", str6, info.Name)); } else if (((fieldType == typeof(short)) || (fieldType == typeof(ushort))) || (fieldType == typeof(char))) { writer6.Line(string.Format("{0} instNET_{1} = instNET.{1} ;", fieldType, info.Name)); writer6.Line(string.Format("IWOA.WritePropertyValue_f28(28, instWbemObjectAccessIP, {0}, 2, ref instNET_{1});", str6, info.Name)); } else if (((fieldType == typeof(uint)) || (fieldType == typeof(int))) || (fieldType == typeof(float))) { writer6.Line(string.Format("IWOA.WriteDWORD_f31(31, instWbemObjectAccessIP, {0}, instNET.{1});", str6, info.Name)); } else if (((fieldType == typeof(ulong)) || (fieldType == typeof(long))) || (fieldType == typeof(double))) { writer6.Line(string.Format("IWOA.WriteQWORD_f33(33, instWbemObjectAccessIP, {0}, instNET.{1});", str6, info.Name)); } else if (fieldType == typeof(bool)) { writer6.Line(string.Format("if(instNET.{0})", info.Name)); writer6.Line(string.Format(" IWOA.WritePropertyValue_f28(28, instWbemObjectAccessIP, {0}, 2, ref SafeAssign.boolTrue);", str6)); writer6.Line("else"); writer6.Line(string.Format(" IWOA.WritePropertyValue_f28(28, instWbemObjectAccessIP, {0}, 2, ref SafeAssign.boolFalse);", str6)); } else if (fieldType == typeof(string)) { writer6.AddChild(string.Format("if(null != instNET.{0})", info.Name)).Line(string.Format("IWOA.WritePropertyValue_f28(28, instWbemObjectAccessIP, {0}, (instNET.{1}.Length+1)*2, instNET.{1});", str6, info.Name)); writer6.AddChild("else").Line(string.Format("IWOA.Put_f5(5, instWbemObjectAccessIP, \"{0}\", 0, ref nullObj, 8);", memberName)); if (!flag3) { flag3 = true; writer2.Line("object nullObj = DBNull.Value;"); } } else if ((fieldType == typeof(DateTime)) || (fieldType == typeof(TimeSpan))) { writer6.Line(string.Format("IWOA.WritePropertyValue_f28(28, instWbemObjectAccessIP, {0}, 52, SafeAssign.WMITimeToString(instNET.{1}));", str6, info.Name)); } else { writer6.Line(string.Format("{0}.Value = instNET.{1};", str5, info.Name)); } } else if ((fieldType == typeof(DateTime)) || (fieldType == typeof(TimeSpan))) { writer6.AddChild(string.Format("if(null == instNET.{0})", info.Name)).Line(string.Format("{0}.Value = null;", str5)); writer6.AddChild("else").Line(string.Format("{0}.Value = SafeAssign.WMITimeArrayToStringArray(instNET.{1});", str5, info.Name)); } else { writer6.Line(string.Format("{0}.Value = instNET.{1};", str5, info.Name)); } CimType propertyType = CimType.String; if (info.DeclaringType == type) { bool flag6 = true; try { PropertyData data2 = this.newClass.Properties[memberName]; CimType type1 = data2.Type; if (data2.IsLocal) { throw new ArgumentException(string.Format(RC.GetString("MEMBERCONFLILCT_EXCEPT"), info.Name), info.Name); } } catch (ManagementException exception2) { if (exception2.ErrorCode != ManagementStatus.NotFound) { throw; } flag6 = false; } if (!flag6) { if (str3 != null) { propertyType = CimType.Object; } else if (flag5) { propertyType = CimType.Object; } else if (fieldType == typeof(ManagementObject)) { propertyType = CimType.Object; } else if (fieldType == typeof(sbyte)) { propertyType = CimType.SInt8; } else if (fieldType == typeof(byte)) { propertyType = CimType.UInt8; } else if (fieldType == typeof(short)) { propertyType = CimType.SInt16; } else if (fieldType == typeof(ushort)) { propertyType = CimType.UInt16; } else if (fieldType == typeof(int)) { propertyType = CimType.SInt32; } else if (fieldType == typeof(uint)) { propertyType = CimType.UInt32; } else if (fieldType == typeof(long)) { propertyType = CimType.SInt64; } else if (fieldType == typeof(ulong)) { propertyType = CimType.UInt64; } else if (fieldType == typeof(float)) { propertyType = CimType.Real32; } else if (fieldType == typeof(double)) { propertyType = CimType.Real64; } else if (fieldType == typeof(bool)) { propertyType = CimType.Boolean; } else if (fieldType == typeof(string)) { propertyType = CimType.String; } else if (fieldType == typeof(char)) { propertyType = CimType.Char16; } else if (fieldType == typeof(DateTime)) { propertyType = CimType.DateTime; } else if (fieldType == typeof(TimeSpan)) { propertyType = CimType.DateTime; } else { ThrowUnsupportedMember(info); } try { properties.Add(memberName, propertyType, isArray); } catch (ManagementException exception3) { ThrowUnsupportedMember(info, exception3); } if (fieldType == typeof(TimeSpan)) { PropertyData data3 = properties[memberName]; data3.Qualifiers.Add("SubType", "interval", false, true, true, true); } if (str3 != null) { PropertyData data4 = properties[memberName]; data4.Qualifiers["CIMTYPE"].Value = "object:" + str3; } } } } } writer3.Line("Marshal.Release(wbemObjectAccessIP);"); }
public InstrumentedAssembly(Assembly assembly, SchemaNaming naming) { SecurityHelper.UnmanagedCode.Demand(); // Bug#112640 - Close off any potential use from anything but fully trusted code this.naming = naming; Assembly compiledAssembly = naming.PrecompiledAssembly; if (null == compiledAssembly) { CSharpCodeProvider provider = new CSharpCodeProvider(); // ICodeCompiler compiler = provider.CreateCompiler(); CompilerParameters parameters = new CompilerParameters(); parameters.GenerateInMemory = true; parameters.ReferencedAssemblies.Add(assembly.Location); parameters.ReferencedAssemblies.Add(typeof(BaseEvent).Assembly.Location); parameters.ReferencedAssemblies.Add(typeof(System.ComponentModel.Component).Assembly.Location); // Must reference any base types in 'assembly' // foreach (Type type in assembly.GetTypes()) { // Only interested in instrumented types (VSQFE#2469) if (IsInstrumentedType(type)) { FindReferences(type, parameters); } } CompilerResults results = provider.CompileAssemblyFromSource(parameters, naming.Code); foreach (CompilerError err in results.Errors) { Console.WriteLine(err.ToString()); } if (results.Errors.HasErrors) { // we failed to compile the generated code - the compile error shows up on console but we need to throw throw new Exception(RC.GetString("FAILED_TO_BUILD_GENERATED_ASSEMBLY")); } compiledAssembly = results.CompiledAssembly; } Type dynType = compiledAssembly.GetType("WMINET_Converter"); mapTypeToConverter = (Hashtable)dynType.GetField("mapTypeToConverter").GetValue(null); // if (!MTAHelper.IsNoContextMTA()) // Bug#110141 - Checking for MTA is not enough. We need to make sure we are not in a COM+ Context { ThreadDispatch disp = new ThreadDispatch(new ThreadDispatch.ThreadWorkerMethodWithParam(InitEventSource)); disp.Parameter = this; disp.Start( ); // We are on an STA thread. Create the event source on an MTA // Thread thread = new Thread(new ThreadStart(InitEventSource)); // thread.ApartmentState = ApartmentState.MTA; // thread.Start(); // thread.Join(); } else { InitEventSource(this); } }