535 lines
22 KiB
C#
535 lines
22 KiB
C#
//----------------------------------------------------------------------------
|
|
//
|
|
// Copyright (c) Intel Corporation, 2003 - 2012 All Rights Reserved.
|
|
//
|
|
// File: AMT_RemoteAccessService.cs
|
|
//
|
|
// Contents: Represents the Remote Access Service in the Intel(R) AMT subsystem.
|
|
// This file was automatically generated from AMT_RemoteAccessService.mof
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Collections.ObjectModel;
|
|
using System.Text;
|
|
using System.Globalization;
|
|
using System.Xml.Serialization;
|
|
using System.IO;
|
|
using Intel.Manageability.WSManagement;
|
|
using Intel.Manageability.Cim.Untyped;
|
|
|
|
|
|
namespace Intel.Manageability.Cim.Typed
|
|
{
|
|
/// <summary>
|
|
///Represents the Remote Access Service in the Intel(R) AMT subsystem.
|
|
/// </summary>
|
|
[System.SerializableAttribute()]
|
|
[System.Xml.Serialization.XmlTypeAttribute(Namespace="http://intel.com/wbem/wscim/1/amt-schema/1/AMT_RemoteAccessService")]
|
|
[System.Xml.Serialization.XmlRootAttribute("AMT_RemoteAccessService", Namespace="http://intel.com/wbem/wscim/1/amt-schema/1/AMT_RemoteAccessService", IsNullable=false)]
|
|
public class AMT_RemoteAccessService : CIM_Service
|
|
{
|
|
/// <summary>
|
|
/// Default constructor.
|
|
/// </summary>
|
|
public AMT_RemoteAccessService() :base()
|
|
{
|
|
}
|
|
/// <summary>
|
|
/// Constructor that recieves an xml string for deserialization.
|
|
/// </summary>
|
|
/// <param name="xml">xml string to deserialize</param>
|
|
public AMT_RemoteAccessService(string xml): base((IWSManClient)null)
|
|
{
|
|
this.Deserialize(xml);
|
|
}
|
|
/// <summary>
|
|
/// Constructor which recieves a Ws-Management client object.
|
|
/// </summary>
|
|
/// <param name="client">Ws-Management client</param>
|
|
public AMT_RemoteAccessService(IWSManClient client): base(client)
|
|
{
|
|
}
|
|
/// <summary>
|
|
/// Remove IsRemoteTunnelConnected field.
|
|
/// Note: This method will succeed only if this field is optional in the concrete object.
|
|
/// </summary>
|
|
public virtual void RemoveIsRemoteTunnelConnected()
|
|
{
|
|
RemoveField("IsRemoteTunnelConnected");
|
|
}
|
|
|
|
/// <summary>
|
|
/// Is true if the field IsRemoteTunnelConnected exists in the current object,
|
|
/// otherwise is false.
|
|
/// </summary>
|
|
public virtual bool IsRemoteTunnelConnectedExist
|
|
{
|
|
get
|
|
{
|
|
return ContainsField("IsRemoteTunnelConnected");
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Optional, Reflects the connection status of the remote tunnel
|
|
/// </summary>
|
|
[CimField(false, false)]
|
|
public virtual bool IsRemoteTunnelConnected
|
|
{
|
|
get
|
|
{
|
|
return bool.Parse(this["IsRemoteTunnelConnected"][0]);
|
|
}
|
|
set
|
|
{
|
|
this.SetOrAddField("IsRemoteTunnelConnected",value.ToString(CultureInfo.InvariantCulture));
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Remove RemoteTunnelKeepAliveTimeout field.
|
|
/// Note: This method will succeed only if this field is optional in the concrete object.
|
|
/// </summary>
|
|
public virtual void RemoveRemoteTunnelKeepAliveTimeout()
|
|
{
|
|
RemoveField("RemoteTunnelKeepAliveTimeout");
|
|
}
|
|
|
|
/// <summary>
|
|
/// Is true if the field RemoteTunnelKeepAliveTimeout exists in the current object,
|
|
/// otherwise is false.
|
|
/// </summary>
|
|
public virtual bool RemoteTunnelKeepAliveTimeoutExist
|
|
{
|
|
get
|
|
{
|
|
return ContainsField("RemoteTunnelKeepAliveTimeout");
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Optional, Reflects the keep-alive timeout value of the remote tunnel (in seconds)
|
|
/// </summary>
|
|
[CimField(false, false)]
|
|
public virtual uint RemoteTunnelKeepAliveTimeout
|
|
{
|
|
get
|
|
{
|
|
return uint.Parse(this["RemoteTunnelKeepAliveTimeout"][0], CultureInfo.InvariantCulture);
|
|
}
|
|
set
|
|
{
|
|
this.SetOrAddField("RemoteTunnelKeepAliveTimeout",value.ToString(CultureInfo.InvariantCulture));
|
|
}
|
|
}
|
|
/// <summary>
|
|
///Adds a Management Presence Server to the Intel(R) AMT subsystem. Creates an AMT_ManagementPresenceRemoteSAP instance and an AMT_RemoteAccessCredentialContext association to a credential. This credential may be an existing AMT_PublicKeyCertificate instance (if the created MPS is configured to use mutual authentication). If the created MpServer is configured to use username password authentication, an AMT_MPSUsernamePassword instance is created and used as the associated credential.
|
|
/// </summary>
|
|
[System.SerializableAttribute()]
|
|
[System.Xml.Serialization.XmlTypeAttribute(AnonymousType=true)]
|
|
[System.Xml.Serialization.XmlRootAttribute(Namespace="http://intel.com/wbem/wscim/1/amt-schema/1/AMT_RemoteAccessService", IsNullable=false)]
|
|
private class AddMpServer_INPUT : CimParams
|
|
{
|
|
public AddMpServer_INPUT(string ns) : base(ns)
|
|
{
|
|
}
|
|
|
|
/// <summary>
|
|
/// Required, A string holding the IP address or FQDN of the server
|
|
/// </summary>
|
|
[CimField(false,true)]
|
|
public virtual string AccessInfo
|
|
{
|
|
set
|
|
{
|
|
this.SetOrAddField("AccessInfo",value);
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Required, An enumerated integer describing the format and interpretation of the AccessInfo property.
|
|
/// </summary>
|
|
[CimField(false,true)]
|
|
public virtual ushort InfoFormat
|
|
{
|
|
set
|
|
{
|
|
this.SetOrAddField("InfoFormat",value.ToString(CultureInfo.InvariantCulture));
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Required, The port to be used to establish a tunnel with the MPS.
|
|
/// </summary>
|
|
[CimField(false,true)]
|
|
public virtual ushort Port
|
|
{
|
|
set
|
|
{
|
|
this.SetOrAddField("Port",value.ToString(CultureInfo.InvariantCulture));
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Required, Authentication method to be used when the Intel(R) AMT subsystem opens a tunnel to the MpServer
|
|
/// </summary>
|
|
[CimField(false,true)]
|
|
public virtual uint AuthMethod
|
|
{
|
|
set
|
|
{
|
|
this.SetOrAddField("AuthMethod",value.ToString(CultureInfo.InvariantCulture));
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Optional, A reference to a certificate. Required if AuthMethod is set to mutual authentication
|
|
/// </summary>
|
|
[CimField(false,false)]
|
|
public virtual CimReference Certificate
|
|
{
|
|
set
|
|
{
|
|
this.SetOrAddField("Certificate",value.Serialize(false));
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Optional, A Username to be used for the connection with the MPS if Username-Pwd authentication is used. Limited to 64 alphanumeric characters
|
|
/// </summary>
|
|
[CimField(false,false)]
|
|
public virtual string Username
|
|
{
|
|
set
|
|
{
|
|
this.SetOrAddField("Username",value);
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Optional, A Password to be used for the connection with the MPS if Username-Pwd authentication is used. Limited to 64 characters
|
|
/// </summary>
|
|
[CimField(false,false)]
|
|
public virtual string Password
|
|
{
|
|
set
|
|
{
|
|
this.SetOrAddField("Password",value);
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Optional, A common name used when AccessInfo is an IP address.
|
|
/// </summary>
|
|
[CimField(false,false)]
|
|
public virtual string CN
|
|
{
|
|
set
|
|
{
|
|
this.SetOrAddField("CN",value);
|
|
}
|
|
}
|
|
}
|
|
/// <summary>
|
|
///Adds a Management Presence Server to the Intel(R) AMT subsystem. Creates an AMT_ManagementPresenceRemoteSAP instance and an AMT_RemoteAccessCredentialContext association to a credential. This credential may be an existing AMT_PublicKeyCertificate instance (if the created MPS is configured to use mutual authentication). If the created MpServer is configured to use username password authentication, an AMT_MPSUsernamePassword instance is created and used as the associated credential.
|
|
/// </summary>
|
|
[System.SerializableAttribute()]
|
|
[System.Xml.Serialization.XmlTypeAttribute(AnonymousType=true)]
|
|
[System.Xml.Serialization.XmlRootAttribute(Namespace="http://intel.com/wbem/wscim/1/amt-schema/1/AMT_RemoteAccessService", IsNullable=false)]
|
|
private class AddMpServer_OUTPUT : CimParams
|
|
{
|
|
public AddMpServer_OUTPUT() : base("")
|
|
{
|
|
}
|
|
|
|
/// <summary>
|
|
/// Optional, A reference to the created MPS if the operation succeeded.
|
|
/// </summary>
|
|
[CimField(false,false)]
|
|
public virtual CimReference MpServer
|
|
{
|
|
get
|
|
{
|
|
string innerXML = this.GetField("MpServer")[0];
|
|
CimReference epr = new CimReference("MpServer", "http://intel.com/wbem/wscim/1/amt-schema/1/AMT_RemoteAccessService", innerXML);
|
|
return epr;
|
|
}
|
|
}
|
|
}
|
|
/// <summary>
|
|
///Adds a Management Presence Server to the Intel(R) AMT subsystem. Creates an AMT_ManagementPresenceRemoteSAP instance and an AMT_RemoteAccessCredentialContext association to a credential. This credential may be an existing AMT_PublicKeyCertificate instance (if the created MPS is configured to use mutual authentication). If the created MpServer is configured to use username password authentication, an AMT_MPSUsernamePassword instance is created and used as the associated credential.
|
|
/// </summary>
|
|
/// <param name="inAccessInfo">Required, IN -A string holding the IP address or FQDN of the server</param>
|
|
/// <param name="inInfoFormat">Required, IN -An enumerated integer describing the format and interpretation of the AccessInfo property.</param>
|
|
/// <param name="inPort">Required, IN -The port to be used to establish a tunnel with the MPS.</param>
|
|
/// <param name="inAuthMethod">Required, IN -Authentication method to be used when the Intel(R) AMT subsystem opens a tunnel to the MpServer</param>
|
|
/// <param name="inCertificate">Optional, IN -A reference to a certificate. Required if AuthMethod is set to mutual authentication</param>
|
|
/// <param name="inUsername">Optional, IN -A Username to be used for the connection with the MPS if Username-Pwd authentication is used. Limited to 64 alphanumeric characters</param>
|
|
/// <param name="inPassword">Optional, IN -A Password to be used for the connection with the MPS if Username-Pwd authentication is used. Limited to 64 characters</param>
|
|
/// <param name="inCN">Optional, IN -A common name used when AccessInfo is an IP address.</param>
|
|
/// <param name="outMpServer">OUT - A reference to the created MPS if the operation succeeded.</param>
|
|
/// <returns>
|
|
/// Legal values:
|
|
/// PT_STATUS_SUCCESS : 0
|
|
/// PT_STATUS_INTERNAL_ERROR : 1
|
|
/// PT_STATUS_NOT_PERMITTTED : 16
|
|
/// PT_STATUS_MAX_LIMIT_REACHED : 23
|
|
/// PT_STATUS_INVALID_PARAMETER : 36
|
|
/// PT_STATUS_FLASH_WRITE_LIMIT_EXCEEDED : 38
|
|
/// </returns>
|
|
public virtual uint AddMpServer(string inAccessInfo,ushort? inInfoFormat,ushort? inPort,uint? inAuthMethod,CimReference inCertificate,string inUsername,string inPassword,string inCN,out CimReference outMpServer)
|
|
{
|
|
AddMpServer_INPUT input = new AddMpServer_INPUT(this.XmlNamespace);
|
|
if (inAccessInfo != null)
|
|
input.AccessInfo=inAccessInfo;
|
|
if (inInfoFormat.HasValue)
|
|
input.InfoFormat=inInfoFormat.Value;
|
|
if (inPort.HasValue)
|
|
input.Port=inPort.Value;
|
|
if (inAuthMethod.HasValue)
|
|
input.AuthMethod=inAuthMethod.Value;
|
|
if (inCertificate != null)
|
|
input.Certificate=inCertificate;
|
|
if (inUsername != null)
|
|
input.Username=inUsername;
|
|
if (inPassword != null)
|
|
input.Password=inPassword;
|
|
if (inCN != null)
|
|
input.CN=inCN;
|
|
AddMpServer_OUTPUT output = new AddMpServer_OUTPUT();
|
|
uint returnValue = base.Invoke("AddMpServer",input,out output);
|
|
outMpServer=null;
|
|
if (returnValue == 0)
|
|
{
|
|
if (output.ContainsField("MpServer"))
|
|
outMpServer = output.MpServer;
|
|
}
|
|
return returnValue;
|
|
}
|
|
/// <summary>
|
|
///Adds a Remote Access policy to the Intel(R) AMT subsystem. The policy defines an event that will trigger an establishment of a tunnel between AMT and a pre-configured MPS. Creates an AMT_RemoteAccessPolicyRule instance and associates it to a given list of AMT_ManagementPresenceRemoteSAP instances with AMT_PolicySetAppliesToElement association instances.
|
|
/// </summary>
|
|
[System.SerializableAttribute()]
|
|
[System.Xml.Serialization.XmlTypeAttribute(AnonymousType=true)]
|
|
[System.Xml.Serialization.XmlRootAttribute(Namespace="http://intel.com/wbem/wscim/1/amt-schema/1/AMT_RemoteAccessService", IsNullable=false)]
|
|
private class AddRemoteAccessPolicyRule_INPUT : CimParams
|
|
{
|
|
public AddRemoteAccessPolicyRule_INPUT(string ns) : base(ns)
|
|
{
|
|
}
|
|
|
|
/// <summary>
|
|
/// Required, The event that will trigger the establishment of the remote connection to the MpServer.
|
|
/// </summary>
|
|
[CimField(false,true)]
|
|
public virtual ushort Trigger
|
|
{
|
|
set
|
|
{
|
|
this.SetOrAddField("Trigger",value.ToString(CultureInfo.InvariantCulture));
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Required, Defines the tunnel's lifetime in seconds, 0 means no lifetime- the tunnel should stay open until it is closed by CloseRemoteAccessConnection or when a different policy with higher priority needs to be processed.
|
|
/// </summary>
|
|
[CimField(false,true)]
|
|
public virtual uint TunnelLifeTime
|
|
{
|
|
set
|
|
{
|
|
this.SetOrAddField("TunnelLifeTime",value.ToString(CultureInfo.InvariantCulture));
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Optional, Data associated with the policy, up to 32 bytes. The data should be in a network order. The extended data for a policy with a periodic trigger contains first a periodic type and after that the data for that type. For periodic type 0 [Interval - The CIRA connection will be established every fixed number of seconds] - the data should include a uint32 value that indicates the time period in seconds between tunnel establishments. For periodic type 1 [Daily - The CIRA connection will be established every day in a specific pre-defined time (hour and minutes)] - the data should include two uint32 values which define the wanted hour of the day and minutes of that hour. For the other triggers extended data is not defined and not needed. The length and data should be zero.
|
|
/// </summary>
|
|
[CimField(false,false)]
|
|
public virtual byte[] ExtendedData
|
|
{
|
|
set
|
|
{
|
|
this.SetOrAddField("ExtendedData",Convert.ToBase64String(value));
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Optional, A list of MPSs the policy applies to. Maximum length is 2 MPSs.
|
|
/// </summary>
|
|
[CimField(false,false)]
|
|
public virtual CimReference[] MpServer
|
|
{
|
|
set
|
|
{
|
|
string[] strArray = new string[value.Length];
|
|
for (int i = 0; i < value.Length; i++)
|
|
{
|
|
strArray.SetValue(value[i].Serialize(false), i);
|
|
}
|
|
this.SetOrAddField("MpServer",strArray);
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Optional, A list of Internal MPSs the policy applies to. Maximum length is 2 MPSs.
|
|
/// </summary>
|
|
[CimField(false,false)]
|
|
public virtual CimReference[] InternalMpServer
|
|
{
|
|
set
|
|
{
|
|
string[] strArray = new string[value.Length];
|
|
for (int i = 0; i < value.Length; i++)
|
|
{
|
|
strArray.SetValue(value[i].Serialize(false), i);
|
|
}
|
|
this.SetOrAddField("InternalMpServer",strArray);
|
|
}
|
|
}
|
|
}
|
|
/// <summary>
|
|
///Adds a Remote Access policy to the Intel(R) AMT subsystem. The policy defines an event that will trigger an establishment of a tunnel between AMT and a pre-configured MPS. Creates an AMT_RemoteAccessPolicyRule instance and associates it to a given list of AMT_ManagementPresenceRemoteSAP instances with AMT_PolicySetAppliesToElement association instances.
|
|
/// </summary>
|
|
[System.SerializableAttribute()]
|
|
[System.Xml.Serialization.XmlTypeAttribute(AnonymousType=true)]
|
|
[System.Xml.Serialization.XmlRootAttribute(Namespace="http://intel.com/wbem/wscim/1/amt-schema/1/AMT_RemoteAccessService", IsNullable=false)]
|
|
private class AddRemoteAccessPolicyRule_OUTPUT : CimParams
|
|
{
|
|
public AddRemoteAccessPolicyRule_OUTPUT() : base("")
|
|
{
|
|
}
|
|
|
|
/// <summary>
|
|
/// Optional, A reference to the created policy if the operation succeeded.
|
|
/// </summary>
|
|
[CimField(false,false)]
|
|
public virtual CimReference PolicyRule
|
|
{
|
|
get
|
|
{
|
|
string innerXML = this.GetField("PolicyRule")[0];
|
|
CimReference epr = new CimReference("PolicyRule", "http://intel.com/wbem/wscim/1/amt-schema/1/AMT_RemoteAccessService", innerXML);
|
|
return epr;
|
|
}
|
|
}
|
|
}
|
|
/// <summary>
|
|
///Adds a Remote Access policy to the Intel(R) AMT subsystem. The policy defines an event that will trigger an establishment of a tunnel between AMT and a pre-configured MPS. Creates an AMT_RemoteAccessPolicyRule instance and associates it to a given list of AMT_ManagementPresenceRemoteSAP instances with AMT_PolicySetAppliesToElement association instances.
|
|
/// </summary>
|
|
/// <param name="inTrigger">Required, IN -The event that will trigger the establishment of the remote connection to the MpServer.</param>
|
|
/// <param name="inTunnelLifeTime">Required, IN -Defines the tunnel's lifetime in seconds, 0 means no lifetime- the tunnel should stay open until it is closed by CloseRemoteAccessConnection or when a different policy with higher priority needs to be processed.</param>
|
|
/// <param name="inExtendedData">Optional, IN -Data associated with the policy, up to 32 bytes. The data should be in a network order. The extended data for a policy with a periodic trigger contains first a periodic type and after that the data for that type. For periodic type 0 [Interval - The CIRA connection will be established every fixed number of seconds] - the data should include a uint32 value that indicates the time period in seconds between tunnel establishments. For periodic type 1 [Daily - The CIRA connection will be established every day in a specific pre-defined time (hour and minutes)] - the data should include two uint32 values which define the wanted hour of the day and minutes of that hour. For the other triggers extended data is not defined and not needed. The length and data should be zero.</param>
|
|
/// <param name="inMpServer">Optional, IN -A list of MPSs the policy applies to. Maximum length is 2 MPSs.</param>
|
|
/// <param name="inInternalMpServer">Optional, IN -A list of Internal MPSs the policy applies to. Maximum length is 2 MPSs.</param>
|
|
/// <param name="outPolicyRule">OUT - A reference to the created policy if the operation succeeded.</param>
|
|
/// <returns>
|
|
/// Legal values:
|
|
/// PT_STATUS_SUCCESS : 0
|
|
/// PT_STATUS_INTERNAL_ERROR : 1
|
|
/// PT_STATUS_INVALID_PARAMETER : 36
|
|
/// PT_STATUS_FLASH_WRITE_LIMIT_EXCEEDED : 38
|
|
/// PT_STATUS_DUPLICATE : 2058
|
|
/// </returns>
|
|
public virtual uint AddRemoteAccessPolicyRule(ushort? inTrigger,uint? inTunnelLifeTime,byte[] inExtendedData,CimReference[] inMpServer,CimReference[] inInternalMpServer,out CimReference outPolicyRule)
|
|
{
|
|
AddRemoteAccessPolicyRule_INPUT input = new AddRemoteAccessPolicyRule_INPUT(this.XmlNamespace);
|
|
if (inTrigger.HasValue)
|
|
input.Trigger=inTrigger.Value;
|
|
if (inTunnelLifeTime.HasValue)
|
|
input.TunnelLifeTime=inTunnelLifeTime.Value;
|
|
if (inExtendedData != null)
|
|
input.ExtendedData=inExtendedData;
|
|
if (inMpServer != null)
|
|
input.MpServer=inMpServer;
|
|
if (inInternalMpServer != null)
|
|
input.InternalMpServer=inInternalMpServer;
|
|
AddRemoteAccessPolicyRule_OUTPUT output = new AddRemoteAccessPolicyRule_OUTPUT();
|
|
uint returnValue = base.Invoke("AddRemoteAccessPolicyRule",input,out output);
|
|
outPolicyRule=null;
|
|
if (returnValue == 0)
|
|
{
|
|
if (output.ContainsField("PolicyRule"))
|
|
outPolicyRule = output.PolicyRule;
|
|
}
|
|
return returnValue;
|
|
}
|
|
/// <summary>
|
|
///Closes a remote access connection if one is opened.
|
|
/// </summary>
|
|
[System.SerializableAttribute()]
|
|
[System.Xml.Serialization.XmlTypeAttribute(AnonymousType=true)]
|
|
[System.Xml.Serialization.XmlRootAttribute(Namespace="http://intel.com/wbem/wscim/1/amt-schema/1/AMT_RemoteAccessService", IsNullable=false)]
|
|
private class CloseRemoteAccessConnection_INPUT : CimParams
|
|
{
|
|
public CloseRemoteAccessConnection_INPUT(string ns) : base(ns)
|
|
{
|
|
}
|
|
|
|
}
|
|
/// <summary>
|
|
///Closes a remote access connection if one is opened.
|
|
/// </summary>
|
|
[System.SerializableAttribute()]
|
|
[System.Xml.Serialization.XmlTypeAttribute(AnonymousType=true)]
|
|
[System.Xml.Serialization.XmlRootAttribute(Namespace="http://intel.com/wbem/wscim/1/amt-schema/1/AMT_RemoteAccessService", IsNullable=false)]
|
|
private class CloseRemoteAccessConnection_OUTPUT : CimParams
|
|
{
|
|
public CloseRemoteAccessConnection_OUTPUT() : base("")
|
|
{
|
|
}
|
|
|
|
}
|
|
/// <summary>
|
|
///Closes a remote access connection if one is opened.
|
|
/// </summary>
|
|
/// <returns>
|
|
/// Legal values:
|
|
/// PT_STATUS_SUCCESS : 0
|
|
/// PT_STATUS_INVALID_COMMAND : 2051
|
|
/// </returns>
|
|
public virtual uint CloseRemoteAccessConnection()
|
|
{
|
|
CloseRemoteAccessConnection_INPUT input = new CloseRemoteAccessConnection_INPUT(this.XmlNamespace);
|
|
CloseRemoteAccessConnection_OUTPUT output = new CloseRemoteAccessConnection_OUTPUT();
|
|
uint returnValue = base.Invoke("CloseRemoteAccessConnection",input,out output);
|
|
return returnValue;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Enumerate instances of AMT_RemoteAccessService class at an endpoint.
|
|
/// </summary>
|
|
/// <param name="client">WS-Management client</param>
|
|
/// <param name="cimKeys">Keys for selecting the instances</param>
|
|
/// <returns>Collection of AMT_RemoteAccessService objects</returns>
|
|
public static new Collection<AMT_RemoteAccessService> Enumerate(IWSManClient client, CimBase.CimKeys cimKeys)
|
|
{
|
|
List<AMT_RemoteAccessService> ret = CimBase.Enumerate<AMT_RemoteAccessService>(client, cimKeys);
|
|
return new Collection<AMT_RemoteAccessService>(ret);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Enumerate instances of AMT_RemoteAccessService class at an endpoint.
|
|
/// </summary>
|
|
/// <param name="client">WS-Management client</param>
|
|
/// <returns>Collection of AMT_RemoteAccessService objects</returns>
|
|
public static new Collection<AMT_RemoteAccessService> Enumerate(IWSManClient client)
|
|
{
|
|
List<AMT_RemoteAccessService> ret = CimBase.Enumerate<AMT_RemoteAccessService>(client);
|
|
return new Collection<AMT_RemoteAccessService>(ret);
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Delete the instance of AMT_RemoteAccessService if it is singular.
|
|
/// Note: This method will succeed only if a single instance of the class exists.
|
|
/// </summary>
|
|
/// <param name="client">WS-Management client</param>
|
|
public static new void Delete(IWSManClient client)
|
|
{
|
|
CimBase.Delete<AMT_RemoteAccessService>(client);
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Represents the keys of the AMT_RemoteAccessService class.
|
|
/// </summary>
|
|
|
|
public new class CimKeys : CIM_Service.CimKeys
|
|
{
|
|
}
|
|
|
|
}
|
|
}
|
|
|