2839 lines
122 KiB
Plaintext
2839 lines
122 KiB
Plaintext
#pragma namespace ("\\\\.\\Root")
|
|
|
|
instance of __NameSpace
|
|
{
|
|
Name = "MicrosoftDNS" ;
|
|
} ;
|
|
|
|
#pragma namespace ( "\\\\.\\Root\\MicrosoftDNS" )
|
|
|
|
|
|
instance of __Win32Provider as $P
|
|
{
|
|
Name = "MS_NT_DNS_PROVIDER";
|
|
ClsId = "{62269fec-7b32-11d2-9ab7-0000f875c5d4}";
|
|
ImpersonationLevel = 3;
|
|
PerUserInitialization = "FALSE";
|
|
};
|
|
|
|
instance of __InstanceProviderRegistration
|
|
{
|
|
Provider = $P;
|
|
SupportsGet = "TRUE";
|
|
SupportsPut = "TRUE";
|
|
SupportsDelete = "TRUE";
|
|
SupportsEnumeration = "TRUE";
|
|
QuerySupportLevels = {"WQL:UnarySelect"};
|
|
};
|
|
|
|
instance of __MethodProviderRegistration
|
|
{
|
|
Provider = $P;
|
|
};
|
|
|
|
|
|
[Abstract, Description (
|
|
"The ManagedSystemElement class is the base class for the system element "
|
|
"hierarchy. Membership Criteria: Any distinguishable component of a "
|
|
"system is a candidate for inclusion in this class.<P>Examples: Software "
|
|
"components, such as files; and devices, such as disk drives and "
|
|
"controllers, and physical components such as chips and cards."):
|
|
ToSubClass,
|
|
Locale (0x409), UUID ("{8502C517-5FBB-11D2-AAC1-006008C78BC7}") ]
|
|
class CIM_ManagedSystemElement
|
|
{
|
|
[MaxLen (64): ToSubClass , Description (
|
|
"The Caption property is a short textual description (one-line string) "
|
|
"of the object."): ToSubClass , Read: ToSubClass]
|
|
string Caption ;
|
|
[Description (
|
|
"The Description property provides a textual description of the "
|
|
"object. "): ToSubClass , Read: ToSubClass]
|
|
string Description ;
|
|
[Description (
|
|
"A datetime value indicating when the object was installed. A lack of a "
|
|
"value does not indicate that the object is not installed."): ToSubClass ,
|
|
MappingStrings {"MIF.DMTF|ComponentID|001.5"}: ToSubClass , Read: ToSubClass]
|
|
datetime InstallDate ;
|
|
[Description (
|
|
"The Name property defines the label by which the object is known. When "
|
|
"subclassed, the Name property can be overridden to be a Key property."):
|
|
ToSubClass , Read: ToSubClass]
|
|
string Name ;
|
|
[Description ("A string indicating the current status of the object."):
|
|
ToSubClass, ValueMap {"OK", "Error", "Degraded", "Unknown"}: ToSubClass ,
|
|
Read: ToSubClass]
|
|
string Status ;
|
|
};
|
|
|
|
[Abstract, Description (
|
|
"The CIM_LogicalElement class is the base class for all the components "
|
|
"of the system that represent abstract system components.<P>Example: "
|
|
"Profiles, processes, or system capabilities in the form of logical "
|
|
"devices."): ToSubClass,
|
|
Locale (0x409), UUID ("{8502C518-5FBB-11D2-AAC1-006008C78BC7}") ]
|
|
class CIM_LogicalElement:CIM_ManagedSystemElement
|
|
{
|
|
};
|
|
|
|
[Abstract, Description (
|
|
"A logical element that contains the information necessary to represent "
|
|
"and manage the functionality provided by a Device and/or "
|
|
"SoftwareFeature. A Service is a general-purpose object to configure and "
|
|
"manage the implementation of functionality. It is not the functionality "
|
|
"itself."): ToSubClass,
|
|
Locale (0x409), UUID ("{8502C527-5FBB-11D2-AAC1-006008C78BC7}") ]
|
|
class CIM_Service:CIM_LogicalElement
|
|
{
|
|
[CIM_Key, Read: ToSubClass]
|
|
string CreationClassName ;
|
|
[Override ("Name"): ToSubClass , Key, Description (
|
|
"The Name property uniquely identifies the Service and provides an "
|
|
"indication of the functionality that is managed. This functionality is "
|
|
"described in more detail in the object's Description property. "):
|
|
ToSubClass , Read: ToSubClass]
|
|
string Name ;
|
|
[Description (
|
|
"StartMode is a string value indicating whether the Service is "
|
|
"automatically started by a System, Operating System, etc. or only "
|
|
"started upon request."): ToSubClass ,
|
|
ValueMap {"Automatic", "Manual"}: ToSubClass ,
|
|
Read: ToSubClass]
|
|
string StartMode ;
|
|
[Description (
|
|
"ServiceStarted is a boolean indicating whether the Service has been "
|
|
"started (TRUE), or stopped (FALSE)."): ToSubClass , Read: ToSubClass]
|
|
boolean Started ;
|
|
[Propagated ("CIM_System.CreationClassName"): ToSubClass, CIM_Key,
|
|
Description ("The type name of the system that hosts this service"):
|
|
ToSubClass , Read: ToSubClass]
|
|
string SystemCreationClassName ;
|
|
[Propagated ("CIM_System.Name"): ToSubClass, CIM_Key, Description (
|
|
"The name of the system that hosts this service"): ToSubClass , Read: ToSubClass]
|
|
string SystemName ;
|
|
[Description (
|
|
"The StartService method places the Service in the started state. It "
|
|
"returns an integer value of 0 if the Service was successfully started, "
|
|
"1 if the request is not supported and any other number to indicate an "
|
|
"error."): ToSubClass ]
|
|
uint32 StartService() ;
|
|
[Description (
|
|
"The StopService method places the Service in the stopped state. It "
|
|
"returns an integer value of 0 if the Service was successfully stopped, "
|
|
"1 if the request is not supported and any other number to indicate an "
|
|
"error."): ToSubClass ]
|
|
uint32 StopService() ;
|
|
};
|
|
|
|
[
|
|
Schema ("MicrosoftDNS"): ToSubClass ,
|
|
Description("This class describes a DNS server. Every instance "
|
|
"of this class may be associated with (or more intuitively 'may "
|
|
"contain') one instance of class MicrosoftDNS_Cache, one instance "
|
|
"of class MicrosoftDNS_RootHints and multiple instances of class "
|
|
"MicrosoftDNS_Zone."): ToSubClass ,
|
|
Dynamic, Provider("MS_NT_DNS_PROVIDER"),
|
|
Locale (0x409), UUID ("{3E9F9B09-AA43-11d2-85DD-0000F8102E5F}")
|
|
]
|
|
class MicrosoftDNS_Server : CIM_Service
|
|
{
|
|
[Override ("Name"): ToSubClass,
|
|
Read: ToSubClass,
|
|
Description("Indicates the Fully Qualified Domain Name or IP "
|
|
"address of the DNS server."): ToSubClass
|
|
]
|
|
string Name;
|
|
|
|
[Read: ToSubClass,
|
|
Description("Indicates the version of the DNS server."):
|
|
ToSubClass
|
|
]
|
|
uint32 Version;
|
|
|
|
[Read: ToSubClass, Write: ToSubClass,
|
|
Description("This property controls what packets and events "
|
|
"are written to the DNS server's debug log. This property "
|
|
"should be set to "
|
|
"specific values based on the following algorithm: "
|
|
"Each policy "
|
|
"is assigned a specific value: Query - 1, Notify - 16, "
|
|
"Update - 32, Non-query transactions - 254, Questions - 256, "
|
|
"Answers - 512, Send - 4096, Receive - 8192, UDP - 16384, "
|
|
"TCP - 32768, All packets - 65535, "
|
|
"Directory Service write transaction - 65536, "
|
|
"Directory Service update transaction - 131072, "
|
|
"Full Packets - 16777216, and Write Through - 2147483648. The "
|
|
"sum of the values corresponding to all the policies to be "
|
|
"activated is indicated in this property."): ToSubClass,
|
|
Valuemap{"1", "16", "32", "254", "256", "512", "4096", "8192", "16384",
|
|
"32768", "65535", "65536", "131072", "16777216", "2147483648"}:ToSubClass,
|
|
Values{"Query", "Notify", "Update", "Non-query transactions", "Questions",
|
|
"Answers", "Send", "Receive", "UDP", "TCP", "All packets",
|
|
"NT Directory Service write transaction",
|
|
"NT Directory Service update transaction",
|
|
"Full Packets", "Write Through"}:ToSubClass
|
|
]
|
|
uint32 LogLevel;
|
|
|
|
[
|
|
Read: ToSubClass, Write: ToSubClass,
|
|
Description( "The file name for the DNS server's debug log. By "
|
|
"the file is system32\\dns\\dns.log. You may change this value. "
|
|
"A relative path path is relative to SystemRoot\\System32. "
|
|
"You may also use absolute paths, but UNC paths are not "
|
|
"supported." ) : ToSubClass
|
|
]
|
|
string LogFilePath;
|
|
|
|
[
|
|
Read: ToSubClass, Write: ToSubClass,
|
|
Description( "The size in bytes of the DNS server's debug log." ) :
|
|
ToSubClass
|
|
]
|
|
uint32 LogFileMaxSize;
|
|
|
|
[
|
|
Read: ToSubClass, Write: ToSubClass,
|
|
Description( "List of IP addresses used to filter DNS events written "
|
|
" to DNS server's debug log." ) : ToSubClass
|
|
]
|
|
string LogIPFilterList[];
|
|
|
|
[Read: ToSubClass, Write: ToSubClass,
|
|
Description("Indicates which events the DNS server records "
|
|
"in the Event Viewer system log."): ToSubClass ,
|
|
Valuemap {"0", "1", "2", "4"}: ToSubClass ,
|
|
Values {"None", "Log only errors", "Log only warnings and errors",
|
|
"Log all events"}: ToSubClass
|
|
]
|
|
uint32 EventLogLevel;
|
|
|
|
[Read: ToSubClass, Write: ToSubClass,
|
|
Description("Indicates the protocols over which "
|
|
"administrative RPC runs. This property should be set to specific "
|
|
"value based on the following algorithm: Every protocol to be used "
|
|
"in RPC is assigned a specific value: None: 0, TCP/IP: 1, Named "
|
|
"Pipes: 2, LPC: 4. The sum of the values corresponding to all "
|
|
"the protocols to be used in RPC is indicated in this property.")
|
|
: ToSubClass
|
|
]
|
|
sint32 RpcProtocol;
|
|
[Read: ToSubClass, Write: ToSubClass,
|
|
Description("Indicates the set of eligible characters "
|
|
"to be used in DNS names."): ToSubClass ,
|
|
Valuemap {"0", "1", "2", "3"}: ToSubClass ,
|
|
Values {"Strict RFC (ANSI)", "Non RFC (ANSI)",
|
|
"Multibyte (UTF8)", "Any"}: ToSubClass
|
|
]
|
|
uint32 NameCheckFlag;
|
|
[Not_NULL, Read: ToSubClass, Write: ToSubClass,
|
|
Description("Indicates the maximum number of host records "
|
|
"returned in response to an address request. Values between "
|
|
"5 and 28 are valid."): ToSubClass
|
|
]
|
|
uint32 AddressAnswerLimit;
|
|
[Read: ToSubClass, Write: ToSubClass,
|
|
Description("Indicates the interval (in seconds) before "
|
|
"retrying a recursive lookup. If the RecursionRetry property "
|
|
"is undefined or zero, retries are made after three "
|
|
"seconds. Users are discouraged from altering this property. "
|
|
"However, there are some scenarios where the property "
|
|
"should be changed. One example is when the "
|
|
"DNS server contacts remote servers over a slow link, and "
|
|
"the DNS server is retrying BEFORE reception "
|
|
"of a response from the remote DNS. In this case, raising "
|
|
"the RecursionRetry timeout to be slightly longer than the "
|
|
"observed response time from the remote DNS would be "
|
|
"reasonable."): ToSubClass ,
|
|
Units("Seconds"): ToSubClass
|
|
]
|
|
uint32 RecursionRetry;
|
|
[Read: ToSubClass, Write: ToSubClass,
|
|
Description("Indicates the timeout (in seconds) before the "
|
|
"DNS server gives up recursive query. If the Recursion"
|
|
"Timeout property is undefined or zero, the DNS "
|
|
"server gives up after fifteen seconds. In general, the "
|
|
"fifteen-second timeout is sufficient to allow any "
|
|
"outstanding response to get back to the DNS server. Users "
|
|
"are discouraged from altering this property. One scenario "
|
|
"where the property should be changed is when the DNS server "
|
|
"contacts remote servers over a slow link, and the DNS server "
|
|
"is observed rejecting queries (with SERVER_FAILURE) before "
|
|
"responses are received. (Note, that client resolvers also "
|
|
"retry queries, so careful investigation is required to determine "
|
|
"that remote responses are really for the query that was timed "
|
|
"out.) In this case, raising the RecursionTimeout to be "
|
|
"slightly longer than the observed response time from the "
|
|
"remote DNS would be reasonable."): ToSubClass ,
|
|
Units("Seconds"): ToSubClass
|
|
]
|
|
uint32 RecursionTimeout;
|
|
|
|
[Read: ToSubClass, Write: ToSubClass,
|
|
Description("Indicates the interval (in seconds) to poll "
|
|
"for changes in DS-integrated zones."): ToSubClass ,
|
|
Units("Seconds"): ToSubClass
|
|
]
|
|
uint32 DsPollingInterval;
|
|
|
|
[Read: ToSubClass, Write: ToSubClass,
|
|
Description("The lifetime (in seconds) of tombstoned "
|
|
"records in DS-integrated zones."): ToSubClass ,
|
|
Units("Seconds"): ToSubClass
|
|
]
|
|
uint32 DsTombstoneInterval;
|
|
|
|
[Read: ToSubClass, Write: ToSubClass,
|
|
Description("Indicates a maximum time (in seconds) a record from "
|
|
"a recursive name query may remain in the DNS server cache. "
|
|
"The DNS server deletes records from the cache when the value "
|
|
"of this entry expires, even if the value of the TTL field in "
|
|
"the record is greater. The default value of this property is "
|
|
"86,400 seconds (1 day)."): ToSubClass ,
|
|
Units("Seconds"): ToSubClass
|
|
]
|
|
uint32 MaxCacheTTL;
|
|
|
|
[Read: ToSubClass, Write: ToSubClass,
|
|
Description("Indicates a maximum time (in seconds) a name error "
|
|
"result from a recursive name query may remain in the "
|
|
"DNS server cache. The DNS server deletes records from "
|
|
"the cache when the value of this entry expires, even if "
|
|
"the value of the TTL field in the record is greater. The "
|
|
"default value of this property is 86,400 seconds "
|
|
"(1 day)."): ToSubClass ,
|
|
Units("Seconds"): ToSubClass
|
|
]
|
|
uint32 MaxNegativeCacheTTL;
|
|
|
|
[Read: ToSubClass, Write: ToSubClass,
|
|
Description("Indicates the port on which the DNS server "
|
|
"sends UDP queries to other servers. By default, the DNS "
|
|
"server sends queries on a socket bound to the "
|
|
"DNS port. Sometimes this situation is NOT desirable. The "
|
|
"most obvious case occurs when an admin firewalls off "
|
|
"the DNS port, to prevent outside access to the DNS server, "
|
|
"but still wants the server to be able to contact "
|
|
"Internet DNS servers to provide name resolution "
|
|
"for internal clients. This is also desirable if the DNS "
|
|
"server is supporting disjoint nets (if true, the "
|
|
"boolean property, DisjointNets, would be set to TRUE). "
|
|
"In these cases, setting the SendPort property to "
|
|
"a non-zero value causes the DNS server to bind to an "
|
|
"arbitrary port for sending to remote DNS servers." ): ToSubClass
|
|
]
|
|
uint32 SendPort;
|
|
|
|
[Read: ToSubClass, Write: ToSubClass,
|
|
Description( "Timeout in seconds the DNS server will wait for a "
|
|
"successful TCP connection to a remote server when attempting "
|
|
"a zone transfer." ): ToSubClass
|
|
]
|
|
uint32 XfrConnectTimeout;
|
|
|
|
[Read: ToSubClass, Write: ToSubClass,
|
|
Description("Indicates the DNS server's initialization method."):
|
|
ToSubClass ,
|
|
Values {"Uninitialized", "Boot from file", "Boot from registry",
|
|
"Boot from directory and registry"}: ToSubClass
|
|
]
|
|
uint32 BootMethod;
|
|
[Read: ToSubClass, Write: ToSubClass,
|
|
Description("This UInt32 indicates whether the DNS server "
|
|
"accepts dynamic update requests."): ToSubClass,
|
|
Values {"Do not allow dynamic updates", "Allow unsecure dynamic updates",
|
|
"Allow only secure dynamic updates"}: ToSubClass
|
|
]
|
|
uint32 AllowUpdate;
|
|
|
|
[Read: ToSubClass, Write: ToSubClass,
|
|
Description("This value restricts the type of records "
|
|
"that can be dynamically updated on the server. This parameter "
|
|
"is a further restriction on dynamic updates applied after the "
|
|
"AllowUpdate setting on Server and Zone objects. "
|
|
"Use these values: \"No restrictions\" = 0, \"Do not allow dynamic "
|
|
"updates of SOA records\" = 1, \"Do not allow dynamic updates of NS "
|
|
"records at the zone root\" = 2, \"Do not allow dynamic updates of "
|
|
"NS records not at the zone root (delegation NS records)\" = 4. "
|
|
"Sum these values to determine the setting value. " ): ToSubClass
|
|
]
|
|
uint32 UpdateOptions;
|
|
|
|
[Read: ToSubClass, Write: ToSubClass,
|
|
Description("This Boolean indicates whether there is an "
|
|
"available DS on the DNS server."): ToSubClass
|
|
]
|
|
boolean DsAvailable;
|
|
|
|
[Read: ToSubClass, Write: ToSubClass,
|
|
Description("This property indicates whether the DNS server "
|
|
"automatically creates standard reverse lookup zones."):
|
|
ToSubClass
|
|
]
|
|
boolean DisableAutoReverseZones;
|
|
|
|
[Read: ToSubClass, Write: ToSubClass,
|
|
Description("This Boolean indicates whether the DNS server "
|
|
"attempts to update its cache entries using data from root "
|
|
"servers. When a DNS server boots, it needs a list of root "
|
|
"server 'hints' - NS and A records for the servers - "
|
|
"historically called the cache file. The Microsoft DNS "
|
|
"server has a feature to allow it to attempt to "
|
|
"write back a new cache file based on the responses from "
|
|
"the root servers."): ToSubClass
|
|
]
|
|
boolean AutoCacheUpdate;
|
|
[Read: ToSubClass, Write: ToSubClass,
|
|
Description("This Boolean indicates whether the DNS server does "
|
|
"NOT do recursive lookups. If set to TRUE, recursive "
|
|
"lookups are not done."): ToSubClass
|
|
]
|
|
boolean NoRecursion;
|
|
[Read: ToSubClass, Write: ToSubClass,
|
|
Description("This Boolean indicates whether the DNS server "
|
|
"round robins multiple A records."): ToSubClass
|
|
]
|
|
boolean RoundRobin;
|
|
[Read: ToSubClass, Write: ToSubClass,
|
|
Description("This Boolean indicates whether the DNS server "
|
|
"gives priority to the local net address returning A "
|
|
"records."): ToSubClass
|
|
]
|
|
boolean LocalNetPriority;
|
|
[Read: ToSubClass, Write: ToSubClass,
|
|
Description("This Boolean indicates whether the DNS server "
|
|
"parses zone files strictly. If the StrictFileParsing "
|
|
"property is undefined or zero, the server will log and "
|
|
"ignore bad data in the zone file and continue to load. If the "
|
|
"StrictFileParsing property is non-zero, the server will log "
|
|
"and fail on zone file errors."): ToSubClass
|
|
]
|
|
boolean StrictFileParsing;
|
|
[Read: ToSubClass, Write: ToSubClass,
|
|
Description("This Boolean indicates whether the DNS server does "
|
|
"wildcarding loosely. If the LooseWildcarding property is "
|
|
"undefined or zero, the server will follow the wildcarding behavior "
|
|
"specified in the DNS RFC. In this case, an admin is advised to "
|
|
"include MX records for all hosts that are not capable of receiving "
|
|
"mail. If the LooseWildcarding property is non-zero, the server "
|
|
"seeks out the closest wildcard node. In this case, an admin should "
|
|
"put MX records at both the zone root and in a wildcard node ('*') "
|
|
"directly below the zone root. Also, the admin should put self-"
|
|
"referent MX records on hosts, which are to receive their own "
|
|
"mail."): ToSubClass
|
|
]
|
|
boolean LooseWildcarding;
|
|
|
|
[Read: ToSubClass, Write: ToSubClass,
|
|
Description("This property determines the AXFR message format when "
|
|
"sending to non-Microsoft DNS secondaries. If this "
|
|
"property is TRUE, the server will send "
|
|
"transfers to non-Microsoft DNS secondaries in the uncompressed "
|
|
"format. If this property is FALSE, "
|
|
"the server will send all transfers in the fast format."): ToSubClass
|
|
]
|
|
boolean BindSecondaries;
|
|
|
|
[Read: ToSubClass, Write: ToSubClass,
|
|
Description("This Boolean indicates whether the DNS server writes "
|
|
"NS and SOA records to the authority section on successful "
|
|
"response."):
|
|
ToSubClass
|
|
]
|
|
boolean WriteAuthorityNS;
|
|
|
|
[Read: ToSubClass, Write: ToSubClass,
|
|
Description("This property indicates whether queries to delegated "
|
|
"sub-zones are forwarded."): ToSubClass
|
|
]
|
|
uint32 ForwardDelegations;
|
|
|
|
[Read: ToSubClass, Write: ToSubClass,
|
|
Description("This Boolean indicates whether the DNS server only"
|
|
"saves records of names that are in the same subtree as the "
|
|
"server that provided them."): ToSubClass
|
|
]
|
|
boolean SecureResponses;
|
|
[Read: ToSubClass, Write: ToSubClass,
|
|
Description("This Boolean indicates whether override is allowed "
|
|
"of the default binding for a socket used to send queries "
|
|
"to remote DNS servers."): ToSubClass
|
|
]
|
|
boolean DisjointNets;
|
|
|
|
[Read: ToSubClass, Write: ToSubClass,
|
|
Description("This Uint32 indicates which standard primary zones "
|
|
"authoritative for the name of the DNS server must be updated "
|
|
"when the name of the server changes. "
|
|
"The default value of this property is 1."): ToSubClass,
|
|
Valuemap {"0", "1", "2", "3"}: ToSubClass,
|
|
Values {
|
|
"None",
|
|
"Only those that allow dynamic updates",
|
|
"Only those that do not allow dynamic updates",
|
|
"All"}: ToSubClass
|
|
]
|
|
uint32 AutoConfigFileZones;
|
|
|
|
[Read: ToSubClass, Write: ToSubClass,
|
|
Description("Indicates the time interval between two consecutive "
|
|
"scavenging operations performed by the server. Zero value means "
|
|
"that scavenging is not enabled on the server."
|
|
"The default value of this property is 168 hours (7 days)."):
|
|
ToSubClass ,
|
|
Units("Hours"): ToSubClass
|
|
]
|
|
uint32 ScavengingInterval;
|
|
|
|
[Read: ToSubClass, Write: ToSubClass,
|
|
Description("Specifies the value of Refresh Interval to be set for all "
|
|
"Active Directory-integrated zones created on this server. "
|
|
"The default value of this property is 168 hours (7 days)."): ToSubClass ,
|
|
Units("Hours"): ToSubClass
|
|
]
|
|
uint32 DefaultRefreshInterval;
|
|
|
|
[Read: ToSubClass, Write: ToSubClass,
|
|
Description("Specifies the value of No-Refresh Interval to be set for all "
|
|
"Active Directory-integrated zones created on this server. "
|
|
"The default value of this property is 168 hours (7 days)."): ToSubClass ,
|
|
Units("Hours"): ToSubClass
|
|
]
|
|
uint32 DefaultNoRefreshInterval;
|
|
[Read: ToSubClass, Write: ToSubClass,
|
|
Description("Specifies the value of Enable Scavenging flag to be set for all "
|
|
"Active Directory-integrated zones created on this server. "
|
|
"The default value 0 corresponds to the Disabled scavenging of a zone."): ToSubClass
|
|
]
|
|
boolean DefaultAgingState;
|
|
|
|
[Read: ToSubClass, Write: ToSubClass,
|
|
Description("Specifies the lifetime in seconds of the cached "
|
|
"information describing the EDNS version supported by other "
|
|
"DNS servers."):
|
|
ToSubClass
|
|
]
|
|
uint32 EDnsCacheTimeout;
|
|
|
|
[Read: ToSubClass, Write: ToSubClass,
|
|
Description("Specifies the behavior of the DNS server with regard to "
|
|
"the EDNS specified in the RFC 2671. If this value is FALSE, "
|
|
"then the DNS server responds to the queries with response "
|
|
"containing OPTs if OPTs are send in the original query, but "
|
|
"doesn't include unsolicited OPTs in queries to other servers."
|
|
"If this value is TRUE then the server always "
|
|
"OPT RRs according to RFC 2671 unless the remote server has"
|
|
"indicated that it does not support EDNS in a prior exchange."): ToSubClass
|
|
]
|
|
boolean EnableEDnsProbes;
|
|
|
|
[Read: ToSubClass, Write: ToSubClass,
|
|
Description("Specifies whether the DNS server includes the DNSSEC "
|
|
"specific RRs, KEY,SIG and NXT, in the response. If this value is "
|
|
"0, then no DNSSEC records are included in response, unless the "
|
|
"query was requesting an RRset of the DNSSEC record type. If this "
|
|
"value is 1, then DNSSEC records are included in response according "
|
|
"to the RFC 2535. If this value is 2, then DNSSEC records are "
|
|
"included in response only if the original client query contained "
|
|
"the OPT RR according to the RFC 2671. If a query was requesting "
|
|
"an RRset of the DNSSEC record type the DNS server will always "
|
|
"respond with such records if they are available."): ToSubClass
|
|
]
|
|
uint32 EnableDnsSec;
|
|
|
|
[Read: ToSubClass,
|
|
Description("This array of strings enumerates the list of the DNS "
|
|
"server's IP addresses."): ToSubClass
|
|
]
|
|
string ServerAddresses[];
|
|
|
|
[Read: ToSubClass, Write: ToSubClass,
|
|
Description("This array of strings enumerates the list of IP addresses "
|
|
"on which the DNS server is allowed to receive queries."):
|
|
ToSubClass
|
|
]
|
|
string ListenAddresses[];
|
|
|
|
[
|
|
Read: ToSubClass, Write: ToSubClass,
|
|
Description(" This array of IP addresses "
|
|
"are the servers to which this DNS server forwards queries "
|
|
"that cannot be resolved with local data." ):
|
|
ToSubClass
|
|
]
|
|
string Forwarders[];
|
|
|
|
[
|
|
Read: ToSubClass, Write: ToSubClass,
|
|
Description( "Indicates how long (in seconds) a DNS server, "
|
|
"forwarding a query to a remote server listed in \"Forwarders\" "
|
|
"will wait for a reply." ): ToSubClass ,
|
|
Units("Seconds"): ToSubClass
|
|
]
|
|
uint32 ForwardingTimeout;
|
|
|
|
[
|
|
Read: ToSubClass, Write: ToSubClass,
|
|
Description( "A slave server will not attempt recursion "
|
|
"if forwarding fails."): ToSubClass
|
|
]
|
|
boolean IsSlave;
|
|
|
|
[
|
|
Read: ToSubClass,
|
|
Write: ToSubClass,
|
|
Description( "This value is TRUE if support for application "
|
|
"directory partitions is enabled on this server." ): ToSubClass
|
|
]
|
|
boolean EnableDirectoryPartitionSupport;
|
|
|
|
//
|
|
// Methods
|
|
//
|
|
|
|
[Implemented, Description(
|
|
"This method starts the DNS server."): ToSubClass
|
|
]
|
|
uint32 StartService();
|
|
|
|
[Implemented, Description(
|
|
"This method stops the DNS server."): ToSubClass
|
|
]
|
|
uint32 StopService();
|
|
|
|
[Implemented, Description(
|
|
"This method starts the scavenging of stale records in the zones subjected to scavenging."): ToSubClass
|
|
]
|
|
uint32 StartScavenging();
|
|
|
|
[Implemented, Description(
|
|
"This method get DS distinguished Name for the zone.") : ToSubClass
|
|
]
|
|
string GetDistinguishedName();
|
|
};
|
|
|
|
|
|
[
|
|
Schema ("MicrosoftDNS"): ToSubClass ,
|
|
Description("This class represents a Domain in a DNS "
|
|
"hierarchy tree."): ToSubClass,
|
|
Dynamic, Provider("MS_NT_DNS_PROVIDER"),
|
|
Locale (0x409), UUID ("{4E0BD136-AA43-11d2-85DD-0000F8102E5F}")
|
|
]
|
|
class MicrosoftDNS_Domain : CIM_LogicalElement
|
|
{
|
|
[Key, Propagated ("MicrosoftDNS_Server.Name"): ToSubClass,
|
|
Read: ToSubClass,
|
|
Description("Indicates the Fully Qualified Domain Name "
|
|
"or IP address of the DNS server that contains this domain."):
|
|
ToSubClass
|
|
]
|
|
string DnsServerName;
|
|
[Key, Read: ToSubClass,
|
|
Description("Indicates the Name of the Container (which "
|
|
"could be a Zone, Cache or RootHints) containing this "
|
|
"domain. In cases where the Container is a Zone (an "
|
|
"instance of the MicrosoftDNS_Zone subclass), this property"
|
|
"contains the fully qualified domain name of the Zone. "
|
|
"When the Container is the root zone, the string, \".\","
|
|
"should be used. In cases where the Container is "
|
|
"the DNS' cache of resource records (an instance of the "
|
|
"MicrosoftDNS_Cache subclass), this property is set to the "
|
|
"string, \"..Cache\". If the Container is Root Hints (an "
|
|
"instance of the MicrosoftDNS_RootHints subclass), then this "
|
|
"property should be set to \"..RootHints\"."): ToSubClass
|
|
]
|
|
string ContainerName;
|
|
[Override ("Name"): ToSubClass , Key,
|
|
Read: ToSubClass,
|
|
Description("This string represents the Fully Qualified Domain Name "
|
|
"of the domain. For instances of DNS Cache or Root Hints, "
|
|
"the strings, \"..Cache\" and \"..Root Hints\" respectively, "
|
|
"should be used."): ToSubClass
|
|
]
|
|
string Name;
|
|
[Implemented, Description(
|
|
"This method get DS distinguished Name for the zone.") : ToSubClass
|
|
]
|
|
string GetDistinguishedName();
|
|
|
|
};
|
|
|
|
[
|
|
Schema ("MicrosoftDNS"): ToSubClass ,
|
|
Description("This class describes a DNS Zone. Every instance of "
|
|
"the class MicrosoftDNS_Zone must be assigned to one and only one DNS "
|
|
"server. Zones may be associated with (or more intuitively 'may "
|
|
"contain') any number of instances of the classes MicrosoftDNS_Domain "
|
|
"or/and MicrosoftDNS_ResourceRecord."): ToSubClass,
|
|
Dynamic, Provider("MS_NT_DNS_PROVIDER"),
|
|
Locale (0x409), UUID ("{4E0BD137-AA43-11d2-85DD-0000F8102E5F}")
|
|
]
|
|
class MicrosoftDNS_Zone : MicrosoftDNS_Domain
|
|
{
|
|
[
|
|
Read: ToSubClass,
|
|
Description( "Indicates the type of the Zone." ): ToSubClass,
|
|
Values
|
|
{
|
|
"Cache", "Primary", "Secondary", "Stub", "Forwarder"
|
|
}: ToSubClass
|
|
]
|
|
uint32 ZoneType;
|
|
|
|
[
|
|
Read: ToSubClass,
|
|
Description( "This property indicates whether the Zone is "
|
|
"stored in Active Directory." ): ToSubClass
|
|
]
|
|
boolean DsIntegrated;
|
|
|
|
[
|
|
Read: ToSubClass, Write: ToSubClass,
|
|
Description( "This Boolean indicates whether the Zone should "
|
|
"accept dynamic update requests." ): ToSubClass
|
|
]
|
|
uint32 AllowUpdate;
|
|
|
|
[
|
|
Read: ToSubClass, Write: ToSubClass,
|
|
Description( "Indicates the name of the zone file." ): ToSubClass
|
|
]
|
|
string DataFile;
|
|
|
|
[
|
|
Read: ToSubClass,
|
|
Description( "This property is TRUE if the the WINS record "
|
|
"for the zone will not be replicated through zone "
|
|
"transfer." ): ToSubClass
|
|
]
|
|
boolean DisableWINSRecordReplication;
|
|
|
|
[
|
|
Read: ToSubClass,
|
|
Description( "This property indicates whether the server will "
|
|
"notify secondaries of any changes to records in the zone. "
|
|
"If set to 1, secondaries are notified."): ToSubClass
|
|
]
|
|
uint32 Notify;
|
|
|
|
[
|
|
Read: ToSubClass,
|
|
Description( "This property indicates whether zone transfer is "
|
|
"allowed - but only to designated secondaries."
|
|
"Designated secondaries are DNS servers whose IP addresses "
|
|
"are listed in the Secondaries array." ): ToSubClass
|
|
]
|
|
uint32 SecureSecondaries;
|
|
|
|
[
|
|
Read: ToSubClass,
|
|
Description( "This Boolean indicates whether the Zone is "
|
|
"paused."): ToSubClass
|
|
]
|
|
boolean Paused;
|
|
|
|
[
|
|
Read: ToSubClass,
|
|
Description( "This Boolean indicates whether this copy of the "
|
|
"Zone is expired." ): ToSubClass
|
|
]
|
|
boolean Shutdown;
|
|
|
|
[
|
|
Read: ToSubClass,
|
|
Description( "This property indicates whether the zone is a "
|
|
"reverse lookup zone." ): ToSubClass
|
|
]
|
|
boolean Reverse;
|
|
|
|
[
|
|
Read: ToSubClass,
|
|
Description( "This Boolean indicates whether the Zone was "
|
|
"auto-created by the DNS Server." ): ToSubClass
|
|
]
|
|
boolean AutoCreated;
|
|
|
|
[
|
|
Read: ToSubClass,
|
|
Description( "This Boolean indicates whether the Zone uses "
|
|
"WINS lookup."): ToSubClass
|
|
]
|
|
boolean UseWins;
|
|
|
|
[
|
|
Read: ToSubClass, Write: ToSubClass,
|
|
Description("Specifies the aging and scavenging behavior of "
|
|
"this zone. The "
|
|
"0 value corresponds to Disabled scavenging of the zone. If the "
|
|
"Scavenging of the zone is disabled, the timestamps of the records "
|
|
"in the zone are not refreshed and the records are not subjected "
|
|
"to scavenging. If the value is set to 1, the records are subjected "
|
|
"to scavenging and their timestamps are refreshed when the server "
|
|
"receives the dynamic update request for the records. "
|
|
"For the Active Directory-integrated zones this value is set to "
|
|
"the DefaultAgingState property of the DNS server where the "
|
|
"zone is created. For the standard primary zones the default "
|
|
"value is 0."): ToSubClass
|
|
]
|
|
boolean Aging;
|
|
|
|
[
|
|
Read: ToSubClass, Write: ToSubClass,
|
|
Description( "Specifies the value of Refresh Interval, during which "
|
|
"the records with non-zero timestamp are expected to be refreshed "
|
|
"to remain in the zone. Records that have not been refreshed by "
|
|
"expiration of the Refresh interval could be removed by the next "
|
|
"scavenging performed by a server. This value should never be "
|
|
"less than the longest refresh period of the records registered "
|
|
"in the zone. Too shirt values of this parameter may lead to "
|
|
"removal of valid DNS records. Too large values prolong the "
|
|
"lifetime of the stale records. "
|
|
"This value is set to the DefaultRefreshInterval property of the "
|
|
"DNS server where the zone is created." ): ToSubClass,
|
|
Units( "Hours" ): ToSubClass
|
|
]
|
|
uint32 RefreshInterval;
|
|
|
|
[
|
|
Read: ToSubClass, Write: ToSubClass,
|
|
Description( "Specifies the time interval between the last update "
|
|
"of a record's timestamp and the earliest moment when the timestamp "
|
|
"can be refreshed. During No-Refresh Interval a DNS server "
|
|
"suppresses the refreshes sent to a record. Small values of this "
|
|
"parameter may cause often writes to the zone storage, e.g. Active "
|
|
"Directory. Large values of this parameter prolong lifetime of the "
|
|
"stale DNS records. "
|
|
"This value is set to the DefaultRefreshInterval property of the "
|
|
"DNS server where the zone is created." ): ToSubClass ,
|
|
Units( "Hours" ): ToSubClass
|
|
]
|
|
uint32 NoRefreshInterval;
|
|
|
|
[
|
|
Read: ToSubClass,
|
|
Description(
|
|
"Specifies the time when the server may attempt scavenging the "
|
|
"zone. Even if the zone is configured to enable scavenging the "
|
|
"DNS server will not attempt scavenging this zone until after "
|
|
"this moment."
|
|
"This value is set to the current time plus Refresh Interval of "
|
|
"the zone every time when the zone is loaded, resumed after being "
|
|
"paused, scavenging becomes enabled, Refresh Interval is changed "
|
|
"and dynamic update becomes enabled. This parameter is stored "
|
|
"locally and is not replicated to other copies of the "
|
|
"zone."): ToSubClass ,
|
|
Units("Hours since GMT midnight January 1, 1601"): ToSubClass
|
|
]
|
|
uint32 AvailForScavengeTime;
|
|
|
|
[
|
|
Read: ToSubClass, Write: ToSubClass,
|
|
Description( "IP addresses of the master DNS servers for this "
|
|
"zone." ): ToSubClass
|
|
]
|
|
string MasterServers[];
|
|
|
|
[
|
|
Read: ToSubClass, Write: ToSubClass,
|
|
Description( "Local IP addresses of the master DNS servers for this "
|
|
"zone. If set, these masters over-ride the MasterServers found in "
|
|
"Active Directory." ): ToSubClass
|
|
]
|
|
string LocalMasterServers[];
|
|
|
|
[
|
|
Read: ToSubClass, Write: ToSubClass,
|
|
Description( "This array of strings enumerates the list of "
|
|
"IP addresses of DNS servers, that are allowed to perform scavenging "
|
|
"of the stale records of this zone. If the list is not specified any "
|
|
"primary DNS server authoritative for the zone will be able to "
|
|
"scavenge the zone if other prerequisites are met." ): ToSubClass
|
|
]
|
|
string ScavengeServers[];
|
|
|
|
[
|
|
Read: ToSubClass, Write: ToSubClass,
|
|
Description( "This array of strings enumerates the list of IP "
|
|
"addresses of the DNS servers that are allowed to"
|
|
"receive this zone through zone replication." ): ToSubClass
|
|
]
|
|
string SecondaryServers[];
|
|
|
|
[
|
|
Read: ToSubClass,
|
|
Description( "This array of strings enumerates the list of IP "
|
|
"addresses of the DNS servers that should be notified of "
|
|
"changes in this zone."): ToSubClass
|
|
]
|
|
string NotifyServers[];
|
|
|
|
[
|
|
Read: ToSubClass, Write: ToSubClass,
|
|
Description( "Indicates how long (in seconds) a DNS server, "
|
|
"forwarding a query, for the name under the forward zone, "
|
|
"will wait for resolution from the "
|
|
"forwarder, before attempting to resolve the query "
|
|
"itself. This parameter is applicable to the Forward zones "
|
|
"only." ): ToSubClass ,
|
|
Units( "Seconds" ): ToSubClass
|
|
]
|
|
uint32 ForwarderTimeout;
|
|
|
|
[
|
|
Read: ToSubClass, Write: ToSubClass,
|
|
Description( "This Boolean indicates whether the DNS server acts as "
|
|
"a Slave when resolving the names for the specified forward zone. "
|
|
"This parameter is applicable to the Forward zones only."): ToSubClass
|
|
]
|
|
boolean ForwarderSlave;
|
|
|
|
[
|
|
Read: ToSubClass,
|
|
Description( "The time the SOA serial number was last checked for this "
|
|
"zone in seconds since the start of 1 January 1970 GMT." ): ToSubClass
|
|
]
|
|
uint32 LastSuccessfulSoaCheck;
|
|
|
|
[
|
|
Read: ToSubClass,
|
|
Description( "The time this zone was last transferred from a "
|
|
"master server in seconds since the start of 1 January 1970 "
|
|
"GMT." ): ToSubClass
|
|
]
|
|
uint32 LastSuccessfulXfr;
|
|
|
|
//
|
|
// Methods
|
|
//
|
|
|
|
|
|
[
|
|
Implemented, Description( "This method pauses the zone."): ToSubClass
|
|
]
|
|
void PauseZone();
|
|
|
|
[
|
|
Implemented, Description( "This method resumes the zone." ): ToSubClass
|
|
]
|
|
void ResumeZone();
|
|
|
|
[
|
|
Implemented, Description( "This method reloads the zone." ): ToSubClass
|
|
]
|
|
void ReloadZone();
|
|
|
|
[
|
|
Implemented, Description(
|
|
"This method causes the server to check the DNS server to "
|
|
"check the master server of a secondary zone for updates." ): ToSubClass
|
|
]
|
|
void ForceRefresh();
|
|
|
|
[
|
|
Implemented, Description(
|
|
"This method forces an update of the zone from the DS. This "
|
|
"method is only valid for DS-integrated zones." ): ToSubClass
|
|
]
|
|
void UpdateFromDS();
|
|
|
|
[
|
|
Implemented, Description(
|
|
"This method saves the xone's data to persistent storage."): ToSubClass
|
|
]
|
|
void WriteBackZone();
|
|
|
|
[
|
|
Implemented, Description(
|
|
"This method enables aging for some or all non-NS and non-SOA records "
|
|
"in a zone. If no NodeName is specified all records will be affected "
|
|
"to aging and scavenging. If the NodeName is specified and "
|
|
"ApplyToSubtree is not specified or set to 0, then records at the "
|
|
"specified node will be subjected to aging and scavenging. If the "
|
|
"NodeName is specified and ApplyToSubtree is set to 1, then all "
|
|
"records of the subtree starting at the specified node will be "
|
|
"subjected to aging and scavenging. When this method is used, the "
|
|
"timestamp is set to the current time for all non-NS and non-SOA "
|
|
"resource records with the owner name(s) identified by the input "
|
|
"parameters."): ToSubClass
|
|
]
|
|
uint32 AgeAllRecords(
|
|
[ IN, optional ] string NodeName,
|
|
[ IN, optional ] boolean ApplyToSubtree );
|
|
|
|
[
|
|
Static, Implemented, Description(
|
|
"This method creates a new zone." ) : ToSubClass
|
|
]
|
|
void CreateZone(
|
|
[IN] string ZoneName,
|
|
[IN, Values {"DS integrated", "Primary", "Secondary", "Stub", "Stub - DS integrated", "Forward"}] uint32 ZoneType,
|
|
[IN, optional] string DataFileName,
|
|
[IN, optional] string IpAddr[],
|
|
[IN, optional] string AdminEmailName,
|
|
[OUT] MicrosoftDns_Zone ref RR);
|
|
|
|
[
|
|
Implemented, Description( "This changes zone type." ) : ToSubClass
|
|
]
|
|
void ChangeZoneType(
|
|
[IN, Values {"DS integrated", "Primary", "Secondary", "Stub", "Stub - DS integrated", "Forward"}] uint32 ZoneType,
|
|
[IN, optional] string DataFileName,
|
|
[IN, optional] string IpAddr[],
|
|
[IN, optional] string AdminEmailName,
|
|
[OUT] MicrosoftDns_Zone ref RR);
|
|
|
|
[
|
|
Implemented, Description(
|
|
"This method resets the secondary ip address array." ) : ToSubClass
|
|
]
|
|
void ResetSecondaries(
|
|
[IN] string SecondaryServers[],
|
|
[IN] uint32 SecureSecondaries,
|
|
[IN] string NotifyServers[],
|
|
[IN] uint32 Notify,
|
|
[OUT] MicrosoftDns_Zone ref RR);
|
|
|
|
[
|
|
Implemented, Description(
|
|
"This method get DS distinguished Name for the zone." ) : ToSubClass
|
|
]
|
|
string GetDistinguishedName();
|
|
|
|
};
|
|
|
|
[
|
|
Schema ("MicrosoftDNS"): ToSubClass ,
|
|
Description("This class describes a cache existing on a DNS "
|
|
"server. It shouldn't be confused with a Cache file which "
|
|
"contains root hints. This class simplifies visualizing the "
|
|
"containment of DNS objects, rather than representing a "
|
|
"real object. The class, MicrosoftDNS_Cache, is a container for the "
|
|
"resource records cached by the DNS server. Every instance of "
|
|
"the class MicrosoftDNS_Cache must be assigned to one and only one "
|
|
"DNS server. It may be associated with (or more intuitively 'may "
|
|
"contain') any number of instances of the classes, MicrosoftDNS_"
|
|
"Domain and/or MicrosoftDNS_ResourceRecord."): ToSubClass ,
|
|
Dynamic, Provider("MS_NT_DNS_PROVIDER"),
|
|
Locale (0x409), UUID ("{591E9D38-AA43-11d2-85DD-0000F8102E5F}")
|
|
]
|
|
class MicrosoftDNS_Cache : MicrosoftDNS_Domain
|
|
{
|
|
[Implemented,
|
|
Description(
|
|
"This method clears the DNS server's cache of resource records. "
|
|
): ToSubClass
|
|
]
|
|
void ClearCache();
|
|
|
|
[Implemented, Description(
|
|
"This method get DS distinguished Name for the zone.") : ToSubClass
|
|
]
|
|
string GetDistinguishedName();
|
|
|
|
};
|
|
|
|
|
|
[
|
|
Schema ("MicrosoftDNS"): ToSubClass ,
|
|
Description("This class describes the Root Hints stored in a "
|
|
"Cache file on a DNS server. This class simplifies visualizing the "
|
|
"containment of DNS objects, rather than representing a real "
|
|
"object. Class MicrosoftDNS_RootHints is a container for the resource "
|
|
"records stored by the DNS server in a Cache file. Every instance "
|
|
"of the class MicrosoftDNS_RootHints must be assigned to one and only "
|
|
"one DNS server. It may be associated with (or more intuitively 'may "
|
|
"contain') any number of instances of class MicrosoftDNS_Resource"
|
|
"Record."): ToSubClass,
|
|
Dynamic, Provider("MS_NT_DNS_PROVIDER"),
|
|
Locale (0x409), UUID ("{5F3F688C-AA43-11d2-85DD-0000F8102E5F}")
|
|
]
|
|
class MicrosoftDNS_RootHints : MicrosoftDNS_Domain
|
|
{
|
|
[Implemented, Description(
|
|
"This method writes the Root Hints back to the DNS' Cache file. "
|
|
): ToSubClass
|
|
]
|
|
void WriteBackRootHintDatafile();
|
|
[Implemented, Description(
|
|
"This method get DS distinguished Name for the zone.") : ToSubClass
|
|
]
|
|
string GetDistinguishedName();
|
|
|
|
};
|
|
|
|
[
|
|
Schema ("MicrosoftDNS"): ToSubClass ,
|
|
Description("This class represents the general properties of a "
|
|
"DNS Resource Record."): ToSubClass,
|
|
abstract, Provider("MS_NT_DNS_PROVIDER"),
|
|
Locale (0x409), UUID ("{5F3F688D-AA43-11d2-85DD-0000F8102E5F}")
|
|
]
|
|
class MicrosoftDNS_ResourceRecord : CIM_LogicalElement
|
|
{
|
|
[Key, Propagated ("MicrosoftDNS_Domain.DnsServerName"): ToSubClass,
|
|
Read: ToSubClass,
|
|
Description("Indicates the Fully Qualified Domain Name or "
|
|
"IP address of the DNS server that contains this Resource "
|
|
"Record."): ToSubClass
|
|
]
|
|
string DnsServerName;
|
|
|
|
[Key, Propagated("MicrosoftDNS_Domain.ContainerName"): ToSubClass,
|
|
Read: ToSubClass,
|
|
Description("Indicates the name of the Container for "
|
|
"the Zone, Cache or Root Hints instance which contains this "
|
|
"Resource Record"): ToSubClass
|
|
]
|
|
string ContainerName;
|
|
|
|
[Key, Propagated ("MicrosoftDNS_Domain.Name"): ToSubClass,
|
|
Read: ToSubClass,
|
|
Description("This string represents the Fully Qualified Domain Name of "
|
|
"the Domain which contains this Resource Record. This property "
|
|
"may contain the strings, \"..Cache\" or \"..RootHints\", if the "
|
|
"DNS' internal cache or Root Hints (respectively) contain this "
|
|
"Resource Record."): ToSubClass
|
|
]
|
|
string DomainName;
|
|
|
|
[Key, Read: ToSubClass,
|
|
Description ("The owner name for the Resource Record."): ToSubClass
|
|
]
|
|
string OwnerName;
|
|
|
|
[Key, Read: ToSubClass,
|
|
Description("This string represents the class of the Resource "
|
|
"Record."): ToSubClass,
|
|
Valuemap {"1", "2", "3", "4"}: ToSubClass,
|
|
Values {"IN (Internet)", "CS (CSNET)", "CH (CHAOS)",
|
|
"HS (Hesiod)"}: ToSubClass
|
|
]
|
|
uint16 RecordClass=1;
|
|
|
|
[Read: ToSubClass, Write: ToSubClass,
|
|
Description("This property indicates how long (in seconds) the "
|
|
"Resource Record can be cached by a DNS resolver."): ToSubClass,
|
|
Units ("Seconds"): ToSubClass
|
|
]
|
|
uint32 TTL;
|
|
|
|
[Read: ToSubClass, Write: ToSubClass,
|
|
Description("This property indicates the time moment, when the record "
|
|
"was refreshed last time. The zero value means that the record is "
|
|
"not subjected to aging and scavenging. To disable aging and "
|
|
"scavenging of this record set this value to zero. To enable "
|
|
"record's aging and scavenging use AgeAllRecords method defined "
|
|
"under the MicrosoftDNS_Zone class."): ToSubClass,
|
|
Units ("Hours since GMT midnight January 1, 1601"): ToSubClass
|
|
]
|
|
uint32 Timestamp;
|
|
|
|
[Key, Read: ToSubClass,
|
|
Description("This string represents the Resource Record data."):
|
|
ToSubClass
|
|
]
|
|
string RecordData;
|
|
|
|
[Read: ToSubClass,
|
|
Description("This string represents the entire Resource Record."):
|
|
ToSubClass
|
|
]
|
|
string TextRepresentation;
|
|
|
|
[Static, Implemented, Description(
|
|
"This method parses the resource record in the TextRepresentation "
|
|
"string, and along with the input DNS server and Container names, "
|
|
"defines and instantiates a ResourceRecord object. The method "
|
|
"returns a reference to the new object as an output parameter."
|
|
): ToSubClass
|
|
]
|
|
void CreateInstanceFromTextRepresentation(
|
|
[IN] string DnsServerName,
|
|
[IN] string ContainerName,
|
|
[IN] string TextRepresentation,
|
|
[OUT] MicrosoftDNS_ResourceRecord ref RR );
|
|
|
|
[Static, Implemented, Description(
|
|
"This method to retrieve an existing instance of the MicrosoftDns_ResourceRecord "
|
|
"subclass, represented by the TextRepresentation string along with Dns Server "
|
|
"and container name." ): ToSubClass
|
|
]
|
|
void GetObjectByTextRepresentation(
|
|
[IN] string DnsServerName,
|
|
[IN] string ContainerName,
|
|
[IN] string TextRepresentation,
|
|
[OUT] MicrosoftDns_ResourceRecord RR);
|
|
|
|
};
|
|
|
|
[
|
|
Schema ("MicrosoftDNS"): ToSubClass ,
|
|
Description ("A subclass of MicrosoftDNS_ResourceRecord that represents a "
|
|
"Type A record."): ToSubClass ,
|
|
Dynamic, Provider("MS_NT_DNS_PROVIDER"),
|
|
Locale (0x409), UUID ("{1A2BC2E6-B6EA-11d2-85E5-0000F8102E5F}")
|
|
]
|
|
class MicrosoftDNS_AType : MicrosoftDNS_ResourceRecord
|
|
{
|
|
[Read: ToSubClass ,
|
|
Description("The IP address of the Host (A) record."): ToSubClass
|
|
]
|
|
string IPAddress;
|
|
|
|
[Implemented, static, Description(
|
|
"This method instantiates an 'A' Type of Resource Record based on "
|
|
"the data in the method's input parameters: the record's DNS Server "
|
|
"Name, Container Name, Owner Name, class (default = IN), 'time to "
|
|
"live' value and the Host's IP address. It returns a reference to "
|
|
"the new object as an output parameter."):
|
|
ToSubClass
|
|
]
|
|
void CreateInstanceFromPropertyData(
|
|
[IN] string DnsServerName,
|
|
[IN] string ContainerName,
|
|
[IN] string OwnerName,
|
|
[IN, optional, Valuemap {"1", "2", "3", "4"}, Values {"IN (Internet)",
|
|
"CS (CSNET)", "CH (CHAOS)", "HS (Hesiod)"}] uint32 RecordClass = 1,
|
|
[IN, optional] uint32 TTL,
|
|
[IN] string IPAddress,
|
|
[OUT] MicrosoftDNS_AType ref RR);
|
|
|
|
[Implemented, Description(
|
|
"This method updates the TTL and IP address to the values specified "
|
|
"as the input parameters of this method. If a new value for some "
|
|
"parameter is not specified, then the current value for this parameter "
|
|
"is not changed. The method returns a reference to the modified "
|
|
"object as an output parameter."): ToSubClass
|
|
]
|
|
void Modify(
|
|
[IN, optional] uint32 TTL,
|
|
[IN, optional] string IPAddress,
|
|
[OUT] MicrosoftDNS_AType ref RR );
|
|
};
|
|
|
|
[
|
|
Schema ("MicrosoftDNS"): ToSubClass ,
|
|
Description ("A subclass of MicrosoftDNS_ResourceRecord that represents a "
|
|
"Type SOA record."): ToSubClass ,
|
|
Dynamic, Provider("MS_NT_DNS_PROVIDER"),
|
|
Locale (0x409), UUID ("{47B8D066-B6EA-11d2-85E5-0000F8102E5F}")
|
|
]
|
|
class MicrosoftDNS_SOAType : MicrosoftDNS_ResourceRecord
|
|
{
|
|
[Read: ToSubClass ,
|
|
Description("The serial number of the SOA record."): ToSubClass
|
|
]
|
|
uint32 SerialNumber;
|
|
[Read: ToSubClass ,
|
|
Description("The primary DNS server having authority for the zone "
|
|
"to which this record belongs."): ToSubClass
|
|
]
|
|
string PrimaryServer;
|
|
[Read: ToSubClass ,
|
|
Description("The 'responsible party' for the zone to which this "
|
|
"record belongs."): ToSubClass
|
|
]
|
|
string ResponsibleParty;
|
|
[Read: ToSubClass ,
|
|
Description("The time interval (in seconds) before the zone, "
|
|
"containing this record, should be refreshed."): ToSubClass ,
|
|
Units ("Seconds"): ToSubClass
|
|
]
|
|
uint32 RefreshInterval;
|
|
[Read: ToSubClass ,
|
|
Description("The time interval (in seconds) that should elapse before "
|
|
"retrying a failed refresh of the zone to which this record belongs."):
|
|
ToSubClass ,
|
|
Units ("Seconds"): ToSubClass
|
|
]
|
|
uint32 RetryDelay;
|
|
[Read: ToSubClass ,
|
|
Description("The upper limit on the time interval (in seconds) that "
|
|
"can elapse before the zone, to which this record belongs, is no "
|
|
"longer authoritative."): ToSubClass ,
|
|
Units ("Seconds"): ToSubClass
|
|
]
|
|
uint32 ExpireLimit;
|
|
[Read: ToSubClass ,
|
|
Description("The lower limit on the time interval (in seconds) that a "
|
|
"DNS server or Caching resolver are allowed to cache any resource "
|
|
"record from the zone, to which this record belongs."): ToSubClass ,
|
|
Units ("Seconds"): ToSubClass
|
|
]
|
|
uint32 MinimumTTL;
|
|
[Implemented, Description(
|
|
"This method updates the TTL, SOA Serial Number, Primary Server, "
|
|
"Responsible Party, Refresh Interval, Retry Delay, Expire Limit and "
|
|
"Minimum TTL (for the zone) to the values specified as the input "
|
|
"parameters of this method. If a new value for some parameter is not "
|
|
"specified, then the current value for this parameter is not changed. "
|
|
"The method returns a reference to the modified object as an output "
|
|
"parameter."): ToSubClass
|
|
|
|
]
|
|
void Modify(
|
|
[IN, optional] uint32 TTL,
|
|
[IN, optional] uint32 SerialNumber,
|
|
[IN, optional] string PrimaryServer,
|
|
[IN, optional] string ResponsibleParty,
|
|
[IN, optional] uint32 RefreshInterval,
|
|
[IN, optional] uint32 RetryDelay,
|
|
[IN, optional] uint32 ExpireLimit,
|
|
[IN, optional] uint32 MinimumTTL,
|
|
[OUT] MicrosoftDNS_SOAType ref RR);
|
|
|
|
|
|
|
|
};
|
|
|
|
[
|
|
Schema ("MicrosoftDNS"): ToSubClass ,
|
|
Description("A subclass of MicrosoftDNS_ResourceRecord that represents a "
|
|
"Type PTR record."): ToSubClass ,
|
|
Dynamic, Provider("MS_NT_DNS_PROVIDER"),
|
|
Locale (0x409), UUID ("{567E21F9-B6EA-11d2-85E5-0000F8102E5F}")
|
|
]
|
|
class MicrosoftDNS_PTRType : MicrosoftDNS_ResourceRecord
|
|
{
|
|
[Read: ToSubClass ,
|
|
Description("The Fully Qualified Domain Name of the PTR record Data."):
|
|
ToSubClass
|
|
]
|
|
string PTRDomainName;
|
|
[Implemented,static, Description(
|
|
"This method instantiates a 'PTR' Type of Resource Record based on "
|
|
"the data in the method's input parameters: the record's DNS Server "
|
|
"Name, Container Name, Owner Name, class (default = IN), 'time to "
|
|
"live' value and the FQDN of the PTR record. It returns a "
|
|
"reference to the new object as an output parameter."): ToSubClass
|
|
]
|
|
void CreateInstanceFromPropertyData(
|
|
[IN] string DnsServerName,
|
|
[IN] string ContainerName,
|
|
[IN] string OwnerName,
|
|
[IN, optional, Valuemap {"1", "2", "3", "4"}, Values {"IN (Internet)",
|
|
"CS (CSNET)", "CH (CHAOS)", "HS (Hesiod)"}] uint32 RecordClass = 1,
|
|
[IN, optional] uint32 TTL,
|
|
[IN] string PTRDomainName,
|
|
[OUT] MicrosoftDNS_PTRType ref RR);
|
|
|
|
[Implemented, Description(
|
|
"This method updates the TTL and PTR Domain Name to the values "
|
|
"specified as the input parameters of this method. If a new value "
|
|
"for some parameter is not specified, then the current value for this "
|
|
"parameter IS not changed. The method returns a reference to the "
|
|
"modified object as an output parameter."): ToSubClass
|
|
|
|
]
|
|
void Modify(
|
|
[IN, optional] uint32 TTL,
|
|
[IN, optional] string PTRDomainName,
|
|
[OUT] MicrosoftDNS_PTRType ref RR);
|
|
|
|
};
|
|
|
|
[
|
|
Schema ("MicrosoftDNS"): ToSubClass ,
|
|
Description("A subclass of MicrosoftDNS_ResourceRecord that represents a "
|
|
"Type NS record."): ToSubClass ,
|
|
Dynamic, Provider("MS_NT_DNS_PROVIDER"),
|
|
Locale (0x409), UUID ("{3F655A18-B6EA-11d2-85E5-0000F8102E5F}")
|
|
]
|
|
class MicrosoftDNS_NSType : MicrosoftDNS_ResourceRecord
|
|
{
|
|
[Read: ToSubClass ,
|
|
Description("A host which should be authoritative for the domain, "
|
|
"specified in record's owner."): ToSubClass
|
|
]
|
|
string NSHost;
|
|
[Implemented, static, Description(
|
|
"This method instantiates an 'NS' Type of Resource Record based on "
|
|
"the data in the method's input parameters: the record's DNS Server "
|
|
"Name, Container Name, Owner Name, class (default = IN), 'time to "
|
|
"live' value and the host with authority for the domain. It returns "
|
|
"a reference to the new object as an output parameter."): ToSubClass
|
|
]
|
|
void CreateInstanceFromPropertyData([IN] string DnsServerName,
|
|
[IN] string ContainerName, [IN] string OwnerName,
|
|
[IN, optional, Valuemap {"1", "2", "3", "4"}, Values {"IN (Internet)",
|
|
"CS (CSNET)", "CH (CHAOS)", "HS (Hesiod)"}] uint32 RecordClass = 1,
|
|
[IN, optional] uint32 TTL, [IN] string NSHost,
|
|
[OUT] MicrosoftDNS_NSType ref RR);
|
|
|
|
[Implemented, Description(
|
|
"This method updates the TTL and NS Host to the values specified as the "
|
|
"input parameters of this method. If a new value for some parameter is "
|
|
"not specified, then the current value for this parameter IS not changed. "
|
|
"The method returns a reference to the modified object as an output "
|
|
"parameter. "): ToSubClass
|
|
|
|
]
|
|
void Modify(
|
|
[IN, optional] uint32 TTL,
|
|
[IN, optional] string NSHost,
|
|
[OUT] MicrosoftDNS_NSType ref RR);
|
|
|
|
};
|
|
|
|
[
|
|
Schema ("MicrosoftDNS"): ToSubClass ,
|
|
Description("A subclass of MicrosoftDNS_ResourceRecord that represents a "
|
|
"Type CNAME record."): ToSubClass ,
|
|
Dynamic, Provider("MS_NT_DNS_PROVIDER"),
|
|
Locale (0x409), UUID ("{47B8D065-B6EA-11d2-85E5-0000F8102E5F}")
|
|
]
|
|
class MicrosoftDNS_CNAMEType : MicrosoftDNS_ResourceRecord
|
|
{
|
|
[Read: ToSubClass ,
|
|
Description("The canonical or primary name for the owner "
|
|
"of the CNAME record."): ToSubClass
|
|
]
|
|
string PrimaryName;
|
|
[Implemented, static, Description(
|
|
"This method instantiates a 'CNAME' Type of Resource Record based "
|
|
"on the data in the method's input parameters: the record's DNS "
|
|
"Server Name, Container Name, Owner Name, class (default = IN), "
|
|
"'time to live' value and the primary name of the CNAME record. It "
|
|
"returns a reference to the new object as an output parameter."): ToSubClass
|
|
]
|
|
void CreateInstanceFromPropertyData([IN] string DnsServerName,
|
|
[IN] string ContainerName, [IN] string OwnerName,
|
|
[IN, optional, Valuemap {"1", "2", "3", "4"}, Values {"IN (Internet)",
|
|
"CS (CSNET)", "CH (CHAOS)", "HS (Hesiod)"}] uint32 RecordClass = 1,
|
|
[IN, optional] uint32 TTL, [IN] string PrimaryName,
|
|
[OUT] MicrosoftDNS_CNAMEType ref RR);
|
|
|
|
[Implemented, Description(
|
|
"This method updates the TTL and Primary Name to the values specified "
|
|
"as the input parameters of this method. If a new value for some "
|
|
"parameter is not specified, then the current value for this parameter "
|
|
"is not changed. The method returns a reference to the modified object "
|
|
"as an output parameter."): ToSubClass
|
|
]
|
|
void Modify(
|
|
[IN, optional] uint32 TTL,
|
|
[IN, optional] string PrimaryName,
|
|
[OUT] MicrosoftDNS_CNAMEType ref RR);
|
|
|
|
};
|
|
|
|
[
|
|
Schema ("MicrosoftDNS"): ToSubClass ,
|
|
Description("A subclass of MicrosoftDNS_ResourceRecord that represents a "
|
|
"Type MB record."): ToSubClass ,
|
|
Dynamic, Provider("MS_NT_DNS_PROVIDER"),
|
|
Locale (0x409), UUID ("{47B8D067-B6EA-11d2-85E5-0000F8102E5F}")
|
|
]
|
|
class MicrosoftDNS_MBType : MicrosoftDNS_ResourceRecord
|
|
{
|
|
[Read: ToSubClass ,
|
|
Description("A Fully Qualified Domain Name which specifies a host "
|
|
"of the mailbox specified in the record's Owner Name."): ToSubClass
|
|
]
|
|
string MBHost;
|
|
[Implemented, static, Description(
|
|
"This method instantiates an 'MB' Type of Resource Record based "
|
|
"on the data in the method's input parameters: the record's DNS "
|
|
"Server Name, Container Name, Owner Name of the mailbox, class "
|
|
"(default = IN), 'time to live' value and the mailbox host. It "
|
|
"returns a reference to the new object as an output parameter."): ToSubClass
|
|
]
|
|
void CreateInstanceFromPropertyData([IN] string DnsServerName,
|
|
[IN] string ContainerName, [IN] string OwnerName,
|
|
[IN, optional, Valuemap {"1", "2", "3", "4"}, Values {"IN (Internet)",
|
|
"CS (CSNET)", "CH (CHAOS)", "HS (Hesiod)"}] uint32 RecordClass = 1,
|
|
[IN, optional] uint32 TTL, [IN] string MBHost,
|
|
[OUT] MicrosoftDNS_MBType ref RR);
|
|
|
|
[Implemented, Description(
|
|
"This method updates the TTL and MB Host to the values specified as "
|
|
"the input parameters of this method. If a new value for some parameter "
|
|
"is not specified, then the current value for this parameter is not "
|
|
"changed. The method returns a reference to the modified object as an "
|
|
"output parameter."): ToSubClass
|
|
|
|
]
|
|
void Modify(
|
|
[IN, optional] uint32 TTL,
|
|
[IN] string MBHost,
|
|
[OUT] MicrosoftDNS_MBType ref RR);
|
|
|
|
};
|
|
|
|
[
|
|
Schema ("MicrosoftDNS"): ToSubClass ,
|
|
Description("A subclass of MicrosoftDNS_ResourceRecord that represents a "
|
|
"Type MD record."): ToSubClass ,
|
|
Dynamic, Provider("MS_NT_DNS_PROVIDER"),
|
|
Locale (0x409), UUID ("{3F655A19-B6EA-11d2-85E5-0000F8102E5F}")
|
|
]
|
|
class MicrosoftDNS_MDType : MicrosoftDNS_ResourceRecord
|
|
{
|
|
[Read: ToSubClass ,
|
|
Description("A Fully Qualified Domain Name which specifies a host "
|
|
"which has a mail agent which should be able to deliver mail for "
|
|
"the specified domain."): ToSubClass
|
|
]
|
|
string MDHost;
|
|
[Implemented, static, Description(
|
|
"This method instantiates an 'MD' Type of Resource Record based "
|
|
"on the data in the method's input parameters: the record's DNS "
|
|
"Server Name, Container Name, Owner Name of the domain, class "
|
|
"(default = IN), 'time to live' value and the host of the mail "
|
|
"agent. It returns a reference to the new object as an output "
|
|
"parameter."): ToSubClass
|
|
]
|
|
void CreateInstanceFromPropertyData([IN] string DnsServerName,
|
|
[IN] string ContainerName, [IN] string OwnerName,
|
|
[IN, optional, Valuemap {"1", "2", "3", "4"}, Values {"IN (Internet)",
|
|
"CS (CSNET)", "CH (CHAOS)", "HS (Hesiod)"}] uint32 RecordClass = 1,
|
|
[IN, optional] uint32 TTL, [IN] string MDHost,
|
|
[OUT] MicrosoftDNS_MDType ref RR);
|
|
|
|
[Implemented, Description(
|
|
"This method updates the TTL and MD Host to the values specified "
|
|
"as the input parameters of this method. If a new value for some "
|
|
"parameter is not specified, then the current value for this "
|
|
"parameter is not changed. The method returns a reference to the "
|
|
"modified object as an output parameter."): ToSubClass
|
|
]
|
|
void Modify(
|
|
[IN, optional] uint32 TTL,
|
|
[IN, optional] string MDHost,
|
|
[OUT] MicrosoftDNS_MDType ref RR);
|
|
};
|
|
|
|
[
|
|
Schema ("MicrosoftDNS"): ToSubClass ,
|
|
Description("A subclass of MicrosoftDNS_ResourceRecord that represents a "
|
|
"Type MF record."): ToSubClass ,
|
|
Dynamic, Provider("MS_NT_DNS_PROVIDER"),
|
|
Locale (0x409), UUID ("{47B8D064-B6EA-11d2-85E5-0000F8102E5F}")
|
|
]
|
|
class MicrosoftDNS_MFType : MicrosoftDNS_ResourceRecord
|
|
{
|
|
[Read: ToSubClass ,
|
|
Description("A Fully Qualified Domain Name which specifies a host "
|
|
"which has a mail agent which will accept mail for forwarding to "
|
|
"the specified domain."): ToSubClass
|
|
]
|
|
string MFHost;
|
|
[Implemented, static, Description(
|
|
"This method instantiates an 'MF' Type of Resource Record based "
|
|
"on the data in the method's input parameters: the record's DNS "
|
|
"Server Name, Container Name, Owner Name of the domain, class "
|
|
"(default = IN), 'time to live' value and the host of the mail "
|
|
"agent. It returns a reference to the new object as an output "
|
|
"parameter."): ToSubClass
|
|
]
|
|
void CreateInstanceFromPropertyData([IN] string DnsServerName,
|
|
[IN] string ContainerName, [IN] string OwnerName,
|
|
[IN, optional, Valuemap {"1", "2", "3", "4"}, Values {"IN (Internet)",
|
|
"CS (CSNET)", "CH (CHAOS)", "HS (Hesiod)"}] uint32 RecordClass = 1,
|
|
[IN, optional] uint32 TTL, [IN] string MFHost,
|
|
[OUT] MicrosoftDNS_MFType ref RR);
|
|
|
|
[Implemented, Description(
|
|
"This method updates the TTL and MF Host to the values specified "
|
|
"as the input parameters of this method. If a new value for some "
|
|
"parameter is not specified, then the current value for this "
|
|
"parameter is not changed. The method returns a reference to the "
|
|
"modified object as an output parameter. "): ToSubClass
|
|
]
|
|
void Modify(
|
|
[IN, optional] uint32 TTL,
|
|
[IN, optional] string MFHost,
|
|
[OUT] MicrosoftDNS_MFType ref RR);
|
|
};
|
|
|
|
[
|
|
Schema ("MicrosoftDNS"): ToSubClass ,
|
|
Description("A subclass of MicrosoftDNS_ResourceRecord that represents a "
|
|
"Type MG record."): ToSubClass ,
|
|
Dynamic, Provider("MS_NT_DNS_PROVIDER"),
|
|
Locale (0x409), UUID ("{4FFDF894-B6EA-11d2-85E5-0000F8102E5F}")
|
|
]
|
|
class MicrosoftDNS_MGType : MicrosoftDNS_ResourceRecord
|
|
{
|
|
[Read: ToSubClass ,
|
|
Description("A Fully Qualified Domain Name which specifies a "
|
|
"mailbox which is a member of the mail group specified by the "
|
|
"record's owner name."): ToSubClass
|
|
]
|
|
string MGMailbox;
|
|
[Implemented, static, Description(
|
|
"This method instantiates an 'MG' Type of Resource Record based "
|
|
"on the data in the method's input parameters: the record's DNS "
|
|
"Server Name, Container Name, Owner Name of the mail group, class "
|
|
"(default = IN), 'time to live' value and the mailbox name. It "
|
|
"returns a reference to the new object as an output parameter."): ToSubClass
|
|
]
|
|
void CreateInstanceFromPropertyData([IN] string DnsServerName,
|
|
[IN] string ContainerName, [IN] string OwnerName,
|
|
[IN, optional, Valuemap {"1", "2", "3", "4"}, Values {"IN (Internet)",
|
|
"CS (CSNET)", "CH (CHAOS)", "HS (Hesiod)"}] uint32 RecordClass = 1,
|
|
[IN, optional] uint32 TTL, [IN] string MGMailbox,
|
|
[OUT] MicrosoftDNS_MGType ref RR);
|
|
|
|
[Implemented, Description(
|
|
"This method updates the TTL and MG Mailbox to the values specified "
|
|
"as the input parameters of this method. If a new value for some "
|
|
"parameter is not specified, then the current value for this parameter "
|
|
"is not changed. The method returns a reference to the modified "
|
|
"object as an output parameter. "): ToSubClass
|
|
|
|
]
|
|
void Modify(
|
|
[IN, optional] uint32 TTL,
|
|
[IN, optional] string MGMailbox,
|
|
[OUT] MicrosoftDNS_MGType ref RR);
|
|
};
|
|
|
|
[
|
|
Schema ("MicrosoftDNS"): ToSubClass ,
|
|
Description("A subclass of MicrosoftDNS_ResourceRecord that represents a "
|
|
"Type MR record."): ToSubClass ,
|
|
Dynamic, Provider("MS_NT_DNS_PROVIDER"),
|
|
Locale (0x409), UUID ("{4FFDF895-B6EA-11d2-85E5-0000F8102E5F}")
|
|
]
|
|
class MicrosoftDNS_MRType : MicrosoftDNS_ResourceRecord
|
|
{
|
|
[Read: ToSubClass ,
|
|
Description("A Fully Qualified Domain Name which specifies a "
|
|
"mailbox which is the proper rename of the mailbox specified "
|
|
"in the record's Owner Name."): ToSubClass
|
|
]
|
|
string MRMailbox;
|
|
[Implemented, static, Description(
|
|
"This method instantiates an 'MR' Type of Resource Record based "
|
|
"on the data in the method's input parameters: the record's DNS "
|
|
"Server Name, Container Name, Owner Name of the mailbox, class "
|
|
"(default = IN), 'time to live' value and the mailbox rename. It "
|
|
"returns a reference to the new object as an output parameter."): ToSubClass
|
|
]
|
|
void CreateInstanceFromPropertyData([IN] string DnsServerName,
|
|
[IN] string ContainerName, [IN] string OwnerName,
|
|
[IN, optional, Valuemap {"1", "2", "3", "4"}, Values {"IN (Internet)",
|
|
"CS (CSNET)", "CH (CHAOS)", "HS (Hesiod)"}] uint32 RecordClass = 1,
|
|
[IN, optional] uint32 TTL, [IN] string MRMailbox,
|
|
[OUT] MicrosoftDNS_MRType ref RR);
|
|
|
|
[Implemented, Description(
|
|
"This method updates the TTL and MR Mailbox to the values "
|
|
"specified as the input parameters of this method. If a new value "
|
|
"for some parameter is not specified, then the current value for "
|
|
"this parameter is not changed. The method returns a reference to the "
|
|
"modified object as an output parameter."): ToSubClass
|
|
|
|
]
|
|
void Modify(
|
|
[IN, optional] uint32 TTL,
|
|
[IN] string MRMailbox,
|
|
[OUT] MicrosoftDNS_MRType ref RR);
|
|
};
|
|
|
|
[
|
|
Schema ("MicrosoftDNS"): ToSubClass ,
|
|
Description("A subclass of MicrosoftDNS_ResourceRecord that represents a "
|
|
"Type MINFO record."): ToSubClass ,
|
|
Dynamic, Provider("MS_NT_DNS_PROVIDER"),
|
|
Locale (0x409), UUID ("{5CA876B4-B6EA-11d2-85E5-0000F8102E5F}")
|
|
]
|
|
class MicrosoftDNS_MINFOType : MicrosoftDNS_ResourceRecord
|
|
{
|
|
[Read: ToSubClass ,
|
|
Description("A Fully Qualified Domain Name which specifies a "
|
|
"mailbox which is responsible for the mailing list or mailbox "
|
|
"specified in the record's Owner Name."): ToSubClass
|
|
]
|
|
string ResponsibleMailbox;
|
|
[Read: ToSubClass ,
|
|
Description("A Fully Qualified Domain Name which specifies a "
|
|
"mailbox which is to receive error messages related to the mailing "
|
|
"list or mailbox specified by the owner name of the MINFO record."):
|
|
ToSubClass
|
|
]
|
|
string ErrorMailbox;
|
|
[Implemented, static, Description(
|
|
"This method instantiates an 'MINFO' Type of Resource Record based "
|
|
"on the data in the method's input parameters: the record's DNS "
|
|
"Server Name, Container Name, Owner Name of the mail list/box, "
|
|
"class (default = IN), 'time to live' value and the responsible "
|
|
"and error mailboxes. It returns a reference to the new object "
|
|
"as an output parameter."):
|
|
ToSubClass
|
|
]
|
|
void CreateInstanceFromPropertyData([IN] string DnsServerName,
|
|
[IN] string ContainerName, [IN] string OwnerName,
|
|
[IN, optional, Valuemap {"1", "2", "3", "4"}, Values {"IN (Internet)",
|
|
"CS (CSNET)", "CH (CHAOS)", "HS (Hesiod)"}] uint32 RecordClass = 1,
|
|
[IN, optional] uint32 TTL, [IN] string ResponsibleMailbox,
|
|
[IN] string ErrorMailbox, [OUT] MicrosoftDNS_MINFOType ref RR);
|
|
|
|
[Implemented, Description(
|
|
"This method updates the TTL, Responsible Mailbox and Error Mailbox "
|
|
"to the values specified as the input parameters of this method. If "
|
|
"a new value for some parameter is not specified, then the current "
|
|
"value for this parameter is not changed. The method returns a "
|
|
"reference to the modified object as an output parameter."): ToSubClass
|
|
|
|
]
|
|
void modify(
|
|
[IN, optional] uint32 TTL,
|
|
[IN, optional] string ResponsibleMailbox,
|
|
[IN, optional] string ErrorMailbox,
|
|
[OUT] MicrosoftDNS_MINFOType ref RR);
|
|
};
|
|
|
|
[
|
|
Schema ("MicrosoftDNS"): ToSubClass ,
|
|
Description("A subclass of MicrosoftDNS_ResourceRecord that represents a "
|
|
"Type RP record."): ToSubClass ,
|
|
Dynamic, Provider("MS_NT_DNS_PROVIDER"),
|
|
Locale (0x409), UUID ("{835AC174-B6EA-11d2-85E5-0000F8102E5F}")
|
|
]
|
|
class MicrosoftDNS_RPType : MicrosoftDNS_ResourceRecord
|
|
{
|
|
[Read: ToSubClass ,
|
|
Description("A Fully Qualified Domain Name that specifies the "
|
|
"mailbox for the responsible person."): ToSubClass
|
|
]
|
|
string RPMailbox;
|
|
[Read: ToSubClass ,
|
|
Description("A Fully Qualified Domain Name for which TXT RR's "
|
|
"exist."): ToSubClass
|
|
]
|
|
string TXTDomainName;
|
|
[Implemented, static, Description(
|
|
"This method instantiates an 'RP' Type of Resource Record based "
|
|
"on the data in the method's input parameters: the record's DNS "
|
|
"Server Name, Container Name, Owner/responsible person Name, "
|
|
"class (default = IN), 'time to live' value and the domain names "
|
|
"for the person's mailbox and TXT RR locations. It returns a "
|
|
"reference to the new object as an output parameter."):
|
|
ToSubClass
|
|
]
|
|
void CreateInstanceFromPropertyData([IN] string DnsServerName,
|
|
[IN] string ContainerName, [IN] string OwnerName,
|
|
[IN, optional, Valuemap {"1", "2", "3", "4"}, Values {"IN (Internet)",
|
|
"CS (CSNET)", "CH (CHAOS)", "HS (Hesiod)"}] uint32 RecordClass = 1,
|
|
[IN, optional] uint32 TTL, [IN] string RPMailbox,
|
|
[IN] string TXTDomainName, [OUT] MicrosoftDNS_RPType ref RR);
|
|
|
|
[Implemented, Description(
|
|
"This method updates the TTL, RP Mailbox and TXT Domain Name to the "
|
|
"values specified as the input parameters of this method. If a new "
|
|
"value for some parameter is not specified, then the current value "
|
|
"for this parameter is not changed. The method returns a reference "
|
|
"to the modified object as an output parameter."): ToSubClass
|
|
|
|
]
|
|
void modify(
|
|
[IN, optional] uint32 TTL,
|
|
[IN, optional] string RPMailbox,
|
|
[IN, optional] string TXTDomainName,
|
|
[OUT] MicrosoftDNS_RPType ref RR);
|
|
};
|
|
|
|
[
|
|
Schema ("MicrosoftDNS"): ToSubClass ,
|
|
Description("A subclass of MicrosoftDNS_ResourceRecord that represents a "
|
|
"Type MX record."): ToSubClass ,
|
|
Dynamic, Provider("MS_NT_DNS_PROVIDER"),
|
|
Locale (0x409), UUID ("{835AC172-B6EA-11d2-85E5-0000F8102E5F}")
|
|
]
|
|
class MicrosoftDNS_MXType : MicrosoftDNS_ResourceRecord
|
|
{
|
|
[Read: ToSubClass ,
|
|
Description("The preference given to this RR among others "
|
|
"at the same owner. Lower values are preferred."): ToSubClass
|
|
]
|
|
uint16 Preference;
|
|
|
|
[Read: ToSubClass ,
|
|
Description("A Fully Qualified Domain Name which specifies a host "
|
|
"willing to act as a mail exchange for the owner name."): ToSubClass
|
|
]
|
|
string MailExchange;
|
|
|
|
[Implemented, static, Description(
|
|
"This method instantiates an 'MX' Type of Resource Record based "
|
|
"on the data in the method's input parameters: the record's DNS "
|
|
"Server Name, Container Name, Owner Name, class (default = IN), "
|
|
"'time to live' value, record preference and host name willing "
|
|
"to be a mail exchange. It returns a reference to the new "
|
|
"object as an output parameter."):
|
|
ToSubClass
|
|
]
|
|
void CreateInstanceFromPropertyData([IN] string DnsServerName,
|
|
[IN] string ContainerName, [IN] string OwnerName,
|
|
[IN, optional, Valuemap {"1", "2", "3", "4"}, Values {"IN (Internet)",
|
|
"CS (CSNET)", "CH (CHAOS)", "HS (Hesiod)"}] uint32 RecordClass = 1,
|
|
[IN, optional] uint32 TTL, [IN] uint16 Preference,
|
|
[IN] string MailExchange, [OUT] MicrosoftDNS_MXType ref RR);
|
|
|
|
[Implemented, Description(
|
|
"This method updates the TTL, Preference and Mail Exchange to the "
|
|
"values specified as the input parameters of this method. If a new "
|
|
"value for some parameter is not specified, then the current value "
|
|
"for this parameter is not changed. The method returns a reference "
|
|
"to the modified object as an output parameter."): ToSubClass
|
|
]
|
|
void modify(
|
|
[IN, optional] uint32 TTL,
|
|
[IN, optional] uint16 Preference,
|
|
[IN, optional] string MailExchange,
|
|
[OUT] MicrosoftDNS_MXType ref RR);
|
|
};
|
|
|
|
[
|
|
Schema ("MicrosoftDNS"): ToSubClass ,
|
|
Description("A subclass of MicrosoftDNS_ResourceRecord that represents a "
|
|
"Type AFSDB record."): ToSubClass ,
|
|
Dynamic, Provider("MS_NT_DNS_PROVIDER"),
|
|
Locale (0x409), UUID ("{8AEF7B9E-B6EA-11d2-85E5-0000F8102E5F}")
|
|
]
|
|
class MicrosoftDNS_AFSDBType : MicrosoftDNS_ResourceRecord
|
|
{
|
|
[Read: ToSubClass ,
|
|
Description("Subtype of the host AFS server. For subtype 1, "
|
|
"the host has an AFS version 3.0 Volume Location Server for "
|
|
"the named AFS cell. In the case of subtype 2, the host has "
|
|
"an authenticated name server holding the cell-root directory "
|
|
"node for the named DCE/NCA cell."): ToSubClass,
|
|
ValueMap {"1", "2"}: ToSubClass
|
|
]
|
|
uint16 Subtype;
|
|
[Read: ToSubClass ,
|
|
Description("A Fully Qualified Domain Name which specifies a host "
|
|
"that has a server for the AFS cell specified in owner name."):
|
|
ToSubClass
|
|
]
|
|
string ServerName;
|
|
[Implemented, static, Description(
|
|
"This method instantiates an 'AFSDB' Type of Resource Record based "
|
|
"on the data in the method's input parameters: the record's DNS "
|
|
"Server Name, Container Name, Owner/cell Name, class (default = "
|
|
"IN), 'time to live' value, and host AFS server subtype and name. "
|
|
"It returns a reference to the new object as an output parameter."
|
|
): ToSubClass
|
|
]
|
|
void CreateInstanceFromPropertyData([IN] string DnsServerName,
|
|
[IN] string ContainerName, [IN] string OwnerName,
|
|
[IN, optional, Valuemap {"1", "2", "3", "4"}, Values {"IN (Internet)",
|
|
"CS (CSNET)", "CH (CHAOS)", "HS (Hesiod)"}] uint32 RecordClass = 1,
|
|
[IN, optional] uint32 TTL, [IN] uint16 Subtype, [IN] string ServerName,
|
|
[OUT] MicrosoftDNS_AFSDBType ref RR);
|
|
|
|
[Implemented, Description(
|
|
"This method updates the TTL, Subtype and Server Name to the values "
|
|
"specified as the input parameters of this method. If a new value "
|
|
"for some parameter is not specified, then the current value for this "
|
|
"parameter is not changed. The method returns a reference to the "
|
|
"modified object as an output parameter."): ToSubClass
|
|
|
|
]
|
|
void modify(
|
|
[IN, optional] uint32 TTL,
|
|
[IN, optional] uint16 Subtype,
|
|
[IN, optional] string ServerName,
|
|
[OUT] MicrosoftDNS_AFSDBType ref RR);
|
|
};
|
|
|
|
[
|
|
Schema ("MicrosoftDNS"): ToSubClass ,
|
|
Description("A subclass of MicrosoftDNS_ResourceRecord that represents a "
|
|
"Type RT record."): ToSubClass ,
|
|
Dynamic, Provider("MS_NT_DNS_PROVIDER"),
|
|
Locale (0x409), UUID ("{913D93A0-B6EA-11d2-85E5-0000F8102E5F}")
|
|
]
|
|
class MicrosoftDNS_RTType : MicrosoftDNS_ResourceRecord
|
|
{
|
|
[Read: ToSubClass ,
|
|
Description("The preference given to this RR among others "
|
|
"at the same owner. Lower values are preferred."): ToSubClass
|
|
]
|
|
uint16 Preference;
|
|
[Read: ToSubClass ,
|
|
Description("A Fully Qualified Domain Name which specifies a host "
|
|
"which will serve as an intermediate in reaching the host "
|
|
"specified by owner."): ToSubClass
|
|
]
|
|
string IntermediateHost;
|
|
[Implemented, static, Description(
|
|
"This method instantiates an 'RT' Type of Resource Record based "
|
|
"on the data in the method's input parameters: the record's DNS "
|
|
"Server Name, Container Name, Owner/host Name, class (default = "
|
|
"IN), 'time to live' value, record preference and intermediate "
|
|
"host name. It returns a reference to the new object as an output "
|
|
"parameter."): ToSubClass
|
|
]
|
|
void CreateInstanceFromPropertyData([IN] string DnsServerName,
|
|
[IN] string ContainerName, [IN] string OwnerName,
|
|
[IN, optional, Valuemap {"1", "2", "3", "4"}, Values {"IN (Internet)",
|
|
"CS (CSNET)", "CH (CHAOS)", "HS (Hesiod)"}] uint32 RecordClass = 1,
|
|
[IN, optional] uint32 TTL, [IN] uint16 Preference,
|
|
[IN] string IntermediateHost, [OUT] MicrosoftDNS_RTType ref RR);
|
|
|
|
[Implemented, Description(
|
|
"This method updates the TTL, Preference and Intermediate Host to "
|
|
"the values specified as the input parameters of this method. If a "
|
|
"new value for some parameter is not specified, then the current "
|
|
"value for this parameter is not changed. The method returns a "
|
|
"reference to the modified object as an output parameter."): ToSubClass
|
|
|
|
]
|
|
void modify(
|
|
[IN, optional] uint32 TTL,
|
|
[IN, optional] uint16 Preference,
|
|
[IN, optional] string IntermediateHost,
|
|
[OUT] MicrosoftDNS_RTType ref RR);
|
|
};
|
|
|
|
[
|
|
Schema ("MicrosoftDNS"): ToSubClass ,
|
|
Description("A subclass of MicrosoftDNS_ResourceRecord that represents a "
|
|
"Type HINFO record."): ToSubClass ,
|
|
Dynamic, Provider("MS_NT_DNS_PROVIDER"),
|
|
Locale (0x409), UUID ("{567E21FA-B6EA-11d2-85E5-0000F8102E5F}")
|
|
]
|
|
class MicrosoftDNS_HINFOType : MicrosoftDNS_ResourceRecord
|
|
{
|
|
[Read: ToSubClass ,
|
|
Description("The CPU type of the owner of the record."):
|
|
ToSubClass
|
|
]
|
|
string CPU;
|
|
[Read: ToSubClass ,
|
|
Description("The operating system type of the owner."): ToSubClass
|
|
]
|
|
string OS;
|
|
[Implemented, static, Description(
|
|
"This method instantiates an 'HINFO' Type of Resource Record based "
|
|
"on the data in the method's input parameters: the record's DNS "
|
|
"Server Name, Container Name, Owner Name, class (default = IN), "
|
|
"'time to live' value, and the host's CPU and OS types. It returns "
|
|
"a reference to the new object as an output parameter."
|
|
): ToSubClass
|
|
]
|
|
void CreateInstanceFromPropertyData([IN] string DnsServerName,
|
|
[IN] string ContainerName, [IN] string OwnerName,
|
|
[IN, optional, Valuemap {"1", "2", "3", "4"}, Values {"IN (Internet)",
|
|
"CS (CSNET)", "CH (CHAOS)", "HS (Hesiod)"}] uint32 RecordClass = 1,
|
|
[IN, optional] uint32 TTL, [IN] string CPU, [IN] string OS,
|
|
[OUT] MicrosoftDNS_HINFOType ref RR);
|
|
|
|
[Implemented, Description(
|
|
"This method updates the TTL, CPU and OS to the values specified as "
|
|
"the input parameters of this method. If a new value for some "
|
|
"parameter is not specified, then the current value for this parameter "
|
|
"is not changed. The method returns a reference to the modified object "
|
|
"as an output parameter."): ToSubClass
|
|
|
|
]
|
|
void modify(
|
|
[IN, optional] uint32 TTL,
|
|
[IN, optional] string CPU,
|
|
[IN, optional] string OS,
|
|
[OUT] MicrosoftDNS_HINFOType ref RR);
|
|
};
|
|
|
|
[
|
|
Schema ("MicrosoftDNS"): ToSubClass ,
|
|
Description("A subclass of MicrosoftDNS_ResourceRecord that represents a "
|
|
"Type ISDN record."): ToSubClass ,
|
|
Dynamic, Provider("MS_NT_DNS_PROVIDER"),
|
|
Locale (0x409), UUID ("{8AEF7BA0-B6EA-11d2-85E5-0000F8102E5F}")
|
|
]
|
|
class MicrosoftDNS_ISDNType : MicrosoftDNS_ResourceRecord
|
|
{
|
|
[Read: ToSubClass ,
|
|
Description("The ISDN number and DDI of the record's owner."):
|
|
ToSubClass
|
|
]
|
|
string ISDNNumber;
|
|
[Read: ToSubClass ,
|
|
Description("The subaddress of the owner, if defined."): ToSubClass
|
|
]
|
|
string SubAddress;
|
|
[Implemented, static, Description(
|
|
"This method instantiates an 'ISDN' Type of Resource Record based "
|
|
"on the data in the method's input parameters: the record's DNS "
|
|
"Server Name, Container Name, Owner Name, class (default = IN), "
|
|
"'time to live' value, and the ISDN number and subaddress of the "
|
|
"owner. It returns a reference to the new object as an output "
|
|
"parameter."): ToSubClass
|
|
]
|
|
void CreateInstanceFromPropertyData([IN] string DnsServerName,
|
|
[IN] string ContainerName, [IN] string OwnerName,
|
|
[IN, optional, Valuemap {"1", "2", "3", "4"}, Values {"IN (Internet)",
|
|
"CS (CSNET)", "CH (CHAOS)", "HS (Hesiod)"}] uint32 RecordClass = 1,
|
|
[IN, optional] uint32 TTL, [IN] string ISDNNumber, [IN] string SubAddress,
|
|
[OUT] MicrosoftDNS_ISDNType ref RR);
|
|
|
|
[Implemented, Description(
|
|
"This method updates the TTL, ISDN Number and SubAddress to the values "
|
|
"specified as the input parameters of this method. If a new value for "
|
|
"some parameter is not specified, then the current value for this "
|
|
"parameter is not changed. The method returns a reference to the "
|
|
"modified object as an output parameter."): ToSubClass
|
|
|
|
]
|
|
void modify(
|
|
[IN, optional] uint32 TTL,
|
|
[IN, optional] string ISDNNumber,
|
|
[IN, optional] string SubAddress,
|
|
[OUT] MicrosoftDNS_ISDNType ref RR);
|
|
};
|
|
|
|
[
|
|
Schema ("MicrosoftDNS"): ToSubClass ,
|
|
Description("A subclass of MicrosoftDNS_ResourceRecord that represents a "
|
|
"Type TXT record."): ToSubClass ,
|
|
Dynamic, Provider("MS_NT_DNS_PROVIDER"),
|
|
Locale (0x409), UUID ("{835AC173-B6EA-11d2-85E5-0000F8102E5F}")
|
|
]
|
|
class MicrosoftDNS_TXTType : MicrosoftDNS_ResourceRecord
|
|
{
|
|
[Read: ToSubClass ,
|
|
Description("Descriptive text whose semantics depend on the owner "
|
|
"domain."): ToSubClass
|
|
]
|
|
string DescriptiveText;
|
|
[Implemented, static, Description(
|
|
"This method instantiates a 'TXT' Type of Resource Record based "
|
|
"on the data in the method's input parameters: the record's DNS "
|
|
"Server Name, Container Name, Owner Name, class (default = IN), "
|
|
"'time to live' value, and the record's text. It returns a "
|
|
"reference to the new object as an output parameter."): ToSubClass
|
|
]
|
|
void CreateInstanceFromPropertyData([IN] string DnsServerName,
|
|
[IN] string ContainerName, [IN] string OwnerName,
|
|
[IN, optional, Valuemap {"1", "2", "3", "4"}, Values {"IN (Internet)",
|
|
"CS (CSNET)", "CH (CHAOS)", "HS (Hesiod)"}] uint32 RecordClass = 1,
|
|
[IN, optional] uint32 TTL, [IN] string DescriptiveText,
|
|
[OUT] MicrosoftDNS_TXTType ref RR);
|
|
|
|
[Implemented, Description(
|
|
"This method updates the TTL and Descriptive Text to the values "
|
|
"specified as the input parameters of this method. If a new value for "
|
|
"some parameter is not specified, then the current value for this "
|
|
"parameter is not changed. The method returns a reference to the "
|
|
"modified object as an output parameter."): ToSubClass
|
|
|
|
]
|
|
void modify(
|
|
[IN, optional] uint32 TTL,
|
|
[IN] string DescriptiveText,
|
|
[OUT] MicrosoftDNS_TXTType ref RR);
|
|
};
|
|
|
|
[
|
|
Schema ("MicrosoftDNS"): ToSubClass ,
|
|
Description("A subclass of MicrosoftDNS_ResourceRecord that represents a "
|
|
"Type X25 record."): ToSubClass ,
|
|
Dynamic, Provider("MS_NT_DNS_PROVIDER"),
|
|
Locale (0x409), UUID ("{8AEF7B9F-B6EA-11d2-85E5-0000F8102E5F}")
|
|
]
|
|
class MicrosoftDNS_X25Type : MicrosoftDNS_ResourceRecord
|
|
{
|
|
[Read: ToSubClass ,
|
|
Description("PSDN address of the record's owner."): ToSubClass
|
|
]
|
|
string PSDNAddress;
|
|
[Implemented, static, Description(
|
|
"This method instantiates an 'X25' Type of Resource Record based "
|
|
"on the data in the method's input parameters: the record's DNS "
|
|
"Server Name, Container Name, Owner Name, class (default = IN), "
|
|
"'time to live' value, and the PSDN address. It returns a "
|
|
"reference to the new object as an output parameter."): ToSubClass
|
|
]
|
|
void CreateInstanceFromPropertyData([IN] string DnsServerName,
|
|
[IN] string ContainerName, [IN] string OwnerName,
|
|
[IN, optional, Valuemap {"1", "2", "3", "4"}, Values {"IN (Internet)",
|
|
"CS (CSNET)", "CH (CHAOS)", "HS (Hesiod)"}] uint32 RecordClass = 1,
|
|
[IN, optional] uint32 TTL, [IN] string PSDNAddress,
|
|
[OUT] MicrosoftDNS_X25Type ref RR);
|
|
|
|
[Implemented, Description(
|
|
"This method updates the TTL and PSDN Address to the values "
|
|
"specified as the input parameters of this method. If a new value for "
|
|
"some parameter is not specified, then the current value for this "
|
|
"parameter is not changed. The method returns a reference to the "
|
|
"modified object as an output parameter."): ToSubClass
|
|
|
|
]
|
|
void modify(
|
|
[IN, optional] uint32 TTL,
|
|
[IN, optional] string PSDNAddress,
|
|
[OUT] MicrosoftDNS_X25Type ref RR);
|
|
};
|
|
|
|
[
|
|
Schema ("MicrosoftDNS"): ToSubClass ,
|
|
Description("A subclass of MicrosoftDNS_ResourceRecord that represents a "
|
|
"Type WKS record."): ToSubClass ,
|
|
Dynamic, Provider("MS_NT_DNS_PROVIDER"),
|
|
Locale (0x409), UUID ("{567E21F8-B6EA-11d2-85E5-0000F8102E5F}")
|
|
]
|
|
class MicrosoftDNS_WKSType : MicrosoftDNS_ResourceRecord
|
|
{
|
|
[Read: ToSubClass ,
|
|
Description("A 32 bit Internet address for the record's owner."):
|
|
ToSubClass
|
|
]
|
|
string InternetAddress;
|
|
[Read: ToSubClass ,
|
|
Description("A string representing the IP protocol for this record. Values "
|
|
"included 'udp' or 'tcp'."): ToSubClass
|
|
]
|
|
string IPProtocol;
|
|
[Read: ToSubClass ,
|
|
Description("A string that contains all the services used by the "
|
|
"Well Known Service (WKS) record."): ToSubClass
|
|
]
|
|
string Services;
|
|
[Implemented, static, Description(
|
|
"This method instantiates a 'WKS' Type of Resource Record based "
|
|
"on the data in the method's input parameters: the record's DNS "
|
|
"Server Name, Container Name, Owner Name, class (default = IN), "
|
|
"'time to live' value, and the owner's Internet Address, IP "
|
|
"protocol and port bit mask. It returns a reference to the new "
|
|
"object as an output parameter."):
|
|
ToSubClass
|
|
]
|
|
void CreateInstanceFromPropertyData([IN] string DnsServerName,
|
|
[IN] string ContainerName,
|
|
[IN] string OwnerName,
|
|
[IN, optional, Valuemap {"1", "2", "3", "4"}, Values {"IN (Internet)",
|
|
"CS (CSNET)", "CH (CHAOS)", "HS (Hesiod)"}] uint32 RecordClass = 1,
|
|
[IN, optional] uint32 TTL,
|
|
[IN] string InternetAddress,
|
|
[IN] string IPProtocol,
|
|
[IN] string Services,
|
|
[OUT] MicrosoftDNS_WKSType ref RR);
|
|
|
|
[Implemented, Description(
|
|
"This method updates the TTL, Internet Address, IP Protocol and Services"
|
|
"to the values specified as the input parameters of this method. If a new "
|
|
"value for some parameter is not specified, then the current value for "
|
|
"this parameter is not changed. The method returns a reference to the "
|
|
"modified object as an output parameter."): ToSubClass
|
|
|
|
]
|
|
void modify(
|
|
[IN, optional] uint32 TTL,
|
|
[IN, optional] uint32 InternetAddress,
|
|
[IN, optional] uint8 IPProtocol,
|
|
[IN, optional] uint8 Services,
|
|
[OUT] MicrosoftDNS_WKSType ref RR);
|
|
};
|
|
|
|
[
|
|
Schema ("MicrosoftDNS"): ToSubClass ,
|
|
Description("A subclass of MicrosoftDNS_ResourceRecord that represents a "
|
|
"Type AAAA record."): ToSubClass ,
|
|
Dynamic, Provider("MS_NT_DNS_PROVIDER"),
|
|
Locale (0x409), UUID ("{913D93A1-B6EA-11d2-85E5-0000F8102E5F}")
|
|
]
|
|
class MicrosoftDNS_AAAAType : MicrosoftDNS_ResourceRecord
|
|
{
|
|
[Read: ToSubClass ,
|
|
Description("The AAAA address for a IPv6 host."): ToSubClass
|
|
]
|
|
string IPv6Address;
|
|
[Implemented, static, Description(
|
|
"This method instantiates an 'AAAA' Type of Resource Record based "
|
|
"on the data in the method's input parameters: the record's DNS "
|
|
"Server Name, Container Name, Owner/host Name, class (default = "
|
|
"IN), 'time to live' value, and the IPv6 address. It returns a "
|
|
"reference to the new object as an output parameter.")
|
|
: ToSubClass
|
|
]
|
|
void CreateInstanceFromPropertyData([IN] string DnsServerName,
|
|
[IN] string ContainerName, [IN] string OwnerName,
|
|
[IN, optional, Valuemap {"1", "2", "3", "4"}, Values {"IN (Internet)",
|
|
"CS (CSNET)", "CH (CHAOS)", "HS (Hesiod)"}] uint32 RecordClass = 1,
|
|
[IN, optional] uint32 TTL, [IN] string IPv6Address,
|
|
[OUT] MicrosoftDNS_AAAAType ref RR);
|
|
|
|
[Implemented, Description(
|
|
"This method updates the TTL and IPv6 Address to the values "
|
|
"specified as the input parameters of this method. If a new value for "
|
|
"some parameter is not specified, then the current value for this "
|
|
"parameter is not changed. The method returns a reference to the "
|
|
"modified object as an output parameter."): ToSubClass
|
|
|
|
]
|
|
void modify(
|
|
[IN, optional] uint32 TTL,
|
|
[IN, optional] string IPv6Address,
|
|
[OUT] MicrosoftDNS_AAAAType ref RR);
|
|
};
|
|
|
|
[
|
|
Schema ("MicrosoftDNS"): ToSubClass ,
|
|
Description("A subclass of MicrosoftDNS_ResourceRecord that represents a "
|
|
"Type SRV record."): ToSubClass ,
|
|
Dynamic, Provider("MS_NT_DNS_PROVIDER"),
|
|
Locale (0x409), UUID ("{A9A68712-B6EA-11d2-85E5-0000F8102E5F}")
|
|
]
|
|
class MicrosoftDNS_SRVType : MicrosoftDNS_ResourceRecord
|
|
{
|
|
[Read: ToSubClass ,
|
|
Description("A priority of the target host specified in owner "
|
|
"name. Lower numbers imply higher priorities."): ToSubClass
|
|
]
|
|
uint16 Priority;
|
|
[Read: ToSubClass ,
|
|
Description("A weight of the target host. This is useful when "
|
|
"selecting among hosts that have the same priority. The chances "
|
|
"of using this host should be proportional to its weight."):
|
|
ToSubClass
|
|
]
|
|
uint16 Weight;
|
|
[Read: ToSubClass ,
|
|
Description("A port on the target host of a protocol service."):
|
|
ToSubClass
|
|
]
|
|
uint16 Port;
|
|
[Read: ToSubClass ,
|
|
Description("A Fully Qualified Domain Name of the target host. A "
|
|
"target of \".\" means that the service is decidedly not available "
|
|
"at this domain."): ToSubClass
|
|
]
|
|
string DomainName;
|
|
[Implemented, static, Description(
|
|
"This method instantiates an 'SRV' Type of Resource Record based "
|
|
"on the data in the method's input parameters: the record's DNS "
|
|
"Server Name, Container Name, Owner/target Name, class (default = "
|
|
"IN), 'time to live' value, and target host's priority, weight, "
|
|
"port and domain name. It returns a reference to the new object "
|
|
"as an output parameter."): ToSubClass
|
|
]
|
|
void CreateInstanceFromPropertyData([IN] string DnsServerName,
|
|
[IN] string ContainerName, [IN] string OwnerName,
|
|
[IN, optional, Valuemap {"1", "2", "3", "4"}, Values {"IN (Internet)",
|
|
"CS (CSNET)", "CH (CHAOS)", "HS (Hesiod)"}] uint32 RecordClass = 1,
|
|
[IN, optional] uint32 TTL, [IN] uint16 Priority, [IN] uint16 Weight,
|
|
[IN] uint16 Port, [IN] string DomainName, [OUT] MicrosoftDNS_SRVType ref RR);
|
|
|
|
[Implemented, Description(
|
|
"This method updates the TTL, Priority, Weight, Port, and Domain Name "
|
|
"to the values specified as the input parameters of this method. If a new "
|
|
"value for some parameter is not specified, then the current value for "
|
|
"this parameter is not changed. The method returns a reference to the "
|
|
"modified object as an output parameter."): ToSubClass
|
|
|
|
]
|
|
void modify(
|
|
[IN, optional] uint32 TTL,
|
|
[IN, optional] uint16 Priority,
|
|
[IN, optional] uint16 Weight,
|
|
[IN, optional] uint16 Port,
|
|
[IN, optional] string DomainName,
|
|
[OUT] MicrosoftDNS_SRVType ref RR);
|
|
};
|
|
|
|
[
|
|
Schema ("MicrosoftDNS"): ToSubClass ,
|
|
Description("A subclass of MicrosoftDNS_ResourceRecord that represents a "
|
|
"Type ATMA record."): ToSubClass ,
|
|
Dynamic, Provider("MS_NT_DNS_PROVIDER"),
|
|
Locale (0x409), UUID ("{A9A68713-B6EA-11d2-85E5-0000F8102E5F}")
|
|
]
|
|
class MicrosoftDNS_ATMAType : MicrosoftDNS_ResourceRecord
|
|
{
|
|
[Read: ToSubClass ,
|
|
Description("The ATM address format. Two possible values "
|
|
"for FORMAT are: 0 indicating ATM End System Address (AESA) "
|
|
"format and 1 indicating E.164 format."): ToSubClass,
|
|
Values {"AESA", "E.164"}: ToSubClass
|
|
]
|
|
uint16 Format;
|
|
[Read: ToSubClass ,
|
|
Description("A variable length string of octets containing the "
|
|
"ATM address of the node/owner to which this RR pertains. The "
|
|
"first four bytes of the array are used to store the size of the "
|
|
"octet string. The most significant byte is stored in byte 0."):
|
|
ToSubClass
|
|
]
|
|
string ATMAddress;
|
|
[Implemented, static, Description(
|
|
"This method instantiates an 'ATMA' Type of Resource Record based "
|
|
"on the data in the method's input parameters: the record's DNS "
|
|
"Server Name, Container Name, Owner/node Name, class (default = "
|
|
"IN), 'time to live' value, and ATM format and address. It returns "
|
|
"a reference to the new object as an output parameter."): ToSubClass
|
|
]
|
|
void CreateInstanceFromPropertyData([IN] string DnsServerName,
|
|
[IN] string ContainerName, [IN] string OwnerName,
|
|
[IN, optional, Valuemap {"1", "2", "3", "4"}, Values {"IN (Internet)",
|
|
"CS (CSNET)", "CH (CHAOS)", "HS (Hesiod)"}] uint32 RecordClass = 1,
|
|
[IN, optional] uint32 TTL,
|
|
[IN] uint16 Format,
|
|
[IN] string ATMAddress,
|
|
[OUT] MicrosoftDNS_ATMAType ref RR);
|
|
|
|
[Implemented, Description(
|
|
"This method updates the TTL, Format and ATMA Address to the values "
|
|
"specified as the input parameters of this method. If a new value for "
|
|
"some parameter is not specified, then the current value for this "
|
|
"parameter is not changed. The method returns a reference to the "
|
|
"modified object as an output parameter."): ToSubClass
|
|
]
|
|
void modify(
|
|
[IN, optional] uint32 TTL,
|
|
[IN, optional] uint16 Format,
|
|
[IN, optional] string ATMAddress,
|
|
[OUT] MicrosoftDNS_ATMAType ref RR);
|
|
};
|
|
|
|
[
|
|
Schema ("MicrosoftDNS"): ToSubClass ,
|
|
Description("A subclass of MicrosoftDNS_ResourceRecord that represents a "
|
|
"Type WINS record."): ToSubClass ,
|
|
Dynamic, Provider("MS_NT_DNS_PROVIDER"),
|
|
Locale (0x409), UUID ("{A9A68714-B6EA-11d2-85E5-0000F8102E5F}")
|
|
]
|
|
class MicrosoftDNS_WINSType : MicrosoftDNS_ResourceRecord
|
|
{
|
|
[Read: ToSubClass ,
|
|
Description("A WINS mapping flag that specifies whether the record "
|
|
"must be included into the zone replication. It may have only two "
|
|
"values: 0x80000000 and 0x00010000 corresponding to the replication "
|
|
"and no-replication (local record) flags, respectively."): ToSubClass,
|
|
ValueMap {"0x80000000", "0x00010000"}: ToSubClass
|
|
|
|
]
|
|
uint32 MappingFlag;
|
|
[Read: ToSubClass ,
|
|
Description("How long (in seconds) a DNS server, using WINS Lookup, "
|
|
"waits before giving up."): ToSubClass ,
|
|
Units ("Seconds"): ToSubClass
|
|
]
|
|
uint32 LookupTimeout;
|
|
[Read: ToSubClass ,
|
|
Description("How long (in seconds) a DNS server, using WINS Lookup, "
|
|
"may cache the WINS server's response."): ToSubClass ,
|
|
Units ("Seconds"): ToSubClass
|
|
]
|
|
uint32 CacheTimeout;
|
|
[Read: ToSubClass ,
|
|
Description("A comma separated list of IP addresses of WINS servers "
|
|
"to be addressed in a WINS Lookups."): ToSubClass
|
|
]
|
|
string WinsServers;
|
|
[Implemented, static, Description(
|
|
"This method instantiates a 'WINS' Type of Resource Record based "
|
|
"on the data in the method's input parameters: the record's DNS "
|
|
"Server Name, Container Name, Owner Name, class (default = "
|
|
"IN), 'time to live' value, and WINS mapping flag, lookup timeout, "
|
|
"cache timeout and list of IP addresses for lookup. It returns "
|
|
"a reference to the new object as an output parameter."): ToSubClass
|
|
]
|
|
void CreateInstanceFromPropertyData([IN] string DnsServerName,
|
|
[IN] string ContainerName, [IN] string OwnerName,
|
|
[IN, optional, Valuemap {"1", "2", "3", "4"}, Values {"IN (Internet)",
|
|
"CS (CSNET)", "CH (CHAOS)", "HS (Hesiod)"}] uint32 RecordClass = 1,
|
|
[IN, optional] uint32 TTL,
|
|
[IN] uint32 MappingFlag,
|
|
[IN] uint32 LookupTimeout,
|
|
[IN] uint32 CacheTimeout,
|
|
[IN] string WinsServers,
|
|
[OUT] MicrosoftDNS_WINSType ref RR);
|
|
|
|
[Implemented, Description(
|
|
"This method updates the TTL, Mapping Flag, Lookup Timeout, Cache Timeout "
|
|
"and Wins Servers to the values specified as the input parameters of this "
|
|
"method. If a new value for some parameter is not specified, then the "
|
|
"current value for this parameter is not changed. The method returns a "
|
|
"reference to the modified object as an output parameter."): ToSubClass
|
|
]
|
|
void modify(
|
|
[IN, optional] uint32 TTL,
|
|
[IN, optional] uint32 MappingFlag,
|
|
[IN, optional] uint32 LookupTimeout,
|
|
[IN, optional] uint32 CacheTimeout,
|
|
[IN, optional] string WinsServers,
|
|
[OUT] MicrosoftDNS_WINSType ref RR);
|
|
};
|
|
|
|
[
|
|
Schema ("MicrosoftDNS"): ToSubClass ,
|
|
Description("A subclass of MicrosoftDNS_ResourceRecord that represents a "
|
|
"Type WINSR record."): ToSubClass ,
|
|
Dynamic, Provider("MS_NT_DNS_PROVIDER"),
|
|
Locale (0x409), UUID ("{A9A68715-B6EA-11d2-85E5-0000F8102E5F}")
|
|
]
|
|
class MicrosoftDNS_WINSRType : MicrosoftDNS_ResourceRecord
|
|
{
|
|
[Read: ToSubClass ,
|
|
Description("A WINSR mapping flag that specifies whether the record "
|
|
"must be included into the zone replication. It may have only two "
|
|
"values: 0x80000000 and 0x00010000 corresponding to the replication "
|
|
"and no-replication (local record) flags, respectively."): ToSubClass,
|
|
ValueMap {"0x80000000", "0x00010000"}: ToSubClass
|
|
|
|
]
|
|
uint32 MappingFlag;
|
|
[Read: ToSubClass ,
|
|
Description("How long (in seconds) a DNS server, using WINS Reverse "
|
|
"Lookup, waits before giving up."): ToSubClass ,
|
|
Units ("Seconds"): ToSubClass
|
|
]
|
|
uint32 LookupTimeout;
|
|
[Read: ToSubClass ,
|
|
Description("How long (in seconds) a DNS server, using WINS Lookup, "
|
|
"may cache the WINS server's response."): ToSubClass ,
|
|
Units ("Seconds"): ToSubClass
|
|
]
|
|
uint32 CacheTimeout;
|
|
[Read: ToSubClass ,
|
|
Description("A domain name to append to returned NetBIOS names."):
|
|
ToSubClass
|
|
]
|
|
string ResultDomain;
|
|
[Implemented, static, Description(
|
|
"This method instantiates a 'WINSR' Type of Resource Record based "
|
|
"on the data in the method's input parameters: the record's DNS "
|
|
"Server Name, Container Name, Owner Name, class (default = "
|
|
"IN), 'time to live' value, and WINS mapping flag, reverse lookup "
|
|
"timeout, WINS cache timeout and domain name to append. It returns "
|
|
"a reference to the new object as an output parameter.")
|
|
: ToSubClass
|
|
]
|
|
void CreateInstanceFromPropertyData([IN] string DnsServerName,
|
|
[IN] string ContainerName, [IN] string OwnerName,
|
|
[IN, optional, Valuemap {"1", "2", "3", "4"}, Values {"IN (Internet)",
|
|
"CS (CSNET)", "CH (CHAOS)", "HS (Hesiod)"}] uint32 RecordClass = 1,
|
|
[IN, optional] uint32 TTL,
|
|
[IN] uint32 MappingFlag,
|
|
[IN] uint32 LookupTimeout,
|
|
[IN] uint32 CacheTimeout,
|
|
[IN] string ResultDomain,
|
|
[OUT] MicrosoftDNS_WINSRType ref RR);
|
|
|
|
|
|
[Implemented, Description(
|
|
"This method updates the TTL, Mapping Flag, Lookup Timeout, Cache Timeout "
|
|
"and Result Domain to the values specified as the input parameters of this "
|
|
"method. If a new value for some parameter is not specified, then the "
|
|
"current value for this parameter is not changed. The method returns a "
|
|
"reference to the modified object as an output parameter"): ToSubClass
|
|
]
|
|
void modify(
|
|
[IN, optional] uint32 TTL,
|
|
[IN, optional] uint32 MappingFlag,
|
|
[IN, optional] uint32 LookupTimeout,
|
|
[IN, optional] uint32 CacheTimeout,
|
|
[IN, optional] string ResultDomain,
|
|
[OUT] MicrosoftDNS_WINSRType ref RR);
|
|
};
|
|
|
|
[
|
|
Schema ("MicrosoftDNS"): ToSubClass ,
|
|
Description("A subclass of MicrosoftDNS_ResourceRecord that represents a "
|
|
"Type KEY record."): ToSubClass ,
|
|
Dynamic, Provider("MS_NT_DNS_PROVIDER"),
|
|
Locale (0x409), UUID ("{E4DEB050-B3FA-4EEC-BF2E-AA93CD000373}")
|
|
]
|
|
class MicrosoftDNS_KEYType : MicrosoftDNS_ResourceRecord
|
|
{
|
|
[Read: ToSubClass ,
|
|
Description("Set of flags described in RFC 2535."): ToSubClass
|
|
]
|
|
uint16 Flags;
|
|
[Read: ToSubClass ,
|
|
Description("Protocol for which the key specified in this record "
|
|
"can be used. The assigned values include 1-5 and map to the "
|
|
"protocols as follows. 1-TLS, 2-email, 3-dnssec, 4-IPSEC, 255-All "):
|
|
ToSubClass
|
|
]
|
|
uint16 Protocol;
|
|
[Read: ToSubClass ,
|
|
Description("Algorithm that can be used with the key specified in "
|
|
"this record. The assigned values include 1-4 and map to the algorithms "
|
|
"as follows. 1-RSA/MD5 [RFC 2537], 2-Diffie-Hellman [RFC 2539], "
|
|
"3-DSA [RFC 2536], 4- elliptic curve crypto "):
|
|
ToSubClass
|
|
]
|
|
uint16 Algorithm;
|
|
[Read: ToSubClass ,
|
|
Description("Public key is represented in base 64 as described in the "
|
|
"RFC 2535, Appendix A. "): ToSubClass
|
|
]
|
|
string PublicKey;
|
|
[Implemented, static, Description(
|
|
"This method instantiates a 'KEY' Type of Resource Record based "
|
|
"on the data in the method's input parameters: the record's DNS "
|
|
"Server Name, Container Name, Owner/target Name, class (default = "
|
|
"IN), 'time to live' value, and Flags, Protocol, Algorithm and "
|
|
"PublicKey. It returns a reference to the new object "
|
|
"as an output parameter."): ToSubClass
|
|
]
|
|
void CreateInstanceFromPropertyData([IN] string DnsServerName,
|
|
[IN] string ContainerName, [IN] string OwnerName,
|
|
[IN, optional, Valuemap {"1", "2", "3", "4"}, Values {"IN (Internet)",
|
|
"CS (CSNET)", "CH (CHAOS)", "HS (Hesiod)"}] uint32 RecordClass = 1,
|
|
[IN, optional] uint32 TTL, [IN] uint16 Flags, [IN] uint16 Protocol,
|
|
[IN] uint16 Algorithm, [IN] string PublicKey, [OUT] MicrosoftDNS_KEYType ref RR);
|
|
|
|
[Implemented, Description(
|
|
"This method updates the TTL, Flags, Protocol, Algorithm and PublicKey "
|
|
"to the values specified as the input parameters of this method. If a new "
|
|
"value for some parameter is not specified, then the current value for "
|
|
"this parameter is not changed. The method returns a reference to the "
|
|
"modified object as an output parameter."): ToSubClass
|
|
|
|
]
|
|
void modify(
|
|
[IN, optional] uint32 TTL,
|
|
[IN, optional] uint16 Flags,
|
|
[IN, optional] uint16 Protocol,
|
|
[IN, optional] uint16 Algorithm,
|
|
[IN, optional] string PublicKey,
|
|
[OUT] MicrosoftDNS_KEYType ref RR);
|
|
};
|
|
|
|
|
|
|
|
[
|
|
Schema ("MicrosoftDNS"): ToSubClass ,
|
|
Description("A subclass of MicrosoftDNS_ResourceRecord that represents a "
|
|
"Type SIG record."): ToSubClass ,
|
|
Dynamic, Provider("MS_NT_DNS_PROVIDER"),
|
|
Locale (0x409), UUID ("{564EB73D-B8A9-4517-B721-AB84BD9B2D}")
|
|
]
|
|
class MicrosoftDNS_SIGType : MicrosoftDNS_ResourceRecord
|
|
{
|
|
[Read: ToSubClass,
|
|
Description("Type of the RR covered by this SIG."): ToSubClass
|
|
]
|
|
uint16 TypeCovered;
|
|
[Read: ToSubClass,
|
|
Description("Algorithm that can be used with the key specified in "
|
|
"this record. The assigned values include 1-4 and map to the algorithms "
|
|
"as follows. 1-RSA/MD5 [RFC 2537], 2-Diffie-Hellman [RFC 2539], "
|
|
"3-DSA [RFC 2536], 4- elliptic curve crypto "):
|
|
ToSubClass
|
|
]
|
|
uint16 Algorithm;
|
|
[Read: ToSubClass,
|
|
Description("The \"labels\" octet is an unsigned count of how many "
|
|
" labels there are in the original SIG RR owner name not counting the "
|
|
" null label for root and not counting any initial \"*\" for a wildcard. "):
|
|
ToSubClass
|
|
]
|
|
uint16 Labels;
|
|
[Read: ToSubClass ,
|
|
Description("The TTL of the RRset signed by this SIG "):
|
|
ToSubClass
|
|
]
|
|
uint32 OriginalTTL;
|
|
[Read: ToSubClass ,
|
|
Description("SIG is valid until Signature Expiration. Signature Expiration "
|
|
" is specified in number of seconds since the start of 1 January 1970, "
|
|
" GMT, ignoring leap seconds. "):
|
|
ToSubClass
|
|
]
|
|
uint32 SignatureExpiration;
|
|
[Read: ToSubClass ,
|
|
Description("SIG is valid after Signature Inception. Signature Inception"
|
|
" is specified in number of seconds since the start of 1 January 1970, "
|
|
" GMT, ignoring leap seconds. "):
|
|
ToSubClass
|
|
]
|
|
uint32 SignatureInception;
|
|
[Read: ToSubClass ,
|
|
Description("KeyTag provides an efficient away to choose a Key"
|
|
"to verify SIG is more than one Keys are available. RFC 2535, "
|
|
"Appendix C describes how to calculate a KeyTag."):
|
|
ToSubClass
|
|
]
|
|
uint16 KeyTag;
|
|
[Read: ToSubClass ,
|
|
Description("The signer name is the domain name of the signer "
|
|
" generating the SIG RR. "): ToSubClass
|
|
]
|
|
string SignerName;
|
|
[Read: ToSubClass ,
|
|
Description("Signature is represented in base 64 as described in the "
|
|
"RFC 2535, Appendix A. "): ToSubClass
|
|
]
|
|
string Signature;
|
|
[Implemented, static, Description(
|
|
"This method instantiates a 'SIG' Type of Resource Record based "
|
|
"on the data in the method's input parameters: the record's DNS "
|
|
"Server Name, Container Name, Owner/target Name, class (default = "
|
|
"IN), 'time to live' value, TypeCovered, Algorithm, Labels, "
|
|
"OriginalTTL, SignatureExpiration, SignatureInception, KeyTag, "
|
|
" SignerName and Signature. It returns a reference to the new object "
|
|
"as an output parameter."): ToSubClass
|
|
]
|
|
void CreateInstanceFromPropertyData([IN] string DnsServerName,
|
|
[IN] string ContainerName, [IN] string OwnerName,
|
|
[IN, optional, Valuemap {"1", "2", "3", "4"}, Values {"IN (Internet)",
|
|
"CS (CSNET)", "CH (CHAOS)", "HS (Hesiod)"}] uint32 RecordClass = 1,
|
|
[IN, optional] uint32 TTL, [IN] uint16 TypeCovered, [IN] uint16 Algorithm,
|
|
[IN] uint16 Labels, [IN] uint32 OriginalTTL, [IN] uint32 SignatureExpiration,
|
|
[IN] uint32 SignatureInception, [IN] uint16 KeyTag, [IN] string SignerName,
|
|
[IN] string Signature, [OUT] MicrosoftDNS_SIGType ref RR);
|
|
|
|
[Implemented, Description(
|
|
"This method updates the TTL, TypeCovered, Algorithm, Labels, OriginalTTL, "
|
|
"SignatureExpiration, SignatureInception, KeyTag, SignerName and Signature "
|
|
"to the values specified as the input parameters of this method. If a new "
|
|
"value for some parameter is not specified, then the current value for "
|
|
"this parameter is not changed. The method returns a reference to the "
|
|
"modified object as an output parameter."): ToSubClass
|
|
|
|
]
|
|
void modify(
|
|
[IN, optional] uint32 TTL,
|
|
[IN] uint16 TypeCovered, [IN] uint16 Algorithm,
|
|
[IN] uint16 Labels, [IN] uint32 OriginalTTL, [IN] uint32 SignatureExpiration,
|
|
[IN] uint32 SignatureInception, [IN] uint16 KeyTag, [IN] string SignerName,
|
|
[IN] string Signature,
|
|
[OUT] MicrosoftDNS_SIGType ref RR);
|
|
};
|
|
|
|
|
|
[
|
|
Schema ("MicrosoftDNS"): ToSubClass ,
|
|
Description("A subclass of MicrosoftDNS_ResourceRecord that represents a "
|
|
"Type NXT record."): ToSubClass ,
|
|
Dynamic, Provider("MS_NT_DNS_PROVIDER"),
|
|
Locale (0x409), UUID ("{81DA27AB-72D2-442C-88EB-C0537E796D60}")
|
|
]
|
|
class MicrosoftDNS_NXTType : MicrosoftDNS_ResourceRecord
|
|
{
|
|
[Read: ToSubClass ,
|
|
Description("Next Domain Name."): ToSubClass
|
|
]
|
|
string NextDomainName;
|
|
[Read: ToSubClass ,
|
|
Description("Types is the space separated list of the RR types"
|
|
"mnemonics that exist for the owner name of the NXT RR. "):
|
|
ToSubClass
|
|
]
|
|
string Types;
|
|
[Implemented, static, Description(
|
|
"This method instantiates a 'NXT' Type of Resource Record based "
|
|
"on the data in the method's input parameters: the record's DNS "
|
|
"Server Name, Container Name, Owner/target Name, class (default = "
|
|
"IN), 'time to live' value, NextDomainName and Types. "
|
|
" It returns a reference to the new object as an output parameter."): ToSubClass
|
|
]
|
|
void CreateInstanceFromPropertyData([IN] string DnsServerName,
|
|
[IN] string ContainerName, [IN] string OwnerName,
|
|
[IN, optional, Valuemap {"1", "2", "3", "4"}, Values {"IN (Internet)",
|
|
"CS (CSNET)", "CH (CHAOS)", "HS (Hesiod)"}] uint32 RecordClass = 1,
|
|
[IN, optional] uint32 TTL, [IN] string NextDomainName,
|
|
[IN] string Types, [OUT] MicrosoftDNS_NXTType ref RR);
|
|
|
|
[Implemented, Description(
|
|
"This method updates the TTL, NextDomainName and Types"
|
|
"to the values specified as the input parameters of this method. If a new "
|
|
"value for some parameter is not specified, then the current value for "
|
|
"this parameter is not changed. The method returns a reference to the "
|
|
"modified object as an output parameter."): ToSubClass
|
|
|
|
]
|
|
void modify(
|
|
[IN, optional] uint32 TTL,
|
|
[IN] string NextDomainName,
|
|
[IN] string Types,
|
|
[OUT] MicrosoftDNS_NXTType ref RR);
|
|
};
|
|
|
|
|
|
|
|
[Abstract, Association: ToInstance ToSubClass DisableOverride,
|
|
Aggregation: ToSubClass DisableOverride,
|
|
Description ("A generic association to establish 'part of' relationships "
|
|
"between managed system elements. For example, the SystemComponent "
|
|
"association defines parts of a system."): ToSubClass,
|
|
Locale (0x409), UUID ("{8502C573-5FBB-11D2-AAC1-006008C78BC7}") ]
|
|
class CIM_Component
|
|
{
|
|
[Read: ToSubClass , Aggregate: ToSubClass DisableOverride ,
|
|
Description ("The parent element in the association"): ToSubClass ]
|
|
CIM_ManagedSystemElement REF GroupComponent;
|
|
[Description ("The child element in the association"): ToSubClass ,
|
|
Read: ToSubClass]
|
|
CIM_ManagedSystemElement REF PartComponent;
|
|
};
|
|
|
|
[
|
|
Schema ("MicrosoftDNS"): ToSubClass ,
|
|
Dynamic, Provider("MS_NT_DNS_PROVIDER"),
|
|
Description ("Every instance of the class MicrosoftDNS_Server may contain "
|
|
"multiple instances of the class MicrosoftDNS_Domain. Every instance of "
|
|
"the class MicrosoftDNS_Domain belongs to a single instance of the class "
|
|
"MicrosoftDNS_Server and is defined to be weak to that server." ):
|
|
ToSubClass ,
|
|
Locale (0x409), UUID ("{6C33CF92-AA43-11d2-85DD-0000F8102E5F}")
|
|
]
|
|
class MicrosoftDNS_ServerDomainContainment : CIM_Component
|
|
{
|
|
[Key, Override ("GroupComponent"): ToSubClass ,
|
|
Read: ToSubClass,
|
|
Min (1): ToSubClass , Max (1): ToSubClass ,
|
|
Description ("The DNS Server." ): ToSubClass
|
|
]
|
|
MicrosoftDNS_Server REF GroupComponent;
|
|
[Key, Override ("PartComponent"): ToSubClass ,
|
|
Weak: DisableOverride ToSubClass, Read: ToSubClass,
|
|
Description ("A Domain, Zone, Cache or RootHints managed "
|
|
"by the DNS server." ): ToSubClass
|
|
]
|
|
MicrosoftDNS_Domain REF PartComponent;
|
|
};
|
|
|
|
[
|
|
Schema ("MicrosoftDNS"): ToSubClass ,
|
|
Dynamic, Provider("MS_NT_DNS_PROVIDER"),
|
|
Description ("Domains may contain other Domains. (Every instance of "
|
|
"the MicrosoftDNS_Domain class may contain multiple other instances of "
|
|
"MicrosoftDNS_Domain.) An instance of a MicrosoftDNS_Domain object is "
|
|
"directly contained in (at most) one higher level MicrosoftDNS_Domain."):
|
|
ToSubClass,
|
|
Locale (0x409), UUID ("{6C33CF93-AA43-11d2-85DD-0000F8102E5F}")
|
|
]
|
|
class MicrosoftDNS_DomainDomainContainment : CIM_Component
|
|
{
|
|
[Key, Max(1): ToSubClass, Override ("GroupComponent"): ToSubClass ,
|
|
Read: ToSubClass,
|
|
Description ("A higher level Domain, Zone, Cache or RootHints." ):
|
|
ToSubClass
|
|
]
|
|
MicrosoftDNS_Domain REF GroupComponent;
|
|
[Key, Override ("PartComponent"): ToSubClass ,
|
|
Read: ToSubClass,
|
|
Description ("The Domain contained by a higher level Domain, "
|
|
"Zone, Cache or RootHints." ): ToSubClass
|
|
]
|
|
MicrosoftDNS_Domain REF PartComponent;
|
|
};
|
|
|
|
[
|
|
Schema ("MicrosoftDNS"): ToSubClass ,
|
|
Dynamic, Provider("MS_NT_DNS_PROVIDER"),
|
|
Description ( "Every instance of the class MicrosoftDNS_Domain may "
|
|
"contain multiple instances of the class, MicrosoftDNS_ResourceRecord. "
|
|
"Every instance of the class MicrosoftDNS_ResourceRecord belongs to a "
|
|
"single instance of the class MicrosoftDNS_Domain and is defined to be "
|
|
"weak to that instance." ): ToSubClass,
|
|
Locale (0x409), UUID ("{767E560C-AA43-11d2-85DD-0000F8102E5F }")
|
|
]
|
|
class MicrosoftDNS_DomainResourceRecordContainment : CIM_Component
|
|
{
|
|
[Key, Override ("GroupComponent"): ToSubClass ,
|
|
Min (1): ToSubClass , Max (1): ToSubClass ,
|
|
Read: ToSubClass,
|
|
Description ("The Zone, Cache, RootHints or Domain directly "
|
|
"containing the Resource Record." ): ToSubClass
|
|
]
|
|
MicrosoftDNS_Domain REF GroupComponent;
|
|
[Key, Override ("PartComponent"): ToSubClass ,
|
|
Weak: DisableOverride ToSubClass , Read: ToSubClass,
|
|
Description ("The Resource Record that is contained in a Domain, "
|
|
"Zone, Cache or RootHints." ): ToSubClass
|
|
]
|
|
MicrosoftDNS_ResourceRecord REF PartComponent;
|
|
};
|
|
|
|
|
|
[
|
|
Schema ("MicrosoftDNS"): ToSubClass,
|
|
Dynamic,
|
|
Provider("MS_NT_DNS_PROVIDER"),
|
|
Description ( "A single DNS Server statistic." ): ToSubClass,
|
|
Locale (0x409)
|
|
]
|
|
class MicrosoftDNS_Statistic
|
|
{
|
|
[
|
|
Key,
|
|
Propagated( "MicrosoftDNS_Server.Name" ): ToSubClass,
|
|
Read: ToSubClass,
|
|
Description(
|
|
"Indicates the IP address or hostname of the DNS Server that "
|
|
"contains this statistic."): ToSubClass
|
|
]
|
|
string DnsServerName;
|
|
|
|
[
|
|
Key,
|
|
Read: ToSubclass,
|
|
Description( "The name of the collection this statistic "
|
|
"belongs to." ): ToSubClass
|
|
]
|
|
string CollectionName;
|
|
|
|
[
|
|
Key,
|
|
Read: ToSubclass,
|
|
Description( "The numeric ID corresponding to "
|
|
"CollectionName." ): ToSubClass
|
|
]
|
|
uint32 CollectionId;
|
|
|
|
[
|
|
Key,
|
|
Read: ToSubclass,
|
|
Description( "The name of this statistic." ): ToSubClass
|
|
]
|
|
string Name;
|
|
|
|
[
|
|
Read: ToSubclass,
|
|
Description( "Numeric (DWORD) value of this statistic." ): ToSubClass
|
|
]
|
|
uint32 Value;
|
|
|
|
[
|
|
Read: ToSubclass,
|
|
Description( "String value of this statistic. This property "
|
|
"will only be set on statistics where the value is not "
|
|
"of DWORD type."): ToSubClass
|
|
]
|
|
string StringValue;
|
|
};
|
|
|
|
|
|
/*
|
|
[
|
|
Schema ("MicrosoftDNS"): ToSubClass,
|
|
Dynamic,
|
|
Provider("MS_NT_DNS_PROVIDER"),
|
|
Description (
|
|
"A collection of related DNS Server statistics." ): ToSubClass,
|
|
Locale (0x409)
|
|
]
|
|
class MicrosoftDNS_StatisticCollection : CIM_LogicalElement
|
|
{
|
|
[
|
|
Key,
|
|
Read: ToSubclass,
|
|
Description( "The name of this statistic collection." ): ToSubClass
|
|
]
|
|
string Name;
|
|
|
|
[
|
|
Read: ToSubclass,
|
|
Description( "Numeric ID of this statistic collection" ): ToSubClass
|
|
]
|
|
uint32 StatId;
|
|
|
|
[
|
|
Read: ToSubclass,
|
|
Description( "Array of values associated with this statistic "
|
|
"collection." ): ToSubClass
|
|
]
|
|
MicrosoftDNS_Statistic Statistics[];
|
|
};
|
|
*/
|