Beispiel #1
0
        internal MI_Result GetIndication(
            out MI_Instance instance,
            out string bookmark,
            out string machineID,
            out bool moreResults,
            out MI_Result result,
            out string errorMessage,
            out MI_Instance completionDetails
            )
        {
            MI_Instance instanceLocal          = MI_Instance.NewIndirectPtr();
            MI_String   bookmarkLocal          = MI_String.NewIndirectPtr();
            MI_String   machineIDLocal         = MI_String.NewIndirectPtr();
            MI_String   errorMessageLocal      = MI_String.NewIndirectPtr();
            MI_Instance completionDetailsLocal = MI_Instance.NewIndirectPtr();

            MI_Result resultLocal = this.ft.GetIndication(this,
                                                          instanceLocal,
                                                          bookmarkLocal,
                                                          machineIDLocal,
                                                          out moreResults,
                                                          out result,
                                                          errorMessageLocal,
                                                          completionDetailsLocal);

            instance          = instanceLocal;
            bookmark          = bookmarkLocal.Value;
            machineID         = machineIDLocal.Value;
            errorMessage      = errorMessageLocal.Value;
            completionDetails = completionDetailsLocal;
            return(resultLocal);
        }
Beispiel #2
0
        internal MI_Result GetElementAt(
            UInt32 index,
            out string name,
            out MI_Value value,
            out bool valueExists,
            out MI_Type type,
            out string referenceClass,
            out MI_QualifierSet qualifierSet,
            out MI_Flags flags
            )
        {
            MI_String       nameLocal           = MI_String.NewIndirectPtr();
            MI_String       referenceClassLocal = MI_String.NewIndirectPtr();
            MI_Value        valueLocal          = new MI_Value();
            MI_QualifierSet qualifierSetLocal   = MI_QualifierSet.NewDirectPtr();

            MI_Result resultLocal = this.ft.GetElementAt(this,
                                                         index,
                                                         nameLocal,
                                                         valueLocal,
                                                         out valueExists,
                                                         out type,
                                                         referenceClassLocal,
                                                         qualifierSetLocal,
                                                         out flags);

            name           = nameLocal.Value;
            referenceClass = referenceClassLocal.Value;
            value          = valueLocal;
            qualifierSet   = qualifierSetLocal;
            return(resultLocal);
        }
        internal static MI_Deserializer.MI_Deserializer_ClassObjectNeededNative GetNativeClassObjectNeededCallback(string format, MI_Deserializer.MI_Deserializer_ClassObjectNeeded managedCallback)
        {
            if (managedCallback == null)
            {
                return(null);
            }

            return(delegate(
                       IntPtr context,
                       IntPtr serverNamePtr,
                       IntPtr namespaceNamePtr,
                       IntPtr classNamePtr,
                       IntPtr requestedClassObject)
            {
                MI_String serverName = MI_String.NewFromDirectPtr(serverNamePtr);
                MI_String namespaceName = MI_String.NewFromDirectPtr(namespaceNamePtr);
                MI_String className = MI_String.NewFromDirectPtr(classNamePtr);

                MI_Class classObject;

                try
                {
                    var localResult = managedCallback(serverName.Value, namespaceName.Value, className.Value, out classObject);
                    if (localResult == MI_Result.MI_RESULT_OK)
                    {
                        IntPtr outPtr;
                        if (MI_SerializationFormat.MOF.Equals(format, StringComparison.OrdinalIgnoreCase))
                        {
                            // The MOF deserializer helpfully tries to manage the class objects returned by the
                            // callback and will cheerfully delete them without warning. Return a copy instead.
                            MI_Class tmp;
                            localResult = classObject.Clone(out tmp);
                            if (localResult != MI_Result.MI_RESULT_OK)
                            {
                                return localResult;
                            }

                            outPtr = tmp.Ptr;
                        }
                        else
                        {
                            outPtr = classObject.Ptr;
                        }

                        Marshal.WriteIntPtr(requestedClassObject, outPtr);
                    }

                    return localResult;
                }
                catch
                {
                    return MI_Result.MI_RESULT_FAILED;
                }
            });
        }
Beispiel #4
0
        internal MI_Result GetServerName(
            out string name
            )
        {
            MI_String nameLocal = MI_String.NewIndirectPtr();

            MI_Result resultLocal = this.ft.GetServerName(this,
                                                          nameLocal);

            name = nameLocal.Value;
            return(resultLocal);
        }
Beispiel #5
0
        internal MI_Result GetClassName(
            out string className
            )
        {
            MI_String classNameLocal = MI_String.NewIndirectPtr();

            MI_Result resultLocal = this.ft.GetClassName(this,
                                                         classNameLocal);

            className = classNameLocal.Value;
            return(resultLocal);
        }
        internal MI_Result GetCredentialsAt(
            UInt32 index,
            out string optionName,
            MI_UserCredentials credentials,
            out UInt32 flags
            )
        {
            MI_String optionNameLocal = MI_String.NewIndirectPtr();

            MI_Result resultLocal = this.ft.GetCredentialsAt(this,
                                                             index,
                                                             optionNameLocal,
                                                             credentials,
                                                             out flags);

            optionName = optionNameLocal.Value;
            return(resultLocal);
        }
        internal MI_Result GetString(
            string optionName,
            out string value,
            out UInt32 index,
            out UInt32 flags
            )
        {
            MI_String valueLocal = MI_String.NewIndirectPtr();

            MI_Result resultLocal = this.ft.GetString(this,
                                                      optionName,
                                                      valueLocal,
                                                      out index,
                                                      out flags);

            value = valueLocal.Value;
            return(resultLocal);
        }
        internal MI_Result GetOptionAt(
            UInt32 index,
            out string optionName,
            MI_Value value,
            out MI_Type type,
            out UInt32 flags
            )
        {
            MI_String optionNameLocal = MI_String.NewIndirectPtr();

            MI_Result resultLocal = this.ft.GetOptionAt(this,
                                                        index,
                                                        optionNameLocal,
                                                        value,
                                                        out type,
                                                        out flags);

            optionName = optionNameLocal.Value;
            return(resultLocal);
        }
        internal MI_Result GetCredentialsAt(
            UInt32 index,
            out string optionName,
            out MI_UserCredentials credentials,
            out MI_DestinationOptionsFlags flags
            )
        {
            MI_String          optionNameLocal  = MI_String.NewIndirectPtr();
            MI_UserCredentials credentialsLocal = new MI_UserCredentials();

            MI_Result resultLocal = this.ft.GetCredentialsAt(this,
                                                             index,
                                                             optionNameLocal,
                                                             ref credentialsLocal,
                                                             out flags);

            optionName  = optionNameLocal.Value;
            credentials = credentialsLocal;
            return(resultLocal);
        }
Beispiel #10
0
        internal MI_Result GetElementAt(
            UInt32 index,
            out string name,
            out MI_Value value,
            out MI_Type type,
            out MI_Flags flags
            )
        {
            MI_Value  valueLocal  = new MI_Value();
            MI_String nameLocal   = MI_String.NewIndirectPtr();
            MI_Result resultLocal = this.ft.GetElementAt(this,
                                                         index,
                                                         nameLocal,
                                                         valueLocal,
                                                         out type,
                                                         out flags);

            value = valueLocal;
            name  = nameLocal.Value;
            return(resultLocal);
        }
Beispiel #11
0
        internal MI_Result GetQualifierAt(
            UInt32 index,
            out string name,
            out MI_Type qualifierType,
            out MI_Flags qualifierFlags,
            out MI_Value qualifierValue
            )
        {
            MI_String nameLocal           = MI_String.NewIndirectPtr();
            MI_Value  qualifierValueLocal = new MI_Value();

            MI_Result resultLocal = this.ft.GetQualifierAt(this,
                                                           index,
                                                           nameLocal,
                                                           out qualifierType,
                                                           out qualifierFlags,
                                                           qualifierValueLocal);

            name           = nameLocal.Value;
            qualifierValue = qualifierValueLocal;
            return(resultLocal);
        }
        internal MI_Result GetCredentialsPasswordAt(
            UInt32 index,
            out string optionName,
            string password,
            UInt32 bufferLength,
            out UInt32 passwordLength,
            out UInt32 flags
            )
        {
            MI_String optionNameLocal = MI_String.NewIndirectPtr();

            MI_Result resultLocal = this.ft.GetCredentialsPasswordAt(this,
                                                                     index,
                                                                     optionNameLocal,
                                                                     password,
                                                                     bufferLength,
                                                                     out passwordLength,
                                                                     out flags);

            optionName = optionNameLocal.Value;
            return(resultLocal);
        }
Beispiel #13
0
        internal MI_Result GetParameter(
            string name,
            out MI_Type parameterType,
            out string referenceClass,
            out MI_QualifierSet qualifierSet,
            out UInt32 index
            )
        {
            MI_String       referenceClassLocal = MI_String.NewIndirectPtr();
            MI_QualifierSet qualifierSetLocal   = MI_QualifierSet.NewDirectPtr();

            MI_Result resultLocal = this.ft.GetParameter(this,
                                                         name,
                                                         out parameterType,
                                                         referenceClassLocal,
                                                         qualifierSetLocal,
                                                         out index);

            referenceClass = referenceClassLocal.Value;
            qualifierSet   = qualifierSetLocal;
            return(resultLocal);
        }
Beispiel #14
0
        internal MI_Result GetMethodAt(
            UInt32 index,
            out string name,
            out MI_QualifierSet qualifierSet,
            out MI_ParameterSet parameterSet
            )
        {
            MI_String       nameLocal         = MI_String.NewIndirectPtr();
            MI_QualifierSet qualifierSetLocal = MI_QualifierSet.NewDirectPtr();
            MI_ParameterSet parameterSetLocal = MI_ParameterSet.NewDirectPtr();

            MI_Result resultLocal = this.ft.GetMethodAt(this,
                                                        index,
                                                        nameLocal,
                                                        qualifierSetLocal,
                                                        parameterSetLocal);

            name         = nameLocal.Value;
            qualifierSet = qualifierSetLocal;
            parameterSet = parameterSetLocal;
            return(resultLocal);
        }
Beispiel #15
0
        internal MI_Result GetInstance(
            out MI_Instance instance,
            out bool moreResults,
            out MI_Result result,
            out string errorMessage,
            out MI_Instance completionDetails
            )
        {
            MI_Instance instanceLocal          = MI_Instance.NewIndirectPtr();
            MI_String   errorMessageLocal      = MI_String.NewIndirectPtr();
            MI_Instance completionDetailsLocal = MI_Instance.NewIndirectPtr();

            MI_Result resultLocal = this.ft.GetInstance(this,
                                                        instanceLocal,
                                                        out moreResults,
                                                        out result,
                                                        errorMessageLocal,
                                                        completionDetailsLocal);

            instance          = instanceLocal;
            errorMessage      = errorMessageLocal.Value;
            completionDetails = completionDetailsLocal;
            return(resultLocal);
        }