//----------------------------------------------------------------------------
//
// Copyright (c) Intel Corporation, 2011 - 2015  All Rights Reserved.
//
//  File:       GeneralInfoApi.cs
//
//  Contents:   Api code for Intel(R) Active Management Technology
//              (Intel® AMT) GeneralInfo Sample.
//
//  Notes:      This sample demonstrates how to how to use various commands of
//              the GeneralInfo service.  
//
//----------------------------------------------------------------------------
using System;
using Intel.Management.Wsman;
using Connection;
using System.Security;

namespace GeneralInfo
{
    public class GeneralInfoApi : Connection_setup
    {
        #region CONSTANTS

        private const string SKU_STRING = "Sku";
        private const string RESERVED_STRING = "Reserved";

        private static readonly uint[] AMT_HIGHER_2_SKU_VERSION_VALUES = {0x00000001,0x00000002,0x00000004,0x00000008,
															 0x00000010,0x00000020,0x00000040,0x00000080,
															 0x00000100,0x00000200,0x00000400,0x00000800,
															 0x00001000,0x00002000,0x00004000,0x00008000,
															 0xFFFF0000};
        private static readonly string[] AMT_HIGHER_2_SKU_VERSION_STRINGS = {"Reserved","Intel(r)QST","ASF","Intel(r)AMT",
														   "Intel(r)Standard Manageability","Intel(r)TPM","Reserved",
														   "Reserved","Intel(r)RPAT","Reserved","Reserved","Reserved",
														   "Reserved","Intel(r)AT-p","Corporate",
                                                           "Level III Manageability Upgrade","Reserved"};
        private const uint ENABLED = 2;
        private const uint HOST_NAME = 2;

        private static readonly string[] KVM_ENABLED_STATE_STRINGS = {"Unknown", "Other", "Enabled", "Disabled", 
                                                                         "Shutting Down", "Not Applicable",
                                                                         "Enabled but Offline", "In Test", "Deferred", 
                                                                         "Quiesce", "Starting"};
        private static readonly string[] InstanceID = { "Flash", "Netstack", "AMTApps", "AMT", "Sku", "VendorID", "Build Number", "Recovery Version", "Recovery Build Num", "Legacy Mode" };
        // AMT_RedirectionService states
        private enum RedirectionServiceStates : int
        {
            NONE = 32768,
            IDER,
            SOL,
            IDER_SOL,
        }

        private const string FIRST_VERSION_SUPPORTING_KVM = "6.0.0";

        //Privacy levels
        private enum PrivacyLevel
        {
            Default = 0,
            Enhanced,
            Extreme,
        }

        // Provisioning Mode Types 
        private enum ProvisioningModeTypes
        {
            ProvisioningModeCurrent = 0,
            ProvisioningModeEnterprise,
            ProvisioningModeSmallBusiness,
            ProvisioningModeRemoteConnectivity,
        }

        // Provisioning State Types 
        private enum ProvisioningStateTypes
        {
            ProvisioningStatePre = 0,
            ProvisioningStateIn,
            ProvisioningStatePost,
        }

        // Password Model State Types 
        private enum PasswordModelStateTypes
        {
            PasswordModelCoupled = 0,
            PasswordModelSeparate,
            PasswordModelSeparateHash,
        }

        #endregion CONSTANTS

        #region CONSTRUCTORS

        // Creating the connection to the WSMan Client.
        // Inheriting Connection details from Connection_setup class.

        public GeneralInfoApi(string ip, string username, SecureString pwd, bool krb, MpsManager proxy, bool acceptSelfSignedCertificate = false)
            : base(ip, username, pwd, krb, proxy, acceptSelfSignedCertificate)
        {
        }

        public GeneralInfoApi(string ip, string username, SecureString pwd, string clientCert, bool krb, MpsManager proxy, bool acceptSelfSignedCertificate = false)
            : base(ip, username, pwd, clientCert, krb, proxy, acceptSelfSignedCertificate)
        {
        }

        #endregion CONSTRUCTORS

        #region PUBLIC_FUNCTIONS

        /// <summary>
        /// 
        /// </summary>
        public void GetPrivacyLevel()
        {
            Console.WriteLine("---------------Get Privacy Level--------------");

            string version = UtilitiesMethods.GetCoreVersion(wsmanClient);

            if (UtilitiesMethods.CompareVersions(version, "7.0") < 0)
                Console.WriteLine("This use case is supported from Intel AMT FW version 7.0 and above.");
            else
            {
                IManagedReference generalSettingRef = wsmanClient.NewReference("SELECT * FROM AMT_GeneralSettings WHERE InstanceID='Intel(r) AMT: General Settings'");

                IManagedInstance generalSettingInstance = generalSettingRef.Get();

                IWsmanItem privacyLevel = generalSettingInstance.GetProperty("PrivacyLevel");

                if (privacyLevel.Count != 0)
                    Console.WriteLine("Privacy Level: {0}\n", (PrivacyLevel)uint.Parse(privacyLevel.ToString()));
                else
                    Console.WriteLine("Privacy Level is not supported");
            }
        }

        /// <summary>
        /// Getting the host name. 
        /// </summary>
        public void GetHostName()
        {
            Console.WriteLine("---------------Get HostName--------------");

            IManagedReference generalSettingRef = wsmanClient.NewReference("SELECT * FROM AMT_GeneralSettings WHERE InstanceID='Intel(r) AMT: General Settings'");

            IManagedInstance generalSettingInstance = generalSettingRef.Get();

            IWsmanItem hostName = generalSettingInstance.GetProperty("HostName");

            Console.WriteLine("Intel AMT HostName: {0}\n", hostName.ToString());
        }

        /// <summary>
        /// Getting the administrator's ACL status.
        /// </summary>
        public void GetAdminAclStatus()
        {
            Console.WriteLine("---------------Get Admin ACL Status--------------");

            // Getting the AMT_AuthorizationService instance.
            IManagedReference authorizationServiceRef = wsmanClient.NewReference("SELECT * FROM  AMT_AuthorizationService WHERE Name='Intel(r) AMT Authorization Service'");
            IManagedInstance inputObject = authorizationServiceRef.CreateMethodInput("GetAdminAclEntryStatus");
            IManagedInstance outputObject = authorizationServiceRef.InvokeMethod(inputObject);

            IWsmanItem returnValue = outputObject.GetProperty("ReturnValue");

            if (returnValue.ToString().CompareTo("0") == 0)
            {
                IWsmanItem isDefault = outputObject.GetProperty("IsDefault");

                if (isDefault.ToString().CompareTo("true") == 0)
                    Console.WriteLine("Admin password was never changed...");

                Console.WriteLine("Intel AMT Admin ACL Status: {0}", returnValue.ToString());
                Console.WriteLine("AdminACLEntrySatus IsDefault: {0}\n", isDefault.ToString());
            }
        }

        /// <summary>
        /// Getting the administrator's network ACL status.
        /// </summary>
        public void GetAdminNetAclStatus()
        {
            Console.WriteLine("---------------Get Admin Net ACL Status--------------");

            IManagedReference authorizationServiceRef = wsmanClient.NewReference("SELECT * FROM  AMT_AuthorizationService WHERE Name='Intel(r) AMT Authorization Service'");

            IManagedInstance inputObject = authorizationServiceRef.CreateMethodInput("GetAdminNetAclEntryStatus");
            IManagedInstance outputObject = authorizationServiceRef.InvokeMethod(inputObject);

            IWsmanItem returnValue = outputObject.GetProperty("ReturnValue");

            Console.WriteLine("Intel AMT Admin ACL Status: {0}\n", returnValue.ToString());
            if (returnValue.ToString().CompareTo("0") == 0)
            {
                IWsmanItem isDefault = outputObject.GetProperty("IsDefault");
                Console.WriteLine("AdminNetAclEntryStatus IsDefault: {0}", isDefault.ToString());
            }
        }

        /// <summary>
        /// Getting audit provisioning record.
        /// </summary>
        public void GetAuditProvisionRecord()
        {
            Console.WriteLine("---------------Get audit provisioning record---------------");
            string version = UtilitiesMethods.GetCoreVersion(wsmanClient);

            if (UtilitiesMethods.CompareVersions(version ,"6.1") < 0)
                Console.WriteLine("This use case is supported from Intel AMT FW version 6.1 and above.");
            else
            {
                IManagedInstance provisioningAuditRecordInstance = null;
                try
                {
                    IManagedReference provisioningAuditRecordRef = wsmanClient.NewReference("IPS_ProvisioningAuditRecord");
                    IWsmanEnumeration provisioningAuditRecordCollection = provisioningAuditRecordRef.Enumerate("http://schemas.dmtf.org/wbem/wsman/1/wsman/SelectorFilter", null);
                    if (provisioningAuditRecordCollection == null)
                    {
                        Console.WriteLine("No Audit Provisioning Record was found");
                        return;
                    }
                    foreach (IWsmanItem provisioningAuditRecordItem in provisioningAuditRecordCollection)
                    {
                        provisioningAuditRecordInstance = provisioningAuditRecordItem.Object;
                    }
                }
                catch (Exception e)
                {
                    Console.WriteLine("Error occurred in GetAuditProvisionRecord. ");
                    if (e.Message == "No instance found.")
                        throw new Exception("Audit Provisioning Record is not supported");
                    throw e;
                }

                if (provisioningAuditRecordInstance != null)
                    if (provisioningAuditRecordInstance.SimpleName == "IPS_TLSProvisioningRecord")
                    {
                        Console.WriteLine("The provisioning type: TLS");
                        IWsmanItem provisioningItem = provisioningAuditRecordInstance.GetProperty("ProvisioningTLSMode");
                        Console.WriteLine("Provisioning TLS mode:{0}", provisioningItem.ToString());

                        provisioningItem = provisioningAuditRecordInstance.GetProperty("SecureDNS");
                        Console.WriteLine("Secure DNS:{0}", provisioningItem.ToString());

                        provisioningItem = provisioningAuditRecordInstance.GetProperty("HostInitiated");
                        Console.WriteLine("Host Initiated:{0}", provisioningItem.ToString());

                        provisioningItem = provisioningAuditRecordInstance.GetProperty("ProvServerFQDN");
                        Console.WriteLine("Provisioning Server FQDN:{0}", provisioningItem.ToString());

                        provisioningItem = provisioningAuditRecordInstance.GetProperty("SelectedHashData");
                        Console.WriteLine("Selected Hash Data:{0}", provisioningItem.ToString());

                        provisioningItem = provisioningAuditRecordInstance.GetProperty("SelectedHashType");
                        Console.WriteLine("Selected Hash Type:{0}", provisioningItem.ToString());

                        provisioningItem = provisioningAuditRecordInstance.GetProperty("AdditionalCaSerialNums");
                        Console.WriteLine("Additional CA Serial Numbers:{0}", provisioningItem.ToString());

                        provisioningItem = provisioningAuditRecordInstance.GetProperty("HashIsOemDefault");
                        Console.WriteLine("Hash is OEM Default:{0}", provisioningItem.ToString());

                        provisioningItem = provisioningAuditRecordInstance.GetProperty("IsTimeValid");
                        Console.WriteLine("Is Time Valid:{0}", provisioningItem.ToString());

                        provisioningItem = provisioningAuditRecordInstance.GetProperty("ProvServerIP");
                        Console.WriteLine("Provisioning Server IP:{0}", provisioningItem.ToString());

                    }
                    else if (provisioningAuditRecordInstance.SimpleName == "IPS_ManualProvisioningRecord")
                        Console.WriteLine("The provisioning type: Manual");
                    else if (provisioningAuditRecordInstance.SimpleName == "IPS_ClientProvisioningRecord")
                        Console.WriteLine("The provisioning type: Client");
                    else
                        Console.WriteLine("The provisioning type: Unknown");
            }
        }

        /// <summary>
        /// Getting code versions.
        /// </summary>
        public void GetCodeVersions()
        {
            Console.WriteLine("---------------Get Code Versions--------------");

            // Get BIOS version.
            // Traversing the CIM_BIOSElement instances using the managed host as a reference.
            IManagedReference biosElementRef = wsmanClient.NewReference("SELECT * FROM  CIM_BIOSElement WHERE Name='Primary BIOS'");
            IManagedInstance biosElementInstance = biosElementRef.Get();

            IWsmanItem version = biosElementInstance.GetProperty("Version");
            IWsmanItem elementName = biosElementInstance.GetProperty("ElementName");

            Console.WriteLine("Bios Version: {0}", version.ToString());
            Console.WriteLine("Element Name: {0}", elementName.ToString());
            foreach (string instID in InstanceID)
            {
                // Traversing the CIM_SoftwareIdentity instance representing the FW Core Version, using the managed host as a reference.
                IManagedReference softwareIdentityRef = wsmanClient.NewReference("SELECT * FROM  CIM_SoftwareIdentity WHERE InstanceID='" + instID + "'");
                // Other InstanceID can be specified to display more details, such as Vendor ID.

                IManagedInstance softwareIdentityInstance = softwareIdentityRef.Get();
                IWsmanItem versionString = softwareIdentityInstance.GetProperty("VersionString");

                int version1 = Convert.ToInt32(versionString.Count);

                Console.WriteLine("{0}: {1} ", instID, versionString);
                if (version1 > 0)
                {
                    if (instID.CompareTo(SKU_STRING) == 0)
                    {
                        int version2 = -1;
                        version2 = Convert.ToInt32(versionString.ToString());
                        if (version2 != -1)
                        {
                            bool firstOccurance = true;
                            for (uint i = 0; i < AMT_HIGHER_2_SKU_VERSION_VALUES.Length; i++)
                            {
                                if ((version2 & AMT_HIGHER_2_SKU_VERSION_VALUES[i]) != 0)
                                {
                                    if (AMT_HIGHER_2_SKU_VERSION_STRINGS[i].CompareTo(RESERVED_STRING) != 0)
                                    {
                                        if (firstOccurance)
                                        {
                                            Console.Write("   ({0}", AMT_HIGHER_2_SKU_VERSION_STRINGS[i]);
                                            firstOccurance = false;
                                        }
                                        else
                                            Console.Write(",\n    {0}", AMT_HIGHER_2_SKU_VERSION_STRINGS[i]);
                                    }
                                }
                            }
                            if (!firstOccurance)
                                Console.WriteLine(")");
                        }
                    }
                }
                //end version
            }
        }

        /// <summary>
        /// Getting the provisioning mode.
        /// </summary>
        public void GetProvisioningMode()
        {
            Console.WriteLine("---------------Get Provisioning Mode--------------");

            // Getting the AMT_SetupAndConfigurationService instance.
            IManagedReference setupAndConfigurationServiceRef = wsmanClient.NewReference("SELECT * FROM AMT_SetupAndConfigurationService WHERE Name='Intel(r) AMT Setup and Configuration Service'");
            IManagedInstance setupAndConfigurationServiceInstance = setupAndConfigurationServiceRef.Get();
            IWsmanItem provisioningMode = setupAndConfigurationServiceInstance.GetProperty("ProvisioningMode");

            Console.Write("Provisioning Mode: ");
            switch (Convert.ToInt16(provisioningMode.ToString()))
            {
                case (byte)ProvisioningModeTypes.ProvisioningModeCurrent:
                    Console.WriteLine("Current provisioning mode based on the Flash image settings\n");
                    break;
                case (byte)ProvisioningModeTypes.ProvisioningModeEnterprise:
                    Console.WriteLine("Enterprise provisioning mode\n");
                    break;
                case (byte)ProvisioningModeTypes.ProvisioningModeSmallBusiness:
                    Console.WriteLine("Small business provisioning mode\n");
                    break;
                case (byte)ProvisioningModeTypes.ProvisioningModeRemoteConnectivity:
                    Console.WriteLine("Remote connectivity provisioning mode\n");
                    break;

                default:
                    Console.WriteLine("Unknown.\n");
                    break;
            }
        }

        /// <summary>
        /// Getting the provisioning state.
        /// </summary>
        public void GetProvisioningState()
        {
            Console.WriteLine("---------------Get Provisioning State--------------");

            // Getting the AMT_SetupAndConfigurationService instance.
            IManagedReference setupAndConfigurationServiceRef = wsmanClient.NewReference("SELECT * FROM AMT_SetupAndConfigurationService WHERE Name='Intel(r) AMT Setup and Configuration Service'");
            IManagedInstance setupAndConfigurationServiceInstance = setupAndConfigurationServiceRef.Get();
            IWsmanItem provisioningState = setupAndConfigurationServiceInstance.GetProperty("ProvisioningState");

            Console.Write("Provisioning State: ");
            switch (Convert.ToInt16(provisioningState.ToString()))
            {
                case (byte)ProvisioningStateTypes.ProvisioningStatePre:
                    Console.WriteLine("Pre Provisioning state\n");
                    break;
                case (byte)ProvisioningStateTypes.ProvisioningStatePost:
                    Console.WriteLine("Post Provisioning state\n");
                    break;
                case (byte)ProvisioningStateTypes.ProvisioningStateIn:
                    Console.WriteLine("In Provisioning state\n");
                    break;
                default:
                    Console.WriteLine("Unknown.\n");
                    break;
            }
        }

        /// <summary>
        /// Getting the password model.
        /// </summary>
        public void GetPasswordModel()
        {
            Console.WriteLine("---------------Get Password Model--------------");

            // Getting the AMT_SetupAndConfigurationService instance.
            IManagedReference setupAndConfigurationServiceRef = wsmanClient.NewReference("SELECT * FROM AMT_SetupAndConfigurationService WHERE Name='Intel(r) AMT Setup and Configuration Service'");
            IManagedInstance setupAndConfigurationServiceInstance = setupAndConfigurationServiceRef.Get();
            IWsmanItem passwordModel = setupAndConfigurationServiceInstance.GetProperty("PasswordModel");

            Console.Write("Password Model: ");
            switch (Convert.ToInt16(passwordModel.ToString()))
            {
                case (byte)PasswordModelStateTypes.PasswordModelCoupled:
                    Console.WriteLine("PasswordModelCoupled\n");
                    break;
                case (byte)PasswordModelStateTypes.PasswordModelSeparate:
                    Console.WriteLine("PasswordModelSeparate\n");
                    break;
                case (byte)PasswordModelStateTypes.PasswordModelSeparateHash:
                    Console.WriteLine("PasswordModelSeparateHash\n");
                    break;
                default:
                    Console.WriteLine("unknown.\n");
                    break;
            }
        }

        /// <summary>
        /// Getting the configuration server's information.
        /// </summary>
        public void GetConfigServerInfo()
        {
            Console.WriteLine("---------------Get Config Server Info--------------");

            // Getting the AMT_SetupAndConfigurationService instance. 
            IManagedReference remotePortRef = wsmanClient.NewReference("SELECT * FROM  CIM_RemotePort WHERE Name='Intel(r) AMT Remote Port'");

            // Retrieve the instance of CIM_RemotePort.
            IManagedInstance remotePortInstance = remotePortRef.Get();

            //Examine the infoFormat and accessInfo to see configuration server host name and IP Address.
            IWsmanItem infoFormat = remotePortInstance.GetProperty("InfoFormat");
            IWsmanItem accessInfo = remotePortInstance.GetProperty("AccessInfo");

            //Examine portInfo for details of the port - the server listens, too.
            IWsmanItem portInfo = remotePortInstance.GetProperty("PortInfo");

            if ((Convert.ToUInt16(infoFormat.ToString())) == HOST_NAME)
                Console.WriteLine("Host Name: {0}", accessInfo.ToString());
            else
                Console.WriteLine("Ip Address: {0}", accessInfo.ToString());
            Console.WriteLine("Port: {0}\n", portInfo.ToString());
        }

        /// <summary>
        /// Getting the core version.
        /// </summary>
        public void GetCoreVersion(ref string coreVersion)
        {
            Console.WriteLine("--------------Getting the Core version-------------");
            IManagedReference softwareIdentityRef = wsmanClient.NewReference("SELECT * FROM CIM_SoftwareIdentity WHERE  InstanceID='AMT FW Core Version'");

            IManagedInstance softwareIdenetityInstance = softwareIdentityRef.Get();
            IWsmanItem versionString = softwareIdenetityInstance.GetProperty("VersionString");

            Console.WriteLine("Intel(R) AMT FW Core Version:{0}\n", versionString.ToString());

            coreVersion = versionString.ToString();
        }

        /// <summary>
        /// Getting the core version.
        /// </summary>
        public void GetCoreVersion()
        {
            Console.WriteLine(" ----------- Get Core version ------------");
            IManagedReference softwareIdentityRef = wsmanClient.NewReference("SELECT * FROM CIM_SoftwareIdentity WHERE  InstanceID='AMT FW Core Version'");

            IManagedInstance softwareIdenetityInstance = softwareIdentityRef.Get();
            IWsmanItem versionString = softwareIdenetityInstance.GetProperty("VersionString");

            Console.WriteLine("Intel(R) AMT FW Core Version:{0}\n", versionString.ToString());
        }

        /// <summary>
        /// Getting the enabled interfaces.
        /// </summary>
        public void GetEnabledInterfaces()
        {
            Console.WriteLine("---------------Get Enabled Interfaces--------------");
            Console.WriteLine("Enabled interfaces: ");

            IManagedReference webUIServiceRef = wsmanClient.NewReference("SELECT * FROM AMT_WebUIService WHERE Name='Intel(r) AMT Web Browser UI Service'");
            // Getting the AMT_WebUIService instance.
            IManagedInstance webUIServiceInstance = webUIServiceRef.Get();
            IWsmanItem enabledState = webUIServiceInstance.GetProperty("EnabledState");

            Console.WriteLine("\tWebUI: {0}", (Convert.ToUInt16(enabledState.ToString()) == ENABLED) ? "\tEnabled" : "\tDisabled");

            IManagedReference redirectionServiceRef = wsmanClient.NewReference("SELECT * FROM AMT_RedirectionService WHERE Name='Intel(r) AMT Redirection Service'");
            // Getting the AMT_RedirectionService instance.
            IManagedInstance redirectionServiceInstance = redirectionServiceRef.Get();
            enabledState = redirectionServiceInstance.GetProperty("EnabledState");

            switch (Convert.ToUInt16(enabledState.ToString()))
            {
                case (int)RedirectionServiceStates.NONE:
                    Console.WriteLine("\tIDER: \tDisabled");
                    Console.WriteLine("\tSOL: \tDisabled");
                    break;
                case (int)RedirectionServiceStates.IDER:
                    Console.WriteLine("\tIDER: \tEnabled");
                    Console.WriteLine("\tSOL: \tDisabled");
                    break;
                case (int)RedirectionServiceStates.SOL:
                    Console.WriteLine("\tIDER: \tDisabled");
                    Console.WriteLine("\tSOL: \tEnabled");
                    break;
                case (int)RedirectionServiceStates.IDER_SOL:
                    Console.WriteLine("\tIDER: \tEnabled");
                    Console.WriteLine("\tSOL: \tEnabled");
                    break;
                default:
                    Console.WriteLine("\tUnknown state");
                    break;
            }

            string fwCoreVersion = "";
            GetCoreVersion(ref fwCoreVersion);

            if (UtilitiesMethods.CompareVersions(fwCoreVersion, FIRST_VERSION_SUPPORTING_KVM) >= 0)
            {
                // Traversing the AMT_RedirectionService instance using the managed system as EPR.
                /*CIM_RedirectionService KvmRedirectionService = (CIM_RedirectionService)AssociationTraversalTypedUtils.GetAssociated(wsmanClient,
                                                                AssociationTraversalTypedUtils.DiscoverManagedHost(wsmanClient),
                                                                typeof(CIM_RedirectionService), typeof(CIM_HostedService));
                */

                //Cross check if it gives the right results.
                IManagedReference kvmRedirectionSAPRef = wsmanClient.NewReference("SELECT * FROM CIM_KVMRedirectionSAP WHERE Name='KVM Redirection Service Access Point'");
                IManagedInstance kvmRedirectionSAPInstance = kvmRedirectionSAPRef.Get();
                IWsmanItem enabledState1 = kvmRedirectionSAPInstance.GetProperty("EnabledState");

                if (enabledState1.ToString().Length < KVM_ENABLED_STATE_STRINGS.Length)
                {
                    Console.WriteLine("\tKVM: \t{0}", KVM_ENABLED_STATE_STRINGS[Convert.ToInt16(enabledState1.ToString())]);
                }
            }
        }

        /// <summary>
        /// Getting the security parameters.
        /// This function is performed by default in the wired interface.
        /// </summary>
        /// <param name="isWireless">true- for performing the operation in  the wireless. else- false</param>
        public void GetSecurityParameters(bool isWireless)
        {
            string fwVersion = UtilitiesMethods.GetCoreVersion(wsmanClient);
            Console.WriteLine("---------------Get Security Parameters--------------");

            // Getting the AMT_SetupAndConfigurationService instance.
            IManagedReference setupAndConfiguration = wsmanClient.NewReference("SELECT * FROM AMT_SetupAndConfigurationService WHERE Name='Intel(r) AMT Setup and Configuration Service'");
            IManagedInstance setupAndConfigurationInstance = setupAndConfiguration.Get();

            Console.WriteLine("Enterprise mode: {0}", setupAndConfigurationInstance.GetProperty("ProvisioningMode").IsString.ToString());

            //Obtain the current provisioning state:
            IWsmanItem provisioningState = setupAndConfigurationInstance.GetProperty("ProvisioningState");

            Console.Write("Provisioning state: ");
            switch (Convert.ToInt16(provisioningState.ToString()))
            {
                case (byte)ProvisioningStateTypes.ProvisioningStatePre:
                    Console.WriteLine("Pre Provisioning state");
                    break;
                case (byte)ProvisioningStateTypes.ProvisioningStatePost:
                    Console.WriteLine("Post Provisioning state");
                    break;
                case (byte)ProvisioningStateTypes.ProvisioningStateIn:
                    Console.WriteLine("In Provisioning state");
                    break;
                default:
                    Console.WriteLine("unknown.");
                    break;
            }
            //Console.WriteLine(Convert.ToInt16(setupAndConfigurationInstance.GetProperty("ProvisioningMode").ToString()) == (byte)ProvisioningModeTypes.ProvisioningModeEnterprise);

            // Traversing the AMT_TLSProtocolEndpoint instances using the Intel AMT as a reference.
            IManagedReference tlsSettingDataRef = wsmanClient.NewReference("SELECT * FROM AMT_TLSSettingData WHERE InstanceID='Intel(r) AMT 802.3 TLS Settings'");
            IManagedInstance tlsSettingDataInstance = tlsSettingDataRef.Get();
            IWsmanItem enabledState = tlsSettingDataInstance.GetProperty("Enabled");

            Console.WriteLine("TLS Enabled: {0}", enabledState.ToString());

            // Traversing the AMT_CryptographicCapabilities instance using the Intel AMT as a reference.
            IManagedReference cryptographicCapabilitiesRef = wsmanClient.NewReference("SELECT * FROM  AMT_CryptographicCapabilities WHERE InstanceID='Intel(r) AMT: Cryptographic Capabilities 0'");
            IManagedInstance cryptographicCapabilitiesInstance = cryptographicCapabilitiesRef.Get();
            IWsmanItem hardwareAcceleration = cryptographicCapabilitiesInstance.GetProperty("HardwareAcceleration");

            Console.WriteLine("HW CryptoEnabled: {0}", hardwareAcceleration.IsString.ToString());

            //Console.WriteLine(CryptographicCapabilities.HardwareAcceleration == 1);

            // Traversing the AMT_GeneralSettings instance using Intel AMT as a reference.
            IManagedReference generalSettings = wsmanClient.NewReference("SELECT * FROM AMT_GeneralSettings WHERE InstanceID='Intel(r) AMT: General Settings'");
            IManagedInstance generalSettingsInstance = generalSettings.Get();

            //Check for the state of the Network Interface.
            enabledState = generalSettingsInstance.GetProperty("NetworkInterfaceEnabled");
            Console.WriteLine("Network Interface Enabled:{0}", enabledState.ToString());

            // Getting the AMT_RedirectionService instance.
            IManagedReference redirectionServiceRef = wsmanClient.NewReference("SELECT * FROM AMT_RedirectionService WHERE Name='Intel(r) AMT Redirection Service'");
            IManagedInstance redirectionServiceInstance = redirectionServiceRef.Get();

            //Check for the state of the IDER.
            enabledState = redirectionServiceInstance.GetProperty("EnabledState");
            Console.Write("IDER Enabled: ");
            bool isIder = ((int)RedirectionServiceStates.IDER == Convert.ToInt64(enabledState.ToString())) ||
                              ((int)RedirectionServiceStates.IDER_SOL == Convert.ToInt64(enabledState.ToString()));
            Console.WriteLine(isIder.ToString());
            // Removed this code because CIM_SoftwareInstallationService removed from 7.0 MOFs.
            //// Getting the CIM_SoftwareInstallationService instance
            //CIM_SoftwareInstallationService SoftwareInstallationService = (CIM_SoftwareInstallationService)GetServiceInstance(typeof(CIM_SoftwareInstallationService));

            //Console.Write("FW UpdateEnabled: ");
            //Console.WriteLine(SoftwareInstallationService.EnabledState == ENABLED);

            // Traversing the CIM_EthernetPort instance using Intel AMT as a reference
            IManagedReference ethernetPortSettingsRef = wsmanClient.NewReference("SELECT * FROM AMT_EthernetPortSettings WHERE InstanceID='Intel(r) AMT Ethernet Port Settings " + (isWireless ? "1'" : "0'"));
            // “InstanceID” is equal to either “Intel(r) AMT Ethernet Port Settings 0” (wired interface)
            //                              or “Intel(r) AMT Ethernet Port Settings 1” (wireless interface).

            if (UtilitiesMethods.CompareVersions(fwVersion, "9.5") >= 0 && !isWireless)
                Console.WriteLine(
                    "\nGetting Ethernet Port Settings information (wired) is not supported in FW versions greater than 9.5.\tTo use wireless please add the 'wireless' argument...");

            else if (UtilitiesMethods.CompareVersions(fwVersion, "9.5") < 0 || (UtilitiesMethods.CompareVersions(fwVersion, "9.5") >= 0 && isWireless)) // version that greater than 9.5 is not supported in a lan-less machine.
            {
                IManagedInstance ethernetPortSettingsInstance = ethernetPortSettingsRef.Get();
                IWsmanItem linkIsUp = ethernetPortSettingsInstance.GetProperty("LinkIsUp");
                IWsmanItem macAddress = ethernetPortSettingsInstance.GetProperty("MACAddress");
                IWsmanItem instanceID = ethernetPortSettingsInstance.GetProperty("InstanceID");

                Console.Write("{0} ({1}) - Link Is Up: ", instanceID.ToString(), macAddress.ToString());
                Console.WriteLine(linkIsUp.ToString());
            }
        }

        public void GetSecurityParameters()
        {
            GetSecurityParameters(false);
        }

        #endregion
    }
}