dnsp

package
v1.0.1 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: May 28, 2024 License: MIT Imports: 9 Imported by: 0

Documentation

Overview

The dnsp package implements the DNSP client protocol.

Introduction

The Domain Name Service (DNS) Server Management Protocol defines RPC interfaces that provide methods for remotely accessing and administering a DNS server. It is a client/server protocol based on RPC that is used in the configuration, management, and monitoring of a DNS server.

Overview

The DNS Server Management Protocol is a client/server protocol that is used to remotely query, monitor and configure DNS server settings, its zones, and resource records. The protocol allows a client to access DNS server settings and properties and also to enumerate all DNS data stored on the server (DNS zones and DNS records).

The DNS Server Management Protocol is a simple protocol with no state shared across RPC method calls. Each RPC method call contains one complete request. Output from one method call can be used as input to another call but the DNS Server Management Protocol does not provide for locking of DNS data across method calls. For example, a client can enumerate DNS zones with one call and retrieve the properties of one or more of the enumerated DNS zones with another call. However, no guarantee is made that the zone has not been deleted by another DNS Server Management Protocol client between these two method calls.

When the DNS server is directory server-integrated, some client requests can require or trigger Lightweight Directory Access Protocol (LDAP) requests from the DNS server to the local directory server or another directory server.

In particular, the DNS server can use the defaultNamingContext of the directory server's rootDSE, a DNS domain partition named DnsDomainZones, or a DNS forest partition named DnsForestZones to store zone information and zone records. (See section 2.3 for a discussion of the schemas used to store this information.) A DNS Server integrated with a directory server creates and automatically enlists itself in these default application directory partitions. Alternatively, zone information and zone records can be stored in additional application directory partitions, which can be created (and removed) by the DNS Server Management Protocol client in order to control the granularity of zone replication. Zones created in these additional application directory partitions will only be visible to directory servers enlisted in those partitions, thus allowing for granular control over replication.

A typical remote management involves the client querying or setting the configuration parameters of the DNS server. The client can also enumerate DNS zones and the DNS records stored in one or more zones. The client can modify the configuration of the DNS server as required. The client can also add, delete, or modify DNS zones or the DNS records held in zones as required. For example, a remote management client can:

* Set or retrieve the server's forwarders ( a95b05da-f1fd-4db3-94b4-817fdaa1f642#gt_025cfacf-ebc5-4659-971a-ee2ab5903575 ).

* Set or retrieve various DNS server settings.

* Create or modify zones.

* Create or modify zone records.

This usually involves sending a request to the DNS server specifying the type of operation (get, set and execute are examples of types of operations) to perform and any specific parameters that are associated with that operation. The DNS server responds to the client with the result of the operation.

The following diagram shows an example of a remote client creating a zone on the DNS server using the DNS server Management Protocol. The client sends a request to the server with the operation type and parameters. The server responds with a success or an error.

Index

Constants

This section is empty.

Variables

View Source 
var DPAutocreated = 1

DPAutocreated represents the DNS_DP_AUTOCREATED RPC constant

View Source 
var DPDeleted = 32

DPDeleted represents the DNS_DP_DELETED RPC constant

View Source 
var DPDomainDefault = 4

DPDomainDefault represents the DNS_DP_DOMAIN_DEFAULT RPC constant

View Source 
var DPEnlisted = 16

DPEnlisted represents the DNS_DP_ENLISTED RPC constant

View Source 
var DPForestDefault = 8

DPForestDefault represents the DNS_DP_FOREST_DEFAULT RPC constant

View Source 
var DPLegacy = 2

DPLegacy represents the DNS_DP_LEGACY RPC constant

View Source 
var DPOperationCreate = 1

DPOperationCreate represents the DNS_DP_OP_CREATE RPC constant

View Source 
var DPOperationCreateDomain = 5

DPOperationCreateDomain represents the DNS_DP_OP_CREATE_DOMAIN RPC constant

View Source 
var DPOperationCreateForest = 6

DPOperationCreateForest represents the DNS_DP_OP_CREATE_FOREST RPC constant

View Source 
var DPOperationDelete = 2

DPOperationDelete represents the DNS_DP_OP_DELETE RPC constant

View Source 
var DPOperationEnlist = 3

DPOperationEnlist represents the DNS_DP_OP_ENLIST RPC constant

View Source 
var DPOperationUnenlist = 4

DPOperationUnenlist represents the DNS_DP_OP_UNENLIST RPC constant

View Source 
var DPStateOkay = 0

DPStateOkay represents the DNS_DP_STATE_OKAY RPC constant

View Source 
var DPStateReplicationIncoming = 1

DPStateReplicationIncoming represents the DNS_DP_STATE_REPL_INCOMING RPC constant

View Source 
var DPStateReplicationOutgoing = 2

DPStateReplicationOutgoing represents the DNS_DP_STATE_REPL_OUTGOING RPC constant

View Source 
var DPStateUnknown = 3

DPStateUnknown represents the DNS_DP_STATE_UNKNOWN RPC constant

View Source 
var EnumZoneScopeListVer = 1

EnumZoneScopeListVer represents the DNS_RPC_ENUM_ZONE_SCOPE_LIST_VER RPC constant

View Source 
var (
	// import guard
	GoPackage = "dnsp"
)
View Source 
var MaxRecordTypes = 32

MaxRecordTypes represents the MAX_RECORD_TYPES RPC constant

View Source 
var MaxZoneTransferTypes = 2

MaxZoneTransferTypes represents the MAX_ZONE_TRANSFER_TYPES RPC constant

View Source 
var ZoneScopeCreateInfoVer = 1

ZoneScopeCreateInfoVer represents the DNS_RPC_ZONE_SCOPE_CREATE_INFO_VER RPC constant

View Source 
var ZoneScopeInfoVer = 1

ZoneScopeInfoVer represents the DNS_RPC_ZONE_SCOPE_INFO_VER RPC constant

View Source 
var ZoneStatsVer = 1

ZoneStatsVer represents the DNS_RPC_ZONE_STATS_VER RPC constant

Functions

This section is empty.

Types

type Addr 

type Addr struct {
	// MaxSa: This field MUST be constructed as specified in DNS ADDR.
	MaxSA []byte `idl:"name:MaxSa" json:"max_sa"`
	// DnsAddrUserDword: This field MUST be constructed as specified in DNS ADD USER.
	//
	// Any field not specified above MUST be set to zero by the sender and ignored by the
	// receiver.
	DNSAddrUser []uint32 `idl:"name:DnsAddrUserDword" json:"dns_addr_user"`
}

Addr structure represents DNS_ADDR RPC structure.

This DNS_ADDR structure is used to represent an IP address. The IP address is either IPv4 or IPv6.

The DNS ADDR structure is an IPv4 or IPv6 address used by DNS_ADDR MaxSa field (section 2.2.3.2.2). 

+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 1 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 2 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 3 | 1 |
|   |   |   |   |   |   |   |   |   |   | 0 |   |   |   |   |   |   |   |   |   | 0 |   |   |   |   |   |   |   |   |   | 0 |   |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| Address Family                                                | Port Number                                                   |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| IPv4 Address                                                                                                                  |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| IPv6 Address (16 bytes)                                                                                                       |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| ...                                                                                                                           |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| ...                                                                                                                           |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| Padding                                                                                                                       |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| ...                                                                                                                           |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+

func (*Addr) MarshalNDR 

func (o *Addr) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*Addr) UnmarshalNDR 

func (o *Addr) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type AddrArray 

type AddrArray struct {
	// MaxCount: The actual number of IP addresses that are present in the AddrArray member.
	MaxCount uint32 `idl:"name:MaxCount" json:"max_count"`
	// AddrCount: Must be set to the same value as MaxCount.
	AddrCount uint32 `idl:"name:AddrCount" json:"addr_count"`
	// Tag: This field is unused. Senders MUST set the value to zero and receivers MUST
	// ignore it.
	Tag uint32 `idl:"name:Tag" json:"tag"`
	// Family: The family of addresses present in the array, such as AF_INET or AF_INET6.
	// If this field is not specified, addresses with all families can be present.
	Family uint16 `idl:"name:Family" json:"family"`

	// Flags: This field is unused. Senders MUST set the value to zero and receivers MUST
	// ignore it.
	Flags uint32 `idl:"name:Flags" json:"flags"`
	// MatchFlag: This field is unused. Senders MUST set the value to zero and receivers
	// MUST ignore it.
	MatchFlag uint32 `idl:"name:MatchFlag" json:"match_flag"`

	// AddrArray: An array of DNS_ADDR (section 2.2.3.2.2) structures. The number of elements
	// in this array is specified by the AddrCount member.
	//
	// An empty DNS_ADDR_ARRAY is represented by AddrCount set to zero. Senders of an empty
	// DNS_ADR_ARRAY MUST set the other fields' values to zero (including a single entry
	// in AddrArray, which is set to binary zeros), and receivers MUST ignore them.
	AddrArray []*Addr `idl:"name:AddrArray;size_is:(AddrCount)" json:"addr_array"`
	// contains filtered or unexported fields
}

AddrArray structure represents DNS_ADDR_ARRAY RPC structure.

The DNS_ADDR_ARRAY structure is used to represent an array of DNS_ADDR (section 2.2.3.2.2) structures. The DNS Server Management Protocol uses this structure to exchange lists of mixed IPv4 and IPv6 addresses between client and server.

func (*AddrArray) MarshalNDR 

func (o *AddrArray) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*AddrArray) NDRSizeInfo 

func (o *AddrArray) NDRSizeInfo() []uint64

func (*AddrArray) UnmarshalNDR 

func (o *AddrArray) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type AutoConfigure 

type AutoConfigure struct {
	// dwRpcStructureVersion: The structure version number; this value MUST be set to 0x00000000.
	RPCStructureVersion uint32 `idl:"name:dwRpcStructureVersion" json:"rpc_structure_version"`

	// dwAutoConfigFlags: The autoconfiguration operation being requested by the client
	// as specified in DNS_RPC_AUTOCONFIG (section 2.2.8.1.1).
	AutoConfigFlags uint32 `idl:"name:dwAutoConfigFlags" json:"auto_config_flags"`

	// pszNewDomainName: A pointer to a null-terminated UTF-8 string which contains the
	// name of the directory server domain that this DNS server is about to join.
	NewDomainName string `idl:"name:pszNewDomainName;string" json:"new_domain_name"`
	// contains filtered or unexported fields
}

AutoConfigure structure represents DNS_RPC_AUTOCONFIGURE RPC structure.

The DNS_RPC_AUTOCONFIGURE structure contains the information required to auto-configure the DNS server.

func (*AutoConfigure) MarshalNDR 

func (o *AutoConfigure) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*AutoConfigure) UnmarshalNDR 

func (o *AutoConfigure) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type Buffer 

type Buffer struct {
	// dwLength: The length, in bytes, of the data stored in Buffer.
	Length uint32 `idl:"name:dwLength" json:"length"`
	// Buffer: A variable length array of bytes of length specified by dwLength. The buffer
	// can contain one or more DNS_RPC_NODE structures (section 2.2.2.2.3). Each DNS_RPC_NODE
	// contains the length of that node, so the DNS_RPC_BUFFER dwLength can be larger to
	// indicate multiple DNS_RPC_NODE structures.
	Buffer []byte `idl:"name:Buffer;size_is:(dwLength)" json:"buffer"`
}

Buffer structure represents DNS_RPC_BUFFER RPC structure.

The DNS_RPC_BUFFER structure contains a set of a specific type of structures. The DNS Server Management Protocol uses this structure to return information from the server, while processing R_DnssrvComplexOperation2 (section 3.1.4.8) method calls with operation type "Statistics".

func (*Buffer) MarshalNDR 

func (o *Buffer) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*Buffer) NDRSizeInfo 

func (o *Buffer) NDRSizeInfo() []uint64

func (*Buffer) UnmarshalNDR 

func (o *Buffer) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type ClientSubnetRecord 

type ClientSubnetRecord struct {
	// pwszClientSubnetName: (variable) A NULL-terminated Unicode string containing the
	// name of the client subnet record.
	ClientSubnetName string `idl:"name:pwszClientSubnetName" json:"client_subnet_name"`
	// pIPAddr: A pointer to a DNS_ADDR_ARRAY (section 2.2.3.2.3) structure that contains
	// a list of IP subnets contained in this client subnet record along with the SubnetLength
	// as defined in DNS ADD USER (section 2.2.3.2.2.2).
	IPAddr *AddrArray `idl:"name:pIPAddr" json:"ip_addr"`
	// pIPv6Addr: A pointer to a DNS_ADDR_ARRAY structure that contains a list of IPv6 subnets
	// contained in this client subnet record along with the SubnetLength as defined in
	// DNS ADD USER.
	IPv6Addr *AddrArray `idl:"name:pIPv6Addr" json:"ipv6_addr"`
}

ClientSubnetRecord structure represents DNS_RPC_CLIENT_SUBNET_RECORD RPC structure.

The DNS_RPC_CLIENT_SUBNET_RECORD structure contains the IPv4 and IPv6 subnets that are grouped together.

func (*ClientSubnetRecord) MarshalNDR 

func (o *ClientSubnetRecord) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*ClientSubnetRecord) UnmarshalNDR 

func (o *ClientSubnetRecord) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type Criteria 

type Criteria struct {
	// type: This specifies the type of criteria associated with the DNS policy. The value
	// is of type DNS_RPC_CRITERIA_ENUM (section 2.2.15.1.1.6).
	Type CriteriaEnum `idl:"name:type" json:"type"`
	// pCriteria: A NULL-terminated Unicode string containing the DNS policy criteria details.
	Criteria string `idl:"name:pCriteria" json:"criteria"`
}

Criteria structure represents DNS_RPC_CRITERIA RPC structure.

The DNS_RPC_CRITERIA structure contains the DNS policy criteria that is associated with a DNS policy.

func (*Criteria) MarshalNDR 

func (o *Criteria) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*Criteria) UnmarshalNDR 

func (o *Criteria) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type CriteriaComparator 

type CriteriaComparator uint16

CriteriaComparator type represents DNS_RPC_CRITERIA_COMPARATOR RPC enumeration.

The DNS_RPC_CRITERIA_COMPARATOR enumeration specifies the logical condition which connects the DNS Policy Criteria evaluation during DNS Operations. 

var (
	// Equals: Specifies that the values in a criteria (DNS_RPC_POLICY section 2.2.15.2.5)
	// of a DNS policy are connected by a logical OR condition.
	CriteriaComparatorEquals CriteriaComparator = 1
	// NotEquals: Specifies that the values in a criteria (DNS_RPC_POLICY section 2.2.15.2.5)
	// of a DNS Policy are connected by logical AND condition.
	CriteriaComparatorNotEquals CriteriaComparator = 2
)

func (CriteriaComparator) String 

func (o CriteriaComparator) String() string

type CriteriaEnum 

type CriteriaEnum uint16

CriteriaEnum type represents DNS_RPC_CRITERIA_ENUM RPC enumeration.

The DNS_RPC_CRITERIA_ENUM enumeration specifies the various criteria that a DNS server needs to match during a DNS operation to have a successful DNS policy match. For more information, see section 3.1.8.2. 

var (
	// DnsPolicyCriteriaSubnet: This specifies that the criteria for match of a DNS policy
	// is based on the client subnet record, derived from the IP address of a resolver [RFC1034]
	// section 2.4 in a DNS Operation.
	CriteriaEnumPolicyCriteriaSubnet CriteriaEnum = 0
	// DnsPolicyCriteriaTransportProtocol: This specifies that the criteria for match of
	// a DNS policy is based on the transport layer protocol (TCP or UDP) used to send a
	// DNS query to the DNS server during a DNS operation.
	CriteriaEnumPolicyCriteriaTransportProtocol CriteriaEnum = 1
	// DnsPolicyCriteriaNetworkProtocol: This specifies that the criteria for match of a
	// DNS policy is based on the Internet protocol used (IPv4 or IPv6) to send a DNS query
	// to the DNS server during a DNS operation.
	CriteriaEnumPolicyCriteriaNetworkProtocol CriteriaEnum = 2
	// DnsPolicyCriteriaInterface: This specifies that the criteria for match of a DNS policy
	// is based on the IP address on which the DNS server receives the DNS query in a DNS
	// operation.
	CriteriaEnumPolicyCriteriaInterface CriteriaEnum = 3
	// DnsPolicyCriteriaFqdn: This specifies that the criteria for match of a DNS policy
	// is based on the query name in the question section [RFC1034] section 3.7 of a DNS
	// query, in a DNS operation.
	CriteriaEnumPolicyCriteriaFQDN CriteriaEnum = 4
	// DnsPolicyCriteriaQtype: This specifies that the criteria for match of a DNS policy
	// is based on the QTYPE [RFC1035] section 3.2.3 of a DNS query in a DNS operation.
	CriteriaEnumPolicyCriteriaQTYPE CriteriaEnum = 5
	// DnsPolicyCriteriaTime: This specifies that the criteria for match of a DNS policy
	// is based on the time of day, in minutes, when the DNS server receives a DNS query
	// during a DNS operation.
	CriteriaEnumPolicyCriteriaTime CriteriaEnum = 6
	// DnsPolicyCriteriaMax: This shows the maximum number of criteria type supported by
	// DNS policy.
	CriteriaEnumPolicyCriteriaMax CriteriaEnum = 7
)

func (CriteriaEnum) String 

func (o CriteriaEnum) String() string

type DPEnum 

type DPEnum struct {
	// dwRpcStructureVersion: As specified in section 2.2.7.2.1.
	RPCStructureVersion uint32 `idl:"name:dwRpcStructureVersion" json:"rpc_structure_version"`

	// pszDpFqdn: As specified in section 2.2.7.2.1.
	DPFQDN string `idl:"name:pszDpFqdn;string" json:"dp_fqdn"`
	// dwFlags: As specified in section 2.2.7.2.1.
	Flags uint32 `idl:"name:dwFlags" json:"flags"`
	// dwZoneCount: As specified in section 2.2.7.2.1.
	ZoneCount uint32 `idl:"name:dwZoneCount" json:"zone_count"`
	// contains filtered or unexported fields
}

DPEnum structure represents DNS_RPC_DP_ENUM RPC structure.

The DNS_RPC_DP_ENUM structure contains abbreviated information about an application directory partition.<58>

func (*DPEnum) MarshalNDR 

func (o *DPEnum) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*DPEnum) UnmarshalNDR 

func (o *DPEnum) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type DPInfo 

type DPInfo struct {
	// dwRpcStructureVersion: The structure version number; this value MUST be set to 0x00000000.
	RPCStructureVersion uint32 `idl:"name:dwRpcStructureVersion" json:"rpc_structure_version"`

	// pszDpFqdn: A pointer to a null-terminated UTF-8 string that specifies the FQDN of
	// the application directory partition. This value is read from the dnsRoot attribute
	// of the partition crossRef object (see pszCrDn) converted to UTF-8 for this application
	// directory partition.
	DPFQDN string `idl:"name:pszDpFqdn;string" json:"dp_fqdn"`
	// pszDpDn: A pointer to a null-terminated Unicode string that specifies the distinguished
	// name for the application directory partition naming context root object. This is
	// the value of the nCName attribute of the application directory partition crossRef
	// object (see pszCrDn).
	DPDN string `idl:"name:pszDpDn;string" json:"dp_dn"`
	// pszCrDn: A pointer to a null-terminated Unicode string that specifies the distinguished
	// name for the application directory partition crossRef object (located beneath "CN=Partitions,
	// CN=Configuration, <Forest DN>").
	CRDN string `idl:"name:pszCrDn;string" json:"cr_dn"`
	// dwFlags: The application directory partition properties; this MUST be set to a combination
	// of allowed values for DNS_RPC_DP_FLAGS (section 2.2.7.1.1).
	Flags uint32 `idl:"name:dwFlags" json:"flags"`
	// dwZoneCount: The number of zones from this application directory partition that are
	// loaded in the DNS server's memory. This value is incremented or decremented in the
	// Application Directory Partition Table whenever a DNS Zone Table entry corresponding
	// to a zone in this application directory partition is initialized or deleted, respectively.
	ZoneCount uint32 `idl:"name:dwZoneCount" json:"zone_count"`
	// dwState: The current state of this application directory partition. This MUST be
	// set to one of the following values:
	//
	//	+---------------------------------------+----------------------------------------------------------------------------------+----------------------------------------------------------------------------------+
	//	|                                       |                                                                                  |                                                                                  |
	//	|                 VALUE                 |                                     MEANING                                      |                                      SOURCE                                      |
	//	|                                       |                                                                                  |                                                                                  |
	//	+---------------------------------------+----------------------------------------------------------------------------------+----------------------------------------------------------------------------------+
	//	+---------------------------------------+----------------------------------------------------------------------------------+----------------------------------------------------------------------------------+
	//	| DNS_DP_OKAY 0x00000000                | The application directory partition is running and ready for all operations.     | The Application Directory Partition naming context root object's instanceType    |
	//	|                                       |                                                                                  | attribute ([MS-ADA1] section 2.309) has neither DS_INSTANCETYPE_NC_COMING        |
	//	|                                       |                                                                                  | (0x00000010), nor the DS_INSTANCETYPE_NC_GOING ( 0x00000020) bit set.            |
	//	+---------------------------------------+----------------------------------------------------------------------------------+----------------------------------------------------------------------------------+
	//	| DNS_DP_STATE_REPL_INCOMING 0x00000001 | The application directory partition is replicating onto the directory server     | The Application Directory Partition naming context root object's instanceType    |
	//	|                                       | but has not completed an initial synchronization so will be ignored for the time | attribute has the (DS_INSTANCETYPE_NC_COMING ( 0x00000010) bit set.              |
	//	|                                       | being.                                                                           |                                                                                  |
	//	+---------------------------------------+----------------------------------------------------------------------------------+----------------------------------------------------------------------------------+
	//	| DNS_DP_STATE_REPL_OUTGOING 0x00000002 | The application directory partition is being deleted from the directory server   | The Application Directory Partition naming context root object's instanceType    |
	//	|                                       | and so will be ignored.                                                          | attribute has the DS_INSTANCETYPE_NC_GOING ( 0x00000020) bit set.                |
	//	+---------------------------------------+----------------------------------------------------------------------------------+----------------------------------------------------------------------------------+
	//	| DNS_DP_STATE_UNKNOWN 0x00000003       | The application directory partition state is unavailable for unknown reasons.    | The Application Directory Partition naming context root object's instanceType    |
	//	|                                       |                                                                                  | attribute is unavailable due to an error condition.                              |
	//	+---------------------------------------+----------------------------------------------------------------------------------+----------------------------------------------------------------------------------+
	State uint32 `idl:"name:dwState" json:"state"`

	// dwReplicaCount: The number of replication locations for the application directory
	// partition. This value MUST be between 0 and 10000. This value is calculated from
	// the values of the msDS-NC-Replica-Locations and msDS-NC-RO-Replica-Locations<56>attributes
	// of the application directory partition crossRef object (see pszCrDn), as the sum
	// of the number of DNs listed in each attribute.
	ReplicaCount uint32 `idl:"name:dwReplicaCount" json:"replica_count"`
	// ReplicaArray: Array of DNS_RPC_DP_REPLICA (section 2.2.7.2.2), that contains information
	// about replication locations for this application directory partition. This structure
	// is populated from the values of the msDS-NC-Replica-Locations (section 2.382) and
	// msDS-NC-RO-Replica-Locations (section 2.383) attributes of the application directory
	// partition crossRef object (see pszCrDn). Failure to read any of those attributes
	// will be treated as if no replica exists for that attribute.
	ArrayReplica []*DPReplica `idl:"name:ReplicaArray;size_is:(dwReplicaCount)" json:"array_replica"`
	// contains filtered or unexported fields
}

DPInfo structure represents DNS_RPC_DP_INFO RPC structure.

The DNS_RPC_DP_INFO structure SHOULD<55> represent the current state of an application directory partition on the directory server.

func (*DPInfo) MarshalNDR 

func (o *DPInfo) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*DPInfo) NDRSizeInfo 

func (o *DPInfo) NDRSizeInfo() []uint64

func (*DPInfo) UnmarshalNDR 

func (o *DPInfo) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type DPList 

type DPList struct {
	// dwRpcStructureVersion: As specified in section 2.2.7.2.1.
	RPCStructureVersion uint32 `idl:"name:dwRpcStructureVersion" json:"rpc_structure_version"`

	// dwDpCount: The number of DNS_RPC_DP_ENUM (section 2.2.7.2.3) structures present in
	// the array pointed to by DpArray.
	DPCount uint32 `idl:"name:dwDpCount" json:"dp_count"`
	// DpArray: An array of DNS_RPC_DP_ENUM structures (section 2.2.7.2.3), containing information
	// about the application directory partitions available to the DNS server.
	DPArray []*DPEnum `idl:"name:DpArray;size_is:(dwDpCount)" json:"dp_array"`
	// contains filtered or unexported fields
}

DPList structure represents DNS_RPC_DP_LIST RPC structure.

The DNS_RPC_DP_LIST structure contains a list of application directory partition information structures.<59>

func (*DPList) MarshalNDR 

func (o *DPList) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*DPList) NDRSizeInfo 

func (o *DPList) NDRSizeInfo() []uint64

func (*DPList) UnmarshalNDR 

func (o *DPList) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type DPReplica 

type DPReplica struct {
	// pszReplicaDn: A pointer to a null-terminated Unicode string that specifies the distinguished
	// name that identifies a specific directory server.
	ReplicaDN string `idl:"name:pszReplicaDn;string" json:"replica_dn"`
}

DPReplica structure represents DNS_RPC_DP_REPLICA RPC structure.

The DNS_RPC_DP_REPLICA structure contains information about an application directory partition replica by giving a distinguished name which can be used to uniquely identify the replica.<57>

func (*DPReplica) MarshalNDR 

func (o *DPReplica) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*DPReplica) UnmarshalNDR 

func (o *DPReplica) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type EnlistDP 

type EnlistDP struct {
	// dwRpcStructureVersion: The DNS management structure version number; this value MUST
	// be set to 0x00000001.
	RPCStructureVersion uint32 `idl:"name:dwRpcStructureVersion" json:"rpc_structure_version"`

	// pszDpFqdn: As specified in section 2.2.7.2.1.
	DPFQDN string `idl:"name:pszDpFqdn;string" json:"dp_fqdn"`
	// dwOperation: The application directory partition operation to be performed by the
	// DNS server; this MUST be set to one of the following values:
	//
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	|                                    |                                                                                  |
	//	|               VALUE                |                                     MEANING                                      |
	//	|                                    |                                                                                  |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	| DNS_DP_OP_CREATE 0x00000001        | Create and enlist (DNS_DP_OP_ENLIST) a new application directory partition.      |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	| DNS_DP_OP_DELETE 0x00000002        | Delete an existing application directory partition. If the application           |
	//	|                                    | directory partition has been marked DNS_DP_AUTOCREATED, DNS_DP_LEGACY,           |
	//	|                                    | DNS_DP_DOMAIN_DEFAULT, DNS_DP_FOREST_DEFAULT, or DNS_DP_DELETED, as specified in |
	//	|                                    | section 2.2.7.1.1, or if the DNS server cannot connect and bind to the FSMO role |
	//	|                                    | owner, then the server MUST return an error.                                     |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	| DNS_DP_OP_ENLIST 0x00000003        | Enlist this DNS server in an existing application directory partition.           |
	//	|                                    | If the application directory partition has been marked DNS_DP_ENLISTED or        |
	//	|                                    | DNS_DP_DELETED, as specified in section 2.2.7.1.1, then the DNS server MUST      |
	//	|                                    | return an error.                                                                 |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	| DNS_DP_OP_UNENLIST 0x00000004      | Un-enlist this DNS server from an existing application directory partition. If   |
	//	|                                    | the application directory partition has been marked DNS_DP_DELETED, as specified |
	//	|                                    | in section 2.2.7.1.1, then the DNS server MUST return an error.                  |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	| DNS_DP_OP_CREATE_DOMAIN 0x00000005 | Create a domain partition on the directory server if one does not already exist. |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	| DNS_DP_OP_CREATE_FOREST 0x00000006 | Create a forest partition on the directory server if it does not already exist.  |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	Operation uint32 `idl:"name:dwOperation" json:"operation"`
	// contains filtered or unexported fields
}

EnlistDP structure represents DNS_RPC_ENLIST_DP RPC structure.

The DNS_RPC_ENLIST_DP structure contains the information required to create, delete, or enumerate application directory partitions.<60>

func (*EnlistDP) MarshalNDR 

func (o *EnlistDP) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*EnlistDP) UnmarshalNDR 

func (o *EnlistDP) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type EnumScopeList 

type EnumScopeList struct {
	// dwRpcStructureVersion: The DNS management structure version number. This value MUST
	// be set to 0x00000000.
	RPCStructureVersion uint32 `idl:"name:dwRpcStructureVersion" json:"rpc_structure_version"`
	// dwScopeCount: The number of server scopes.
	ScopeCount uint32 `idl:"name:dwScopeCount" json:"scope_count"`
	// ScopeArray: An array containing the names of server scopes.
	ScopeArray []string `idl:"name:ScopeArray;size_is:(dwScopeCount)" json:"scope_array"`
}

EnumScopeList structure represents DNS_RPC_ENUM_SCOPE_LIST RPC structure.

The DNS_RPC_ENUM_SCOPE_LIST structure<89> contains the list of server scopes configured on the DNS server.

func (*EnumScopeList) MarshalNDR 

func (o *EnumScopeList) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*EnumScopeList) NDRSizeInfo 

func (o *EnumScopeList) NDRSizeInfo() []uint64

func (*EnumScopeList) UnmarshalNDR 

func (o *EnumScopeList) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type EnumVirtualizationInstanceList 

type EnumVirtualizationInstanceList struct {
	// dwRpcStructureVersion: The DNS management structure version number. This value MUST
	// be set to 0x00000000.
	RPCStructureVersion uint32 `idl:"name:dwRpcStructureVersion" json:"rpc_structure_version"`
	// dwVirtualizationInstanceCount: An unsigned integer that specifies the total number
	// of DNS_RPC_VIRTUALIZATION_INSTANCE_INFO (section 2.2.17.1.2) elements.
	VirtualizationInstanceCount uint32 `idl:"name:dwVirtualizationInstanceCount" json:"virtualization_instance_count"`
	// VirtualizationInstanceArray: An array of pointers to DNS_RPC_VIRTUALIZATION_INSTANCE_INFO
	// (section 2.2.17.1.2) structures.
	VirtualizationInstanceArray []*VirtualizationInstanceInfo `idl:"name:VirtualizationInstanceArray;size_is:(dwVirtualizationInstanceCount)" json:"virtualization_instance_array"`
}

EnumVirtualizationInstanceList structure represents DNS_RPC_ENUM_VIRTUALIZATION_INSTANCE_LIST RPC structure.

The DNS_RPC_ENUM_VIRTUALIZATION_INSTANCE_LIST structure contains information about all the virtualization instances in a DNS server (section 3.1.4.15).

func (*EnumVirtualizationInstanceList) MarshalNDR 

func (o *EnumVirtualizationInstanceList) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*EnumVirtualizationInstanceList) NDRSizeInfo 

func (o *EnumVirtualizationInstanceList) NDRSizeInfo() []uint64

func (*EnumVirtualizationInstanceList) UnmarshalNDR 

func (o *EnumVirtualizationInstanceList) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type EnumZoneScopeList 

type EnumZoneScopeList struct {
	// dwRpcStructureVersion: The DNS management structure version number. This value MUST
	// be set to 0x00000001.
	RPCStructureVersion uint32 `idl:"name:dwRpcStructureVersion" json:"rpc_structure_version"`
	// dwZoneScopeCount: The number of zone scopes or cache scopes.
	ZoneScopeCount uint32 `idl:"name:dwZoneScopeCount" json:"zone_scope_count"`
	// ZoneScopeArray: An array containing the names of zone scopes or cache scopes.
	ZoneScopeArray []string `idl:"name:ZoneScopeArray;size_is:(dwZoneScopeCount)" json:"zone_scope_array"`
}

EnumZoneScopeList structure represents DNS_RPC_ENUM_ZONE_SCOPE_LIST RPC structure.

The DNS_RPC_ENUM_ZONE_SCOPE_LIST structure<86> contains a list of zone scopes or cache scopes to be enumerated.

func (*EnumZoneScopeList) MarshalNDR 

func (o *EnumZoneScopeList) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*EnumZoneScopeList) NDRSizeInfo 

func (o *EnumZoneScopeList) NDRSizeInfo() []uint64

func (*EnumZoneScopeList) UnmarshalNDR 

func (o *EnumZoneScopeList) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type EnumZonesFilter 

type EnumZonesFilter struct {
	// dwRpcStructureVersion: The structure version number; this MUST be set to 0x00000001.
	RPCStructureVersion uint32 `idl:"name:dwRpcStructureVersion" json:"rpc_structure_version"`

	// dwFilter: A filter value that specifies the zone types that are to be selected as
	// part of the output zone list. This value MUST be set to any combination of the ZONE_REQUEST_FILTERS
	// (section 2.2.5.1.4).
	Filter uint32 `idl:"name:dwFilter" json:"filter"`
	// pszPartitionFqdn: A pointer to a null-terminated UTF-8 string that specifies the
	// distinguished name for an application directory partition location from which the
	// server is to enumerate zones; if this is NULL then zone enumeration is not restricted
	// based on the application directory partition.
	PartitionFQDN string `idl:"name:pszPartitionFqdn;string" json:"partition_fqdn"`
	// pszQueryString: Reserved for future use. Server MUST set to zero and receiver MUST
	// ignore this value.
	QueryString string `idl:"name:pszQueryString;string" json:"query_string"`
	// contains filtered or unexported fields
}

EnumZonesFilter structure represents DNS_RPC_ENUM_ZONES_FILTER RPC structure.

The DNS_RPC_ENUM_ZONES_FILTER structure specifies zone filtering criteria.

func (*EnumZonesFilter) MarshalNDR 

func (o *EnumZonesFilter) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*EnumZonesFilter) UnmarshalNDR 

func (o *EnumZonesFilter) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type EnumeratePolicyList 

type EnumeratePolicyList struct {
	// dwPolicyCount: An unsigned integer that specifies the total number of DNS_RPC_POLICY_NAME
	// structures (section 2.2.15.2.6).
	PolicyCount uint32 `idl:"name:dwPolicyCount" json:"policy_count"`
	// pPolicyArray: An array of pointers of DNS_RPC_POLICY_NAME (section 2.2.15.2.6) structures.
	PolicyArray []*PolicyName `idl:"name:pPolicyArray;size_is:(dwPolicyCount)" json:"policy_array"`
}

EnumeratePolicyList structure represents DNS_RPC_ENUMERATE_POLICY_LIST RPC structure.

The DNS_RPC_ENUMERATE_POLICY_LIST structure contains all the DNS policies at a specified level (section 2.2.15.1.1.3).

func (*EnumeratePolicyList) MarshalNDR 

func (o *EnumeratePolicyList) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*EnumeratePolicyList) NDRSizeInfo 

func (o *EnumeratePolicyList) NDRSizeInfo() []uint64

func (*EnumeratePolicyList) UnmarshalNDR 

func (o *EnumeratePolicyList) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type FlatRecord 

type FlatRecord struct {
	DataLength uint16 `idl:"name:wDataLength" json:"data_length"`
	Type       uint16 `idl:"name:wType" json:"type"`
	Flags      uint32 `idl:"name:dwFlags" json:"flags"`
	Serial     uint32 `idl:"name:dwSerial" json:"serial"`
	TTLSeconds uint32 `idl:"name:dwTtlSeconds" json:"ttl_seconds"`
	Timestamp  uint32 `idl:"name:dwTimeStamp" json:"timestamp"`

	Buffer []byte `idl:"name:Buffer;size_is:(wDataLength)" json:"buffer"`
	// contains filtered or unexported fields
}

FlatRecord structure represents DNS_FLAT_RECORD RPC structure.

func (*FlatRecord) MarshalNDR 

func (o *FlatRecord) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*FlatRecord) NDRSizeInfo 

func (o *FlatRecord) NDRSizeInfo() []uint64

func (*FlatRecord) UnmarshalNDR 

func (o *FlatRecord) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type Forwarders 

type Forwarders struct {
	RPCStructureVersion uint32 `idl:"name:dwRpcStructureVersion" json:"rpc_structure_version"`

	RecurseAfterForwarding uint32     `idl:"name:fRecurseAfterForwarding" json:"recurse_after_forwarding"`
	ForwardTimeout         uint32     `idl:"name:dwForwardTimeout" json:"forward_timeout"`
	Forwarders             *AddrArray `idl:"name:aipForwarders" json:"forwarders"`
	// contains filtered or unexported fields
}

Forwarders structure represents DNS_RPC_FORWARDERS RPC structure.

The DNS_RPC_FORWARDERS structure contains information about forwarders configured on the DNS server. There are different versions of the DNS_RPC_FORWARDERS structure. The DNS server MUST use the structures corresponding to the value of dwClientVersion in DNS Server Management Protocol method calls (section 3.1.4) in the following table, or if the method call does not specify the value of dwClientVersion, the DNS_RPC_FORWARDERS_W2K version of the structure MUST be used. 

+------------+----------------------------------------------------+
|            |                                                    |
|   VALUE    |                     STRUCTURE                      |
|            |                                                    |
+------------+----------------------------------------------------+
+------------+----------------------------------------------------+
| 0x00000000 | DNS_RPC_FORWARDERS_W2K (section 2.2.5.2.10.1)      |
+------------+----------------------------------------------------+
| 0x00060000 | DNS_RPC_FORWARDERS_DOTNET (section 2.2.5.2.10.2)   |
+------------+----------------------------------------------------+
| 0x00070000 | DNS_RPC_FORWARDERS_LONGHORN (section 2.2.5.2.10.3) |
+------------+----------------------------------------------------+

func (*Forwarders) MarshalNDR 

func (o *Forwarders) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*Forwarders) UnmarshalNDR 

func (o *Forwarders) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type ForwardersLonghorn 

type ForwardersLonghorn struct {
	// dwRpcStructureVersion: The structure version number. It MUST be set to 0x00000002.
	RPCStructureVersion uint32 `idl:"name:dwRpcStructureVersion" json:"rpc_structure_version"`

	RecurseAfterForwarding uint32 `idl:"name:fRecurseAfterForwarding" json:"recurse_after_forwarding"`
	ForwardTimeout         uint32 `idl:"name:dwForwardTimeout" json:"forward_timeout"`
	// aipForwarders: A pointer to a structure of type DNS_ADDR_ARRAY (section 2.2.3.2.3)
	// specifies a list of IP addresses that will be used as forwarders by the DNS server.
	Forwarders *AddrArray `idl:"name:aipForwarders" json:"forwarders"`
	// contains filtered or unexported fields
}

ForwardersLonghorn structure represents DNS_RPC_FORWARDERS_LONGHORN RPC structure.

In the DNS_RPC_FORWARDERS_LONGHORN structure all fields have same definition as specified in section DNS_RPC_FORWARDERS_DOTNET (section 2.2.5.2.10.2), with the following exceptions:

func (*ForwardersLonghorn) MarshalNDR 

func (o *ForwardersLonghorn) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*ForwardersLonghorn) UnmarshalNDR 

func (o *ForwardersLonghorn) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type ForwardersW2K 

type ForwardersW2K struct {
	// fRecurseAfterForwarding: A value of 0x00000001 indicates that the DNS server is configured
	// to use normal recursion for name resolution if forwarders are not configured or are
	// unreachable; a value of 0x00000000 indicates it is not.
	RecurseAfterForwarding uint32 `idl:"name:fRecurseAfterForwarding" json:"recurse_after_forwarding"`
	// dwForwardTimeout: The time-interval, in seconds, for which the DNS server waits for
	// a response from each server in the forwarders list. No restrictions are applied to
	// the range for the dwForwardTimeout member when modifying its value through this structure.
	// If dwForwardTimeout is set to zero, then the server SHOULD<45> reset the forward
	// timeout to the default value, 3 minutes (180 seconds).
	ForwardTimeout uint32 `idl:"name:dwForwardTimeout" json:"forward_timeout"`
	// aipForwarders: The list of IP addresses that will be used as forwarders by the DNS
	// server.
	Forwarders *IPv4Array `idl:"name:aipForwarders" json:"forwarders"`
}

ForwardersW2K structure represents DNS_RPC_FORWARDERS_W2K RPC structure.

The DNS_RPC_FORWARDERS_W2K structure specifies the set of DNS servers this DNS server will forward unresolved queries to.

func (*ForwardersW2K) MarshalNDR 

func (o *ForwardersW2K) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*ForwardersW2K) UnmarshalNDR 

func (o *ForwardersW2K) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type Forwarders_NET 

type Forwarders_NET struct {
	// dwRpcStructureVersion: The structure version number. It MUST be set to 0x00000001.
	RPCStructureVersion uint32 `idl:"name:dwRpcStructureVersion" json:"rpc_structure_version"`

	RecurseAfterForwarding uint32     `idl:"name:fRecurseAfterForwarding" json:"recurse_after_forwarding"`
	ForwardTimeout         uint32     `idl:"name:dwForwardTimeout" json:"forward_timeout"`
	Forwarders             *IPv4Array `idl:"name:aipForwarders" json:"forwarders"`
	// contains filtered or unexported fields
}

Forwarders_NET structure represents DNS_RPC_FORWARDERS_DOTNET RPC structure.

In the DNS_RPC_FORWARDERS_DOTNET structure all fields have same definition as specified in section DNS_RPC_FORWARDERS_W2K (section 2.2.5.2.10.1), with the following exceptions:

func (*Forwarders_NET) MarshalNDR 

func (o *Forwarders_NET) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*Forwarders_NET) UnmarshalNDR 

func (o *Forwarders_NET) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type IPValidate 

type IPValidate struct {
	// dwRpcStructureVersion: The DNS management structure version number. This value MUST
	// be set to 0x00000001.
	RPCStructureVersion uint32 `idl:"name:dwRpcStructureVersion" json:"rpc_structure_version"`

	// dwContext: The context or purpose for which addresses present in aipValidateAddrs
	// MUST be validated by the DNS server. This field MUST be set to one of the following
	// values:
	//
	//	+---------------------------------------+----------------------------------------------------------------------------------+
	//	|                                       |                                                                                  |
	//	|                 VALUE                 |                                     MEANING                                      |
	//	|                                       |                                                                                  |
	//	+---------------------------------------+----------------------------------------------------------------------------------+
	//	+---------------------------------------+----------------------------------------------------------------------------------+
	//	| DNS_IPVAL_DNS_SERVERS 0x00000000      | Validate that IP addresses are reachable and operational by the DNS servers.     |
	//	+---------------------------------------+----------------------------------------------------------------------------------+
	//	| DNS_IPVAL_DNS_ROOTHINTS 0x00000001    | Validate that IP addresses are suitable as root hints.                           |
	//	+---------------------------------------+----------------------------------------------------------------------------------+
	//	| DNS_IPVAL_DNS_FORWARDERS 0x00000002   | Validate that IP addresses are server level forwarders.                          |
	//	+---------------------------------------+----------------------------------------------------------------------------------+
	//	| DNS_IPVAL_DNS_ZONE_MASTERS 0x00000003 | Validate that IP addresses are remote DNS servers hosting a zone, named as       |
	//	|                                       | pointed to by pszContextName.                                                    |
	//	+---------------------------------------+----------------------------------------------------------------------------------+
	//	| DNS_IPVAL_DNS_DELEGATIONS 0x00000004  | Validate that IP addresses are remote DNS servers are name-server for the        |
	//	|                                       | delegated zone, named as pointed to by pszContextName.                           |
	//	+---------------------------------------+----------------------------------------------------------------------------------+
	Context uint32 `idl:"name:dwContext" json:"context"`

	// pszContextName: A pointer to a null-terminated ASCII character string that specifies
	// a zone name. The use of this zone name is specified by the dwContext member.
	ContextName string `idl:"name:pszContextName;string" json:"context_name"`
	// aipValidateAddrs: A pointer to a DNS_ADDR_ARRAY structure (section 2.2.3.2.3) contains
	// a list of IP addresses to be validated by the DNS server.
	ValidateAddrs *AddrArray `idl:"name:aipValidateAddrs" json:"validate_addrs"`
	// contains filtered or unexported fields
}

IPValidate structure represents DNS_RPC_IP_VALIDATE RPC structure.

The DNS_RPC_IP_VALIDATE structure is used to request that the DNS server validate a number of IP addresses. This can be used by clients to determine if an IP address is suitable for use as a DNS server in the context specified by the dwContext member (see below). This structure is to request IP validation while processing the R_DnssrvComplexOperation2 (section 3.1.4.8) method call with operation type IpValidate.

func (*IPValidate) MarshalNDR 

func (o *IPValidate) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*IPValidate) UnmarshalNDR 

func (o *IPValidate) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type IPv4Array 

type IPv4Array struct {
	// AddrCount: The number of IPv4 addresses present in the AddrArray member.
	AddrCount uint32 `idl:"name:AddrCount" json:"addr_count"`
	// AddrArray: An array of IPv4 addresses. An IPv4 address is represented as a 32-bit
	// unsigned integer in network byte order.
	//
	// An empty IP4_ARRAY is represented by AddrCount set to zero and AddrArray unused.
	// Senders of an empty IP4_ARRAY MUST set AddrArray to a single entry containing binary
	// zeros, and receivers MUST ignore it.
	AddrArray []uint32 `idl:"name:AddrArray;size_is:(AddrCount)" json:"addr_array"`
}

IPv4Array structure represents IP4_ARRAY RPC structure.

The IP4_ARRAY structure is used to represent an array of IPv4 addresses. This structure cannot represent IPv6 addresses.

func (*IPv4Array) MarshalNDR 

func (o *IPv4Array) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*IPv4Array) NDRSizeInfo 

func (o *IPv4Array) NDRSizeInfo() []uint64

func (*IPv4Array) UnmarshalNDR 

func (o *IPv4Array) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type ImportOperationResult 

type ImportOperationResult uint16

ImportOperationResult type represents ImportOpResult RPC enumeration.

The ImportOpResult enumeration SHOULD<47> define the operations to be executed when the DNS_RPC_ZONE_DNSSEC_SETTINGS structure (section 2.2.6.2.9) is imported on a zone. 

var (
	// IMPORT_STATUS_NOOP: No change was detected in the imported signing settings or the
	// signing settings of the zone.
	ImportOperationResultStatusNoop ImportOperationResult = 0
	// IMPORT_STATUS_SIGNING_READY: The zone is marked for re-signing.
	ImportOperationResultStatusSigningReady ImportOperationResult = 1
	// IMPORT_STATUS_UNSIGNING_READY: The zone is marked for unsigning.
	ImportOperationResultStatusUnsigningReady ImportOperationResult = 2
	// IMPORT_STATUS_CHANGED: The change was detected in signing settings imported and were
	// incorporated, but no re-signing or unsigning is required.
	ImportOperationResultStatusChanged ImportOperationResult = 3
)

func (ImportOperationResult) String 

func (o ImportOperationResult) String() string

type KeySignScope 

type KeySignScope uint16

KeySignScope type represents KeySignScope RPC enumeration.

The KeySignScope enumeration defines the scope of the key in a signed zone. It SHOULD<46> be used to indicate different signing and publishing scopes of the key. 

var (
	// SIGN_SCOPE_DEFAULT: The key is used for its default purpose: If the signing key descriptor's
	// fIsKSK field is set to 0x00000001, the key is used to sign only DNSKEY records in
	// the zone. If the signing key descriptor's fIsKSK field is set to 0x00000000, the
	// key is used to sign all records in the zone.
	KeySignScopeDefault KeySignScope = 0
	// SIGN_SCOPE_DNSKEY_ONLY: The key is used to sign only DNSKEY records in the zone.
	KeySignScopeDNSKEYOnly KeySignScope = 1
	// SIGN_SCOPE_ALL_RECORDS: The key is used to sign all records in the zone.
	KeySignScopeAllRecords KeySignScope = 2
	// SIGN_SCOPE_ADD_ONLY: The key is published as a DNSKEY in the zone, but it is not
	// used to sign any records.
	KeySignScopeAddOnly KeySignScope = 3
	// SIGN_SCOPE_DO_NOT_PUBLISH: The key is not published to the zone and is not used to
	// sign any records.
	KeySignScopeDoNotPublish KeySignScope = 4
	// SIGN_SCOPE_REVOKED: The key is published as a DNSKEY in the zone with its Revoked
	// bit ([RFC5011] section 2.1) set. It is used to sign DNSKEY records.
	KeySignScopeRevoked KeySignScope = 5
)

func (KeySignScope) String 

func (o KeySignScope) String() string

type NameAndParam 

type NameAndParam struct {
	// dwParam: The requested new value for the server property specified by pszNodeName.
	Param uint32 `idl:"name:dwParam" json:"param"`
	// pszNodeName: Pointer to a null-terminated UTF-8 string that specifies the name of
	// the server property.
	NodeName string `idl:"name:pszNodeName;string" json:"node_name"`
}

NameAndParam structure represents DNS_RPC_NAME_AND_PARAM RPC structure.

The DNS_RPC_NAME_AND_PARAM structure contains information about a simple server property that takes a DWORD value. The DNS Server Management Protocol uses this structure to exchange information about various properties that take an integer value, while processing the R_DnssrvOperation2 (section 3.1.4.6) method call with operation types "ResetDwordProperty", "DeleteNode", and "DeleteRecordSet".

func (*NameAndParam) MarshalNDR 

func (o *NameAndParam) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*NameAndParam) UnmarshalNDR 

func (o *NameAndParam) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type Policy 

type Policy struct {
	// pwszPolicyName: A NULL-terminated Unicode string containing the name of the DNS policy.
	// The name is unique across a level as specified in DNS_RPC_POLICY_LEVEL (section 2.2.15.1.1.3).
	PolicyName string `idl:"name:pwszPolicyName" json:"policy_name"`
	// level: This specifies whether the policy is configured for a zone (including a cache
	// zone) or is at server level. The value is of type DNS_RPC_POLICY_LEVEL.
	Level PolicyLevel `idl:"name:level" json:"level"`
	// appliesOn: This specifies the DNS operation for which the DNS policy is applicable.
	// The value is of type DNS_RPC_POLICY_TYPE (section 2.2.15.1.1.5).
	AppliesOn PolicyType `idl:"name:appliesOn" json:"applies_on"`
	// action: This specifies the action to be applied on a DNS operation when there is
	// a DNS policy match. The value is of type DNS_RPC_POLICY_ACTION_TYPE (section 2.2.15.1.1.4).
	Action PolicyActionType `idl:"name:action" json:"action"`
	// condition: This specifies the logical operation across the DNS policy criteria of
	// a DNS policy, which determines whether the DNS policy match has succeeded or failed.
	// The value is of type DNS_RPC_POLICY_CONDITION (section 2.2.15.1.1.2).
	Condition PolicyCondition `idl:"name:condition" json:"condition"`
	// isEnabled: A BOOL variable that specifies whether a DNS policy is enabled. TRUE indicates
	// that the DNS policy MUST be applied to the DNS operation; FALSE indicates that the
	// DNS policy is disabled and MUST NOT be applied to the DNS operation.
	IsEnabled bool `idl:"name:isEnabled" json:"is_enabled"`
	// dwProcessingOrder: An unsigned integer that specifies the order in which this DNS
	// policy is processed, along with 0 or more other DNS policies for a given level 2.2.15.1.1.3
	// and DNS_RPC_POLICY_TYPE (section 2.2.15.1.1.5) during a DNS operation.
	ProcessingOrder uint32 `idl:"name:dwProcessingOrder" json:"processing_order"`
	// pszZoneName: A NULL-terminated string containing the name of the zone for which this
	// DNS policy is configured.
	ZoneName string `idl:"name:pszZoneName" json:"zone_name"`
	// pContentList: An object of type DNS_RPC_POLICY_CONTENT_LIST (section 2.2.15.2.3)
	// that has a list of zone scope, cache scope, or server scope with weight as defined
	// in DNS_RPC_POLICY_CONTENT (section 2.2.15.2.2). If the DNS policy matches the criteria
	// in pCriteriaList and its action is DnsPolicyAllow, then the zone scopes, cache scopes,
	// or server scopes contained in pContentList are used in the DNS operation as per their
	// dwWeight.
	ContentList *PolicyContentList `idl:"name:pContentList" json:"content_list"`
	// flags: This is used during update of a DNS policy. The various bits of flags show
	// which members of the DNS Policy are to be updated. For possible values of the bits
	// of flags. see section 2.2.15.1.1. For details on how this is used during a policy
	// update, see the operation UpdatePolicy in section 3.1.4.1.
	Flags uint64 `idl:"name:flags" json:"flags"`
	// dwCriteriaCount: An unsigned integer containing the number of DNS policy criteria
	// that are configured for this DNS policy.
	CriteriaCount uint32 `idl:"name:dwCriteriaCount" json:"criteria_count"`
	// pCriteriaList: An array of DNS_RPC_CRITERIA (section 2.2.15.2.4) that are compared
	// with each other using condition DNS_RPC_POLICY_CONDITION (section 2.2.15.1.1.2) to
	// match a DNS policy.
	CriteriaList []*Criteria `idl:"name:pCriteriaList;size_is:(dwCriteriaCount)" json:"criteria_list"`
}

Policy structure represents DNS_RPC_POLICY RPC structure.

The DNS_RPC_POLICY structure contains all details associated with a DNS policy.

func (*Policy) MarshalNDR 

func (o *Policy) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*Policy) NDRSizeInfo 

func (o *Policy) NDRSizeInfo() []uint64

func (*Policy) UnmarshalNDR 

func (o *Policy) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type PolicyActionType 

type PolicyActionType uint16

PolicyActionType type represents DNS_RPC_POLICY_ACTION_TYPE RPC enumeration.

The DNS_RPC_POLICY_ACTION_TYPE enumeration specifies the action to be applied when a DNS Policy is matched. 

var (
	// DnsPolicyDeny: Denies the specific DNS operation.
	PolicyActionTypeDeny PolicyActionType = 0
	// DnsPolicyAllow: Allows a specific DNS operation.
	PolicyActionTypeAllow  PolicyActionType = 1
	PolicyActionTypeIgnore PolicyActionType = 2
	// DnsPolicyActionMax: Shows the maximum action types supported.
	PolicyActionTypeMax PolicyActionType = 3
)

func (PolicyActionType) String 

func (o PolicyActionType) String() string

type PolicyCondition 

type PolicyCondition uint16

PolicyCondition type represents DNS_RPC_POLICY_CONDITION RPC enumeration.

The DNS_RPC_POLICY_CONDITION enumeration specifies the logical condition that connects the DNS Policy Criteria evaluation during DNS operations. 

var (
	// DNS_AND: While evaluating a DNS policy (section 2.2.15.2.5) during a DNS Operation,
	// all criteria (section 2.2.15.2.4) configured for that particular DNS Policy MUST
	// match.
	PolicyConditionAnd PolicyCondition = 0
	// DNS_OR: While evaluating a DNS Policy during a DNS Operation, at least one configured
	// criterion MUST match.
	PolicyConditionOr PolicyCondition = 1
)

func (PolicyCondition) String 

func (o PolicyCondition) String() string

type PolicyContent 

type PolicyContent struct {
	// pwszScopeName: A NULL-terminated Unicode string containing the name of the zone scope,
	// cache scope or server scope.
	ScopeName string `idl:"name:pwszScopeName" json:"scope_name"`
	// dwWeight: A 32-bit unsigned integer that specifies the weight associated with the
	// scope name. The weight of a scope determines the number of responses that are sent
	// from that scope. For example, if a DNS_RPC_POLICY has pContentList with two DNS_RPC_POLICY_CONTENT
	// items having scope name and weight as {Scope1,2} and {Scope2,3}, then when the DNS
	// policy is a match, Scope1 is used to respond to the DNS operation for the first two
	// times the DNS policy is a match. Scope2 is used to respond to the DNS operation for
	// the next three times the DNS policy is a match. The sequence is repeated for further
	// matches of the DNS policy. If a dwWeight of a DNS_RPC_POLICY_CONTENT is not given.
	// its default weight is 1. So if two or more DNS_RPC_POLICY_CONTENT structures are
	// given during DNS_RPC_POLICY creation without a value for dwWeight, all of them will
	// get weight of 1 and the DNS operation will be performed from each scope in a round-robin
	// fashion. Allowed values for weight are any positive number from 1 and higher to 0xFFFFFFFF.
	// If 0 is sent as a weight, the DNS server returns the error DNS_ERROR_POLICY_INVALID_WEIGHT
	// (9981).
	Weight uint32 `idl:"name:dwWeight" json:"weight"`
}

PolicyContent structure represents DNS_RPC_POLICY_CONTENT RPC structure.

The DNS_RPC_POLICY_CONTENT structure contains the zone scope, cache scope, or server scope details that are used to service the DNS operation if a DNS policy's DNS_RPC_POLICY_ACTION_TYPE (section 2.2.15.1.1.4) is DnsPolicyAllow.

func (*PolicyContent) MarshalNDR 

func (o *PolicyContent) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*PolicyContent) UnmarshalNDR 

func (o *PolicyContent) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type PolicyContentList 

type PolicyContentList struct {
	// dwContentCount: An unsigned integer specifying the number of DNS_RPC_POLICY_CONTENT
	// elements present.
	ContentCount uint32 `idl:"name:dwContentCount" json:"content_count"`
	// pContent: An array of pointers to DNS_RPC_POLICY_CONTENT structures.
	Content []*PolicyContent `idl:"name:pContent;size_is:(dwContentCount)" json:"content"`
}

PolicyContentList structure represents DNS_RPC_POLICY_CONTENT_LIST RPC structure.

The DNS_RPC_POLICY_CONTENT_LIST structure contains a list of DNS_RPC_POLICY_CONTENT structures (section 2.2.15.2.2) configured for a DNS policy.

func (*PolicyContentList) MarshalNDR 

func (o *PolicyContentList) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*PolicyContentList) NDRSizeInfo 

func (o *PolicyContentList) NDRSizeInfo() []uint64

func (*PolicyContentList) UnmarshalNDR 

func (o *PolicyContentList) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type PolicyLevel 

type PolicyLevel uint16

PolicyLevel type represents DNS_RPC_POLICY_LEVEL RPC enumeration.

The DNS_RPC_POLICY_LEVEL enumeration specifies that the DNS Policy is applied for a zone, cache zone, or at server level. 

var (
	// DnsPolicyServerLevel: The DNS Policy is applicable at the server level for all DNS
	// operations.
	PolicyLevelServerLevel PolicyLevel = 0
	// DnsPolicyZoneLevel: The DNS Policy is applicable only for a specified zone. It is
	// applicable for all DNS operations allowed for any zone.
	PolicyLevelZoneLevel PolicyLevel = 1
	// DnsPolicyLevelMax: Shows the maximum level types supported.
	PolicyLevelMax PolicyLevel = 2
)

func (PolicyLevel) String 

func (o PolicyLevel) String() string

type PolicyName 

type PolicyName struct {
	// pwszPolicyName: A NULL-terminated Unicode string containing the name of the DNS policy.
	// The name is unique across a level as specified in DNS_RPC_POLICY_LEVEL (section 2.2.15.1.1.3).
	PolicyName string `idl:"name:pwszPolicyName" json:"policy_name"`
	// appliesOn: This specifies the DNS operation to which the DNS policy applies. The
	// value is of type DNS_RPC_POLICY_TYPE (section 2.2.15.1.1.5).
	AppliesOn PolicyType `idl:"name:appliesOn" json:"applies_on"`
	// fEnabled: A BOOL variable that specifies whether a DNS policy is enabled.
	Enabled bool `idl:"name:fEnabled" json:"enabled"`
	// processingOrder: An unsigned integer that specifies the order in which this DNS policy
	// is processed, along with 0 or more other DNS policies for a given level (section
	// 2.2.15.1.1.3) and DNS_RPC_POLICY_TYPE (section 2.2.15.1.1.5) during a DNS operation.
	ProcessingOrder uint32 `idl:"name:processingOrder" json:"processing_order"`
}

PolicyName structure represents DNS_RPC_POLICY_NAME RPC structure.

The DNS_RPC_POLICY_NAME structure contains the details of the DNS policy when the DNS policies are enumerated at a specified level (section 2.2.15.1.1.3).

func (*PolicyName) MarshalNDR 

func (o *PolicyName) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*PolicyName) UnmarshalNDR 

func (o *PolicyName) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type PolicyType 

type PolicyType uint16

PolicyType type represents DNS_RPC_POLICY_TYPE RPC enumeration.

The DNS_RPC_POLICY_TYPE enumeration specifies the DNS operation for which the DNS policy is applicable. 

+----------------------------+----------------------------------------------------------------------------------+
|         ENUMERATOR         |                                                                                  |
|           VALUE            |                                   DESCRIPTION                                    |
|                            |                                                                                  |
+----------------------------+----------------------------------------------------------------------------------+
+----------------------------+----------------------------------------------------------------------------------+
| DnsPolicyQueryProcessing=0 | The DNS policy is applicable for DNS queries.                                    |
+----------------------------+----------------------------------------------------------------------------------+
| DnsPolicyZoneTransfer      | The DNS policy is applicable for zone transfer.                                  |
+----------------------------+----------------------------------------------------------------------------------+
| DnsPolicyDynamicUpdate     | The DNS policy is applicable for dynamic DNS updates.                            |
+----------------------------+----------------------------------------------------------------------------------+
| DnsPolicyRecursion         | The DNS policy is applicable for recursive queries.                              |
+----------------------------+----------------------------------------------------------------------------------+
| DnsPolicyRRLExceptionList  | The DNS policy is applicable for RRL Exceptionlisting. Exceptionlisting exempts  |
|                            | queries from response rate limiting. The queries can be exempted based on name,  |
|                            | source subnet, or the DNS server interface address where the query was received. |
+----------------------------+----------------------------------------------------------------------------------+
| DnsPolicyMax               | Shows the maximum DNS policies supported.                                        |
+----------------------------+----------------------------------------------------------------------------------+

var (
	PolicyTypeQueryProcessing PolicyType = 0
	PolicyTypeZoneTransfer    PolicyType = 1
	PolicyTypeDynamicUpdate   PolicyType = 2
	PolicyTypeRecursion       PolicyType = 3
	PolicyTypeMax             PolicyType = 4
)

func (PolicyType) String 

func (o PolicyType) String() string

type RRLModeEnum 

type RRLModeEnum uint16

RRLModeEnum type represents DNS_RRL_MODE_ENUM RPC enumeration.

The DNS_RRL_MODE_ENUM enumeration controls the behavior and application of DNS Response Rate Limiting at the server level. 

var (
	// DnsRRLLogOnly: This is the simulation mode for RRL, where the impact of RRL is logged
	// in analytical channel logs but no actual action is taken (that is, responses are
	// not dropped).
	RRLModeEnumLogOnly RRLModeEnum = 0
	// DnsRRLEnabled: In this mode, the RRL algorithm is applied to every incoming query.
	RRLModeEnumEnabled RRLModeEnum = 1
	// DnsRRLDisabled: This mode ensures RRL is disabled and not applied to any incoming
	// query.
	RRLModeEnumDisabled RRLModeEnum = 2
)

func (RRLModeEnum) String 

func (o RRLModeEnum) String() string

type RRLParams 

type RRLParams struct {
	// dwResponsesPerSecond: The maximum number of responses a DNS server can give for each
	// successful "unique response" in one-second intervals. A DNS response is considered
	// a unique response if the combination of the following parameters is unique: the requestor's
	// IP address, masked according to either dwIPv4PrefixLength or dwIPv6PrefixLength;
	// an imputed domain name that is either a wildcard (if a wildcard match occurred),
	// the zone name (if no match occurred), or the query name; and a Boolean error indicator
	// (response code Refused, FormError, or ServFail).
	//
	// This parameter can be set any positive integer; the default value is 5.
	ResponsesPerSecond uint32 `idl:"name:dwResponsesPerSecond" json:"responses_per_second"`
	// dwErrorsPerSecond: The maximum number of responses a DNS server can give for queries
	// resulting in error (ServFail, FormError, Refused) in one-second intervals. This parameter
	// can be set to any positive integer; the default value is 5.
	ErrorsPerSecond uint32 `idl:"name:dwErrorsPerSecond" json:"errors_per_second"`
	// dwLeakRate: When a query would be dropped due to rate limiting, the DNS server responds
	// once per Leak Rate query. The default value for this parameter is 3. This parameter
	// can be set to any positive integer greater than 1. If the value is set to 0, this
	// behavior is disabled.
	LeakRate uint32 `idl:"name:dwLeakRate" json:"leak_rate"`
	// dwTCRate: When a query would be dropped due to rate limiting, the DNS server returns
	// a truncated response once per TC rate query. The default value for this parameter
	// is 2. The parameter can be set to any positive integer greater than 1. If the value
	// is set to 0, the behavior is disabled (see [RRL] section 2.2.8).
	TCRate uint32 `idl:"name:dwTCRate" json:"tc_rate"`
	// dwTotalResponsesInWindow: The maximum number of responses the DNS server can give
	// for each "unique response" in the defined window duration. See dwResponsesPerSecond
	// for the definition of "unique response". This includes responses given from leak
	// rate, truncation rate, and responses per second / errors per second. The default
	// value for this parameter is 1024. This parameter can be set any positive integer.
	TotalResponsesInWindow uint32 `idl:"name:dwTotalResponsesInWindow" json:"total_responses_in_window"`
	// dwWindowSize: The duration, in seconds, where the state of dwTotalResponsesInWindow
	// is maintained for each "unique response". See dwResponsesPerSecond for the definition
	// of "unique response". After this duration, the value for dwTotalResponsesInWindow
	// is reset to 0. The default value for this parameter is 5. The parameter can be set
	// to any positive integer (see [RRL] section 2.2.4).
	WindowSize uint32 `idl:"name:dwWindowSize" json:"window_size"`
	// dwIPv4PrefixLength: Controls how the DNS query source IPv4 addresses are grouped
	// into buckets of size (32 – dwIPv4PrefixLength) ^ 2. The default value for this
	// parameter is 24. The parameter can be set to any positive integer between 0 and 32.
	IPv4PrefixLength uint32 `idl:"name:dwIPv4PrefixLength" json:"ipv4_prefix_length"`
	// dwIPv6PrefixLength: Controls how DNS query source IPv6 addresses are grouped into
	// buckets of size (32 – dwIPv6PrefixLength) ^ 2. The default value for this parameter
	// is 56. This parameter can be set any positive integer between 0 and 128.
	IPv6PrefixLength uint32 `idl:"name:dwIPv6PrefixLength" json:"ipv6_prefix_length"`
	// eMode: The mode in which RRL functions on a DNS server.
	Mode RRLModeEnum `idl:"name:eMode" json:"mode"`
	// dwFlags: This is used during the update of a DNS Response Rate Limiting. The various
	// bits show which members of the DNS RRL are to be updated. For possible values, see
	// section 2.2.16.1.1. For details on how this is used for setting RRL, see the operation
	// SetRRL in section 3.1.4.1. If dwFlags is not set for a configuration parameter, default
	// values are applied as shown in the following table:
	//
	//	+-----------------------------+-----------------+
	//	|      RRL CONFIGURATION      |     DEFAULT     |
	//	|          PARAMETER          |     VALUES      |
	//	+-----------------------------+-----------------+
	//	+-----------------------------+-----------------+
	//	| dwResponsesPerSecond        |               5 |
	//	+-----------------------------+-----------------+
	//	| dwErrorsPerSecond           |               5 |
	//	+-----------------------------+-----------------+
	//	| dwLeakRate                  |               3 |
	//	+-----------------------------+-----------------+
	//	| dwTCRate                    |               2 |
	//	+-----------------------------+-----------------+
	//	| dwTotalResponsesInWindow    |            1024 |
	//	+-----------------------------+-----------------+
	//	| dwWindowSize                |               5 |
	//	+-----------------------------+-----------------+
	//	| dwIPv4PrefixLength          |              24 |
	//	+-----------------------------+-----------------+
	//	| dwIPv6PrefixLength          |              56 |
	//	+-----------------------------+-----------------+
	//	| eMode                       | DnsRRLDisabled  |
	//	+-----------------------------+-----------------+
	Flags uint32 `idl:"name:dwFlags" json:"flags"`
	// fSetDefault: Set this value to TRUE to set RRL parameters to their default values.
	// This parameter does not affect the eMode parameter of RRL.
	SetDefault bool `idl:"name:fSetDefault" json:"set_default"`
}

RRLParams structure represents DNS_RPC_RRL_PARAMS RPC structure.

The DNS_RPC_RRL_PARAMS structure SHOULD<93> contain the configuration parameters for the Response Rate Limiting capability configured on the DNS server.

func (*RRLParams) MarshalNDR 

func (o *RRLParams) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*RRLParams) UnmarshalNDR 

func (o *RRLParams) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type RRLStats 

type RRLStats struct {
	// Header (8 bytes): A structure of type DNSSRV_STAT_HEADER (section 2.2.10.2.1).
	Header *StatHeader `idl:"name:Header" json:"header"`
	// TotalResponsesSent (4 bytes): The number of times the server responded to a valid
	// query since it last started. This counter is maintained and updated only when RRL
	// is enabled. After reaching 0xFFFFFFFF, the value increments to 0x00000000.
	TotalResponsesSent uint32 `idl:"name:TotalResponsesSent" json:"total_responses_sent"`
	// TotalResponsesDropped (4 bytes): The number of times the server dropped a valid query
	// due to Response Rate Limiting, since it last started. This counter is maintained
	// and updated only when RRL is enabled. After reaching 0xFFFFFFFF, the value increments
	// to 0x00000000.
	TotalResponsesDropped uint32 `idl:"name:TotalResponsesDropped" json:"total_responses_dropped"`
	// TotalResponsesTruncated (4 bytes): The number of times the server has responded to
	// a valid query with a truncation bit set, since it last started. This counter is maintained
	// and updated only when RRL is enabled. After reaching 0xFFFFFFFF, the value increments
	// to 0x00000000.
	TotalResponsesTruncated uint32 `idl:"name:TotalResponsesTruncated" json:"total_responses_truncated"`
	// TotalResponsesLeaked (4 bytes): The number of times the server has responded to a
	// valid query after using the total responses available within a given timeframe since
	// it last started. For details see DNS_RPC_RRL_PARAMS (section 2.2.16.2.1). This counter
	// is maintained and updated only when RRL is enabled. After reaching 0xFFFFFFFF, the
	// value increments to 0x00000000.
	TotalResponsesLeaked uint32 `idl:"name:TotalResponsesLeaked" json:"total_responses_leaked"`
}

RRLStats structure represents DNSSRV_RRL_STATS RPC structure.

The DNSSRV_RRL_STATS structure SHOULD<78> contain DNS server statistics related to the Response Rate Limiting (RRL). This structure is formatted as follows: 

+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 1 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 2 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 3 | 1 |
|   |   |   |   |   |   |   |   |   |   | 0 |   |   |   |   |   |   |   |   |   | 0 |   |   |   |   |   |   |   |   |   | 0 |   |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| Header                                                                                                                        |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| ...                                                                                                                           |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| TotalResponsesSent                                                                                                            |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| TotalResponsesDropped                                                                                                         |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| TotalResponsesTruncated                                                                                                       |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| TotalResponsesLeaked                                                                                                          |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+

func (*RRLStats) MarshalNDR 

func (o *RRLStats) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*RRLStats) UnmarshalNDR 

func (o *RRLStats) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type Record 

type Record struct {
	// wDataLength: The total size of the variable buffer, in bytes. Note that the DNS_RPC_RECORD
	// structure is always 4-byte aligned, which means there can be 0-3 bytes of padding
	// at the end of the structure. The pad bytes are not included in the wDataLength count.
	DataLength uint16 `idl:"name:wDataLength" json:"data_length"`
	// wType: The type of the resource record, as specified in section 2.2.2.1.1 DNS_RECORD_TYPE.
	Type uint16 `idl:"name:wType" json:"type"`
	// dwFlags: Resource record properties. This field can contain one of the RANK* flags
	// in the low-order bits and one of the DNS_RPC_FLAGS* in the high-order bits.
	//
	//	+--------------------------------------------+----------------------------------------------------------------------------------+
	//	|                                            |                                                                                  |
	//	|                   VALUE                    |                                     MEANING                                      |
	//	|                                            |                                                                                  |
	//	+--------------------------------------------+----------------------------------------------------------------------------------+
	//	+--------------------------------------------+----------------------------------------------------------------------------------+
	//	| RANK_CACHE_BIT 0x00000001                  | The record came from the cache.                                                  |
	//	+--------------------------------------------+----------------------------------------------------------------------------------+
	//	| RANK_ROOT_HINT 0x00000008                  | The record is a preconfigured root hint.                                         |
	//	+--------------------------------------------+----------------------------------------------------------------------------------+
	//	| RANK_OUTSIDE_GLUE 0x00000020               | This value is not used.                                                          |
	//	+--------------------------------------------+----------------------------------------------------------------------------------+
	//	| RANK_CACHE_NA_ADDITIONAL 0x00000031        | The record was cached from the additional section of a non-authoritative         |
	//	|                                            | response.                                                                        |
	//	+--------------------------------------------+----------------------------------------------------------------------------------+
	//	| RANK_CACHE_NA_AUTHORITY 0x00000041         | The record was cached from the authority section of a non-authoritative          |
	//	|                                            | response.                                                                        |
	//	+--------------------------------------------+----------------------------------------------------------------------------------+
	//	| RANK_CACHE_A_ADDITIONAL 0x00000051         | The record was cached from the additional section of an authoritative response.  |
	//	+--------------------------------------------+----------------------------------------------------------------------------------+
	//	| RANK_CACHE_NA_ANSWER 0x00000061            | The record was cached from the answer section of a non-authoritative response.   |
	//	+--------------------------------------------+----------------------------------------------------------------------------------+
	//	| RANK_CACHE_A_AUTHORITY 0x00000071          | The record was cached from the authority section of an authoritative response.   |
	//	+--------------------------------------------+----------------------------------------------------------------------------------+
	//	| RANK_GLUE 0x00000080                       | The record is a glue record in an authoritative zone.                            |
	//	+--------------------------------------------+----------------------------------------------------------------------------------+
	//	| RANK_NS_GLUE 0x00000082                    | The record is a delegation  (type NS) record in an authoritative zone.           |
	//	+--------------------------------------------+----------------------------------------------------------------------------------+
	//	| RANK_CACHE_A_ANSWER 0x000000C1             | The record was cached from the answer section of an authoritative response.      |
	//	+--------------------------------------------+----------------------------------------------------------------------------------+
	//	| RANK_ZONE 0x000000F0                       | The record comes from an authoritative zone.                                     |
	//	+--------------------------------------------+----------------------------------------------------------------------------------+
	//	| DNS_RPC_FLAG_ZONE_ROOT 0x40000000          | The record is at the root of a zone (not necessarily a zone hosted by this       |
	//	|                                            | server; the record could have come from the cache).                              |
	//	+--------------------------------------------+----------------------------------------------------------------------------------+
	//	| DNS_RPC_FLAG_AUTH_ZONE_ROOT 0x20000000     | The record is at the root of a zone that is locally hosted on this server.       |
	//	+--------------------------------------------+----------------------------------------------------------------------------------+
	//	| DNS_RPC_FLAG_CACHE_DATA 0x80000000         | The record came from the cache.                                                  |
	//	+--------------------------------------------+----------------------------------------------------------------------------------+
	//	| DNS_RPC_FLAG_RECORD_WIRE_FORMAT 0x00100000 | The record SHOULD<25> be treated as a resource record of unknown type ([RFC3597] |
	//	|                                            | section 2) by the DNS server.                                                    |
	//	+--------------------------------------------+----------------------------------------------------------------------------------+
	Flags uint32 `idl:"name:dwFlags" json:"flags"`
	// dwSerial: This MUST be set to 0x00000000 when sent by the client or server, and ignored
	// on receipt by the server or client.
	Serial uint32 `idl:"name:dwSerial" json:"serial"`
	// dwTtlSeconds: The duration, in seconds, after which this record will expire.
	TTLSeconds uint32 `idl:"name:dwTtlSeconds" json:"ttl_seconds"`
	// dwTimeStamp: The time stamp, in hours, for the record when it received the last update.
	Timestamp uint32 `idl:"name:dwTimeStamp" json:"timestamp"`

	// Buffer: Record data in DNS_RPC_RECORD_DATA (section 2.2.2.2.4) format where type
	// is specified by the value wType.<26>
	//
	//	+----------------------------+--------------------------------+
	//	|                            |                                |
	//	|           VALUE            |            MEANING             |
	//	|                            |                                |
	//	+----------------------------+--------------------------------+
	//	+----------------------------+--------------------------------+
	//	| DNS_TYPE_ZERO 0x0000       | DNS_RPC_RECORD_TS              |
	//	+----------------------------+--------------------------------+
	//	| DNS_TYPE_A 0x0001          | DNS_RPC_RECORD_A               |
	//	+----------------------------+--------------------------------+
	//	| DNS_TYPE_NS 0x0002         | DNS_RPC_RECORD_NODE_NAME       |
	//	+----------------------------+--------------------------------+
	//	| DNS_TYPE_MD 0x0003         | DNS_RPC_RECORD_NODE_NAME       |
	//	+----------------------------+--------------------------------+
	//	| DNS_TYPE_MF 0x0004         | DNS_RPC_RECORD_NODE_NAME       |
	//	+----------------------------+--------------------------------+
	//	| DNS_TYPE_CNAME 0x0005      | DNS_RPC_RECORD_NODE_NAME       |
	//	+----------------------------+--------------------------------+
	//	| DNS_TYPE_SOA 0x0006        | DNS_RPC_RECORD_SOA             |
	//	+----------------------------+--------------------------------+
	//	| DNS_TYPE_MB 0x0007         | DNS_RPC_RECORD_NODE_NAME       |
	//	+----------------------------+--------------------------------+
	//	| DNS_TYPE_MG 0x0008         | DNS_RPC_RECORD_NODE_NAME       |
	//	+----------------------------+--------------------------------+
	//	| DNS_TYPE_MR 0x0009         | DNS_RPC_RECORD_NODE_NAME       |
	//	+----------------------------+--------------------------------+
	//	| DNS_TYPE_NULL 0x000A       | DNS_RPC_RECORD_NULL            |
	//	+----------------------------+--------------------------------+
	//	| DNS_TYPE_WKS 0x000B        | DNS_RPC_RECORD_WKS             |
	//	+----------------------------+--------------------------------+
	//	| DNS_TYPE_PTR 0x000C        | DNS_RPC_RECORD_NODE_NAME       |
	//	+----------------------------+--------------------------------+
	//	| DNS_TYPE_HINFO 0x000D      | DNS_RPC_RECORD_STRING          |
	//	+----------------------------+--------------------------------+
	//	| DNS_TYPE_MINFO 0x000E      | DNS_RPC_RECORD_MAIL_ERROR      |
	//	+----------------------------+--------------------------------+
	//	| DNS_TYPE_MX 0x000F         | DNS_RPC_RECORD_NAME_PREFERENCE |
	//	+----------------------------+--------------------------------+
	//	| DNS_TYPE_TXT 0x0010        | DNS_RPC_RECORD_STRING          |
	//	+----------------------------+--------------------------------+
	//	| DNS_TYPE_RP 0x0011         | DNS_RPC_RECORD_MAIL_ERROR      |
	//	+----------------------------+--------------------------------+
	//	| DNS_TYPE_AFSDB 0x0012      | DNS_RPC_RECORD_NAME_PREFERENCE |
	//	+----------------------------+--------------------------------+
	//	| DNS_TYPE_X25 0x0013        | DNS_RPC_RECORD_STRING          |
	//	+----------------------------+--------------------------------+
	//	| DNS_TYPE_ISDN 0x0014       | DNS_RPC_RECORD_STRING          |
	//	+----------------------------+--------------------------------+
	//	| DNS_TYPE_RT 0x0015         | DNS_RPC_RECORD_NAME_PREFERENCE |
	//	+----------------------------+--------------------------------+
	//	| DNS_TYPE_SIG 0x0018        | DNS_RPC_RECORD_SIG             |
	//	+----------------------------+--------------------------------+
	//	| DNS_TYPE_KEY 0x0019        | DNS_RPC_RECORD_KEY             |
	//	+----------------------------+--------------------------------+
	//	| DNS_TYPE_AAAA 0x001C       | DNS_RPC_RECORD_AAAA            |
	//	+----------------------------+--------------------------------+
	//	| DNS_TYPE_NXT 0x001E        | DNS_RPC_RECORD_NXT             |
	//	+----------------------------+--------------------------------+
	//	| DNS_TYPE_SRV 0x0021        | DNS_RPC_RECORD_SRV             |
	//	+----------------------------+--------------------------------+
	//	| DNS_TYPE_ATMA 0x0022       | DNS_RPC_RECORD_ATMA            |
	//	+----------------------------+--------------------------------+
	//	| DNS_TYPE_NAPTR 0x0023      | DNS_RPC_RECORD_NAPTR           |
	//	+----------------------------+--------------------------------+
	//	| DNS_TYPE_DNAME 0x0027      | DNS_RPC_RECORD_NODE_NAME       |
	//	+----------------------------+--------------------------------+
	//	| DNS_TYPE_DS 0x002B         | DNS_RPC_RECORD_DS              |
	//	+----------------------------+--------------------------------+
	//	| DNS_TYPE_RRSIG 0x002E      | DNS_RPC_RECORD_RRSIG           |
	//	+----------------------------+--------------------------------+
	//	| DNS_TYPE_NSEC 0x002F       | DNS_RPC_RECORD_NSEC            |
	//	+----------------------------+--------------------------------+
	//	| DNS_TYPE_DNSKEY 0x0030     | DNS_RPC_RECORD_DNSKEY          |
	//	+----------------------------+--------------------------------+
	//	| DNS_TYPE_DHCID 0x0031      | DNS_RPC_RECORD_DHCID           |
	//	+----------------------------+--------------------------------+
	//	| DNS_TYPE_NSEC3 0x0032      | DNS_RPC_RECORD_NSEC3           |
	//	+----------------------------+--------------------------------+
	//	| DNS_TYPE_NSEC3PARAM 0x0033 | DNS_RPC_RECORD_NSEC3PARAM      |
	//	+----------------------------+--------------------------------+
	//	| DNS_TYPE_TLSA 0x0034       | DNS_RPC_RECORD_TLSA            |
	//	+----------------------------+--------------------------------+
	//	| DNS_TYPE_WINS 0xFF01       | DNS_RPC_RECORD_WINS            |
	//	+----------------------------+--------------------------------+
	//	| DNS_TYPE_WINSR 0xFF02      | DNS_RPC_RECORD_WINSR           |
	//	+----------------------------+--------------------------------+
	Buffer []byte `idl:"name:Buffer;size_is:(wDataLength)" json:"buffer"`
	// contains filtered or unexported fields
}

Record structure represents DNS_RPC_RECORD RPC structure.

The DNS_RPC_RECORD structure is used to specify a single DNS record's parameters and data. This structure is returned by the DNS server in response to an R_DnssrvEnumRecords2 (section 3.1.4.9) method call.

func (*Record) MarshalNDR 

func (o *Record) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*Record) NDRSizeInfo 

func (o *Record) NDRSizeInfo() []uint64

func (*Record) UnmarshalNDR 

func (o *Record) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type SKD 

type SKD struct {
	// dwRpcStructureVersion: The structure version number; this MUST be set to 0x00000001.
	RPCStructureVersion uint32 `idl:"name:dwRpcStructureVersion" json:"rpc_structure_version"`

	// Guid: A unique identifier for this signing key descriptor.
	GUID *dtyp.GUID `idl:"name:Guid" json:"guid"`
	// pwszKeyStorageProvider: The Key Storage Provider that will be used to generate and
	// store keys for this signing key descriptor.
	KeyStorageProvider string `idl:"name:pwszKeyStorageProvider;string" json:"key_storage_provider"`
	// fStoreKeysInDirectory: A value of 0x00000001 indicates that the DNS server exports
	// keys generated for this signing key descriptor and stores them on the DNS zone object
	// in Active Directory. A value of 0x00000000 indicates that the DNS server stores keys
	// in self-signed certificates in the local machine certificate store.
	StoreKeysInDirectory bool `idl:"name:fStoreKeysInDirectory" json:"store_keys_in_directory"`
	// fIsKSK: A value of 0x00000001 indicates that this signing key descriptor describes
	// a key signing key (KSK); a value of 0x00000000 indicates a zone signing key [RFC4641].
	IsKSK bool `idl:"name:fIsKSK" json:"is_ksk"`
	// bSigningAlgorithm: The cryptographic algorithm used to generate signing keys. The
	// DNS server SHOULD<48> support all values given by [IANA-DNSSECAN] and [DRAFT-DNSSEC-ECDSA].
	SigningAlgorithm uint8 `idl:"name:bSigningAlgorithm" json:"signing_algorithm"`
	// dwKeyLength: The length, in bits, of cryptographic signing keys. This value MUST
	// be ignored if the signing algorithm does not have variable key length.
	KeyLength uint32 `idl:"name:dwKeyLength" json:"key_length"`
	// dwInitialRolloverOffset: The amount of time, in seconds, to delay the first scheduled
	// key rollover for this signing key descriptor. The value SHOULD be limited to the
	// range 0x00000000 to 0x00278D00 (30 days), inclusive, but it can be any value. The
	// default value SHOULD be 0x00000000, and the value zero MUST be allowed and treated
	// literally.
	InitialRolloverOffset uint32 `idl:"name:dwInitialRolloverOffset" json:"initial_rollover_offset"`
	// dwDNSKEYSignatureValidityPeriod: The number of seconds that signatures covering DNSKEY
	// record sets generated for this signing key descriptor's keys are valid, as defined
	// by [RFC4034] section 3.1.5. The value SHOULD be limited to the range 0x00005460 (6
	// hours) to 0x00093A80 (7 days), inclusive, but it can be any value. The default value
	// SHOULD be 0x0003F480 (3 days).
	DNSKEYSignatureValidityPeriod uint32 `idl:"name:dwDNSKEYSignatureValidityPeriod" json:"dnskey_signature_validity_period"`
	// dwDSSignatureValidityPeriod: The number of seconds that signatures covering DS record
	// sets generated for this signing key descriptor's keys are valid, as defined by [RFC4034]
	// section 3.1.5. The value SHOULD be limited to the range 0x00005460 (6 hours) to 0x00093A80
	// (7 days), inclusive, but it can be any value. The default value SHOULD be 0x0003F480
	// (3 days).
	DSSignatureValidityPeriod uint32 `idl:"name:dwDSSignatureValidityPeriod" json:"ds_signature_validity_period"`
	// dwStandardSignatureValidityPeriod: The number of seconds that signatures covering
	// record sets not of type DNSKEY or DS generated for this signing key descriptor's
	// keys are valid, as defined by [RFC4034] section 3.1.5. The value SHOULD be limited
	// to the range 0x00005460 (6 hours) to 0x00278D00 (30 days), inclusive, but it can
	// be any value. The default value SHOULD be 0x000D2F00 (10 days).
	StandardSignatureValidityPeriod uint32 `idl:"name:dwStandardSignatureValidityPeriod" json:"standard_signature_validity_period"`
	// dwRolloverType: When sent, this value MUST be set to one of the allowed values specified
	// in ZONE_SKD_ROLLOVER_TYPE (section 2.2.5.1.5) as follows: this value MUST be DNS_ROLLOVER_TYPE_PREPUBLISH
	// if fIsKSK is 0x00000000 and MUST be DNS_ROLLOVER_TYPE_DOUBLE_SIGNATURE if fIsKSK
	// is 0x00000001. On receipt, this value MUST be ignored.
	RolloverType uint32 `idl:"name:dwRolloverType" json:"rollover_type"`
	// dwRolloverPeriod: The number of seconds between scheduled key rollovers, or 0xFFFFFFFF
	// to disable automatic key rollovers. This value SHOULD be limited to the range 0x00093A80
	// (1 week) to 0x25980600 (20 years), inclusive, in addition to 0xFFFFFFFF, when fIsKSK
	// is 0x00000001, and the range 0x00093A80 (1 week) to 0x09660180 (5 years), inclusive,
	// in addition to 0xFFFFFFFF, when fIsKSK is 0x00000000. The default SHOULD be 0x02022900
	// (13 months) when fIsKSK is 0x00000001, and 0x0x00278D00 (1 month) when fIsKSK is
	// 0x00000000.
	RolloverPeriod uint32 `idl:"name:dwRolloverPeriod" json:"rollover_period"`
	// dwNextRolloverAction: This value describes the next key rollover action that the
	// DNS server will take for this signing key descriptor. This value MUST be set to one
	// of the allowed values specified in ZONE_SKD_ROLLOVER_ACTION (section 2.2.5.1.6).
	NextRolloverAction uint32 `idl:"name:dwNextRolloverAction" json:"next_rollover_action"`
	// contains filtered or unexported fields
}

SKD structure represents DNS_RPC_SKD RPC structure.

The DNS_RPC_SKD structure specifies a signing key descriptor.

func (*SKD) MarshalNDR 

func (o *SKD) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*SKD) UnmarshalNDR 

func (o *SKD) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type SKDList 

type SKDList struct {
	// dwRpcStructureVersion: The structure version number; this MUST be set to 0x00000001.
	RPCStructureVersion uint32 `idl:"name:dwRpcStructureVersion" json:"rpc_structure_version"`

	// dwCount: The number of signing key descriptors present in the array of signing key
	// descriptors pointed to by SkdArray.
	Count uint32 `idl:"name:dwCount" json:"count"`
	// SkdArray: An array of structures of type DNS_RPC_SKD (section 2.2.6.2.1). Each element
	// of the array represents one signing key descriptor.
	SKDArray []*SKD `idl:"name:SkdArray;size_is:(dwCount)" json:"skd_array"`
	// contains filtered or unexported fields
}

SKDList structure represents DNS_RPC_SKD_LIST RPC structure.

The DNS_RPC_SKD_LIST structure contains the information about a list of signing key descriptors that are present for a particular zone on the DNS server.

func (*SKDList) MarshalNDR 

func (o *SKDList) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*SKDList) NDRSizeInfo 

func (o *SKDList) NDRSizeInfo() []uint64

func (*SKDList) UnmarshalNDR 

func (o *SKDList) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type SKDState 

type SKDState struct {
	// dwRpcStructureVersion: The structure version number; this MUST be set to 0x00000001.
	RPCStructureVersion uint32 `idl:"name:dwRpcStructureVersion" json:"rpc_structure_version"`

	// Guid: A unique identifier for this signing key descriptor.
	GUID *dtyp.GUID `idl:"name:Guid" json:"guid"`
	// ftLastRolloverTime: The time at which the last successful rollover event was performed
	// for this signing key descriptor. This value MUST be 0 if no rollover has been performed
	// on this signing key descriptor.
	LastRolloverTime *dtyp.Filetime `idl:"name:ftLastRolloverTime" json:"last_rollover_time"`
	// ftNextRolloverTime: The time at which the next rollover for this signing key descriptor
	// is scheduled. This MAY be 0 if no rollover event is scheduled. When the time comes
	// for a key rollover to start, the signing key descriptor is added to the Rollover
	// Queue, and its dwCurrentRolloverStatus is changed to DNS_SKD_STATUS_QUEUED. If another
	// signing key descriptor in the zone is in the process of rolling, ftNextRolloverTime
	// MAY represent a time in the past.
	NextRolloverTime *dtyp.Filetime `idl:"name:ftNextRolloverTime" json:"next_rollover_time"`
	// dwState: The current state of this signing key descriptor. This MUST be set to one
	// of the following values.<49>
	//
	//	+----------------------------------+---------------------------------------------------------------------------------+
	//	|                                  |                                                                                 |
	//	|              VALUE               |                                     MEANING                                     |
	//	|                                  |                                                                                 |
	//	+----------------------------------+---------------------------------------------------------------------------------+
	//	+----------------------------------+---------------------------------------------------------------------------------+
	//	| DNS_SKD_STATE_ACTIVE 0x00000000  | The signing key descriptor is active and in use for online signing of the zone. |
	//	+----------------------------------+---------------------------------------------------------------------------------+
	//	| DNS_SKD_STATE_RETIRED 0x00000001 | The signing key descriptor is no longer in use for online signing.              |
	//	+----------------------------------+---------------------------------------------------------------------------------+
	State uint32 `idl:"name:dwState" json:"state"`
	// dwCurrentRolloverStatus: The current rollover status of this signing key descriptor.
	// This MUST be set to one of the following values, representing the various stages
	// of key rollover as described in [RFC4641] and [RFC5011]:
	//
	//	+-----------------------------------------------------------------+----------------------------------------------------------------------------------+
	//	|                                                                 |                                                                                  |
	//	|                              VALUE                              |                                     MEANING                                      |
	//	|                                                                 |                                                                                  |
	//	+-----------------------------------------------------------------+----------------------------------------------------------------------------------+
	//	+-----------------------------------------------------------------+----------------------------------------------------------------------------------+
	//	| DNS_SKD_STATUS_NOT_ROLLING 0x00000000                           | The signing key descriptor is not currently in the process of rolling over keys. |
	//	+-----------------------------------------------------------------+----------------------------------------------------------------------------------+
	//	| DNS_SKD_STATUS_QUEUED 0x00000001                                | This signing key descriptor is waiting for another rollover to complete          |
	//	|                                                                 | before its rollover can begin. After the signing key descriptor reaches the      |
	//	|                                                                 | head of the Rollover Queue, the signing key descriptor will move into the        |
	//	|                                                                 | DNS_SKD_STATUS_ROLL_STARTED state.                                               |
	//	+-----------------------------------------------------------------+----------------------------------------------------------------------------------+
	//	| DNS_SKD_STATUS_ROLL_STARTED 0x00000002                          | This signing key descriptor has begun the process of key rollover.               |
	//	|                                                                 | Signing key descriptors representing ZSKs will move from this state              |
	//	|                                                                 | to the DNS_SKD_STATUS_ZSK_WAITING_FOR_DNSKEY_TTL state, and signing              |
	//	|                                                                 | key descriptors representing KSKs will move from this state to the               |
	//	|                                                                 | DNS_SKD_STATUS_KSK_WAITING_FOR_DS_UPDATE state.                                  |
	//	+-----------------------------------------------------------------+----------------------------------------------------------------------------------+
	//	| DNS_SKD_STATUS_ZSK_WAITING_FOR_DNSKEY_TTL 0x00000003            | This ZSK signing key descriptor is waiting for the previous key to expire in all |
	//	|                                                                 | caching resolvers (it is waiting for the DNSKEY TTL to expire). The signing key  |
	//	|                                                                 | descriptor will next move into the DNS_SKD_STATUS_ZSK_WAITING_FOR_MAXZONE_TTL    |
	//	|                                                                 | state.                                                                           |
	//	+-----------------------------------------------------------------+----------------------------------------------------------------------------------+
	//	| DNS_SKD_STATUS_ZSK_WAITING_FOR_MAXZONE_TTL 0x00000004           | This ZSK signing key descriptor is waiting for the signatures using the previous |
	//	|                                                                 | key to expire in all caching resolvers (it is waiting for the largest record     |
	//	|                                                                 | TTL to expire). This is the final state for ZSK rollovers. The signing key       |
	//	|                                                                 | descriptor will move into the DNS_SKD_STATUS_NOT_ROLLING state when this portion |
	//	|                                                                 | of key rollover is complete.                                                     |
	//	+-----------------------------------------------------------------+----------------------------------------------------------------------------------+
	//	| DNS_SKD_STATUS_KSK_WAITING_FOR_DS_UPDATE 0x00000005             | This KSK signing key descriptor is waiting for a DS record corresponding to      |
	//	|                                                                 | the new key to appear in the parent zone. If DS records are found in the parent  |
	//	|                                                                 | zone, the server MUST set the zone's "ParentHasSecureDelegation" property        |
	//	|                                                                 | to 0x00000001 and continue to wait until the parent's DS record set includes     |
	//	|                                                                 | the new key, at which point the signing key descriptor will move into the        |
	//	|                                                                 | DNS_SKD_STATUS_KSK_WAITING_FOR_DS_TTL state. If no DS records are found in       |
	//	|                                                                 | the parent zone, the server MUST set the zone's "ParentHasSecureDelegation"      |
	//	|                                                                 | property to 0x00000000 and transition the signing key descriptor into the        |
	//	|                                                                 | DNS_SKD_STATUS_KSK_WAITING_FOR_DNSKEY_TTL state. If there is an error or if the  |
	//	|                                                                 | presence of a DS record set in the parent zone cannot be determined, the server  |
	//	|                                                                 | MUST continue to attempt to query for this record set for up to 15 minutes       |
	//	|                                                                 | if the zone's "ParentHasSecureDelegation" property is 0x00000000 or until the    |
	//	|                                                                 | PokeZoneKeyRollover command is received if it is 0x00000001.                     |
	//	+-----------------------------------------------------------------+----------------------------------------------------------------------------------+
	//	| DNS_SKD_STATUS_KSK_WAITING_FOR_DS_TTL 0x00000006                | This KSK signing key descriptor is waiting for the DS record set in              |
	//	|                                                                 | the parent zone to expire in all caching resolvers (it is waiting                |
	//	|                                                                 | for the parent DS TTL to expire). If the zone's "RFC5011KeyRollovers"            |
	//	|                                                                 | property is TRUE, the signing key descriptor will next move into the             |
	//	|                                                                 | DNS_SKD_STATUS_WAITING_FOR_5011_REMOVE_HOLD_DOWN state. Otherwise, this is a     |
	//	|                                                                 | final state for KSK rollovers, and signing key descriptors will move into the    |
	//	|                                                                 | DNS_SKD_STATUS_NOT_ROLLING state when this portion of key rollover is complete.  |
	//	+-----------------------------------------------------------------+----------------------------------------------------------------------------------+
	//	| DNS_SKD_STATUS_KSK_WAITING_FOR_DNSKEY_TTL 0x00000007            | This KSK signing key descriptor is waiting for the previous key to expire in     |
	//	|                                                                 | all caching resolvers (it is waiting for the DNSKEY TTL to expire). This is a    |
	//	|                                                                 | final state for KSK rollovers, and signing key descriptors will move into the    |
	//	|                                                                 | DNS_SKD_STATUS_NOT_ROLLING state when this portion of key rollover is complete.  |
	//	+-----------------------------------------------------------------+----------------------------------------------------------------------------------+
	//	| DNS_SKD_STATUS_KSK_WAITING_FOR_5011_REMOVE_HOLD_DOWN 0x00000008 | This KSK signing key descriptor is waiting for the RFC5011 remove hold-down      |
	//	|                                                                 | time before the revoked previous key can be removed. This is a final             |
	//	|                                                                 | state for KSK rollovers, and signing key descriptors will move into the          |
	//	|                                                                 | DNS_SKD_STATUS_NOT_ROLLING state when this portion of key rollover is complete.  |
	//	+-----------------------------------------------------------------+----------------------------------------------------------------------------------+
	//	| DNS_SKD_STATUS_ROLL_ERROR 0x00000009                            | This signing key descriptor experienced an unrecoverable error during the key    |
	//	|                                                                 | rollover.                                                                        |
	//	+-----------------------------------------------------------------+----------------------------------------------------------------------------------+
	CurrentRolloverStatus uint32 `idl:"name:dwCurrentRolloverStatus" json:"current_rollover_status"`
	// pwszActiveKey: Signing key pointer string for the signing key descriptor's currently
	// active key. This is the key that is currently being used to sign zone records.
	ActiveKey string `idl:"name:pwszActiveKey;string" json:"active_key"`
	// pwszStandbyKey: Signing key pointer string for the signing key descriptor's standby
	// key. The key represented by this string has several different roles depending on
	// the associated signing key descriptor's fIsKSK flag and its dwRolloverStatus:
	//
	// * If the signing key descriptor's fIsKSK flag is TRUE, pwszStandbyKey represents
	// the "double signature" key as described in [RFC4641] section 4.2.2, also depicted
	// as the "standby" key in [RFC5011] section 6.
	//
	// * If the signing key descriptor's fIsKSK flag is FALSE, *pwszStandbyKey* will generally
	// be NULL unless the SKD is in the process of key rollover:
	//
	// * If the signing key descriptor's dwRolloverStatus is DNS_SKD_STATUS_ZSK_WAITING_FOR_DNSKEY_TTL,
	// *pwszStandbyKey* represents the "pre-publish" key as described in [RFC4641] section
	// 4.2.1.1.
	//
	// * If the signing key descriptor's dwRolloverStatus is DNS_SKD_STATUS_ZSK_WAITING_FOR_MAXZONE_TTL,
	// *pwszStandbyKey* represents the previously active key during the "new RRSIGs" phase
	// of Pre-Publish Key Rollover, as described in [RFC4641] section 4.2.1.1.
	StandbyKey string `idl:"name:pwszStandbyKey;string" json:"standby_key"`
	// pwszNextKey: Signing key pointer string for the signing key descriptor's next key.
	// The key represented by this string has several different roles depending on the associated
	// signing key descriptor's fIsKSK flag:
	//
	// * If the signing key descriptor's fIsKSK flag is TRUE, *pwszNextKey* represents the
	// next key that will be consumed during key rollover. It is not published in the zone
	// and is not used to sign any other records. If the zone's "RFC5011KeyRollovers" property
	// is TRUE, this key becomes the next "standby" key according to [RFC5011]. Otherwise,
	// this key is used as the "double signature" key according to [RFC4641] as the signing
	// key descriptor's key rollover process begins.
	//
	// * If the signing key descriptor's fIsKSK flag is FALSE, *pwszNextKey* represents
	// the "pre-publish" key as described in [RFC4641] section 4.2.1.1. When the SKD is
	// in the process of key rollover, *pwszNextKey* can be populated with a newly generated
	// post-rollover "pre-publish" key.
	NextKey string `idl:"name:pwszNextKey;string" json:"next_key"`
	// contains filtered or unexported fields
}

SKDState structure represents DNS_RPC_SKD_STATE RPC structure.

The DNS_RPC_SKD_STATE structure contains information about the current state of a signing key descriptor.

func (*SKDState) MarshalNDR 

func (o *SKDState) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*SKDState) UnmarshalNDR 

func (o *SKDState) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type SKDStateEx 

type SKDStateEx struct {
	// dwRpcStructureVersion: The structure version number; this MUST be set to 0x00000001.
	RPCStructureVersion uint32 `idl:"name:dwRpcStructureVersion" json:"rpc_structure_version"`

	// Guid: A unique identifier for this signing key descriptor.
	GUID *dtyp.GUID `idl:"name:Guid" json:"guid"`
	// dwCurrentRollState: The current rollover status of this signing key descriptor. Note
	// that these are DNS Server Management Protocol implementations of the protocol specified
	// rollover states of SKDs in DNS_RPC_SKD_STATE.
	//
	//	+-------------------------------------------------------------+----------------------------------------------------------------------------------+
	//	|                                                             |                                    MAPPING IN                                    |
	//	|                            VALUE                            |                                DNS RPC SKD STATE                                 |
	//	|                                                             |                                                                                  |
	//	+-------------------------------------------------------------+----------------------------------------------------------------------------------+
	//	+-------------------------------------------------------------+----------------------------------------------------------------------------------+
	//	| DNS_SKD_ROLL_STATE_NOT_STARTED 0x00000000                   | DNS_SKD_STATUS_NOT_ROLLING                                                       |
	//	+-------------------------------------------------------------+----------------------------------------------------------------------------------+
	//	| DNS_SKD_ROLL_STATE_ZSK_SWAP_ACTIVE_WITH_ROLLOVER 0x00000001 | DNS_SKD_STATUS_ZSK_WAITING_FOR_DNSKEY_TTL                                        |
	//	+-------------------------------------------------------------+----------------------------------------------------------------------------------+
	//	| DNS_SKD_ROLL_STATE_ZSK_FINISH 0x00000002                    | DNS_SKD_STATUS_ZSK_WAITING_FOR_MAXZONE_TTL                                       |
	//	+-------------------------------------------------------------+----------------------------------------------------------------------------------+
	//	| DNS_SKD_ROLL_STATE_KSK_WAITING_FOR_DS 0x00000003            | DNS_SKD_STATUS_KSK_WAITING_FOR_DS_UPDATE                                         |
	//	+-------------------------------------------------------------+----------------------------------------------------------------------------------+
	//	| DNS_SKD_ROLL_STATE_KSK_REVOKE 0x00000004                    | DNS_SKD_STATUS_KSK_WAITING_FOR_DS_TTL The key is revoked once the rollover is    |
	//	|                                                             | completed.                                                                       |
	//	+-------------------------------------------------------------+----------------------------------------------------------------------------------+
	//	| DNS_SKD_ROLL_STATE_KSK_FINISH 0x00000005                    | DNS_SKD_STATUS_KSK_WAITING_FOR_DS_TTL The key is not revoked and is used with    |
	//	|                                                             | the rolled over key-set.                                                         |
	//	+-------------------------------------------------------------+----------------------------------------------------------------------------------+
	//	| DNS_SKD_ROLL_STATE_MAX 0x00000005                           | DNS_SKD_STATUS_KSK_WAITING_FOR_DS_TTL                                            |
	//	+-------------------------------------------------------------+----------------------------------------------------------------------------------+
	//	| DNS_SKD_STATUS_ROLL_ERROR 0x00000009                        | This signing key descriptor experienced an unrecoverable error during the key    |
	//	|                                                             | rollover.                                                                        |
	//	+-------------------------------------------------------------+----------------------------------------------------------------------------------+
	CurrentRollState uint32 `idl:"name:dwCurrentRollState" json:"current_roll_state"`
	// fManualTrigger: TRUE if the rollover was triggered manually.
	ManualTrigger uint32 `idl:"name:fManualTrigger" json:"manual_trigger"`
	// dwPreRollEventFired: Specifies which prerollover event has been fired.
	PreRollEventFired uint32 `idl:"name:dwPreRollEventFired" json:"pre_roll_event_fired"`
	// ftNextKeyGenerationTime: The time at which the next key was added to the zone.
	NextKeyGenerationTime *dtyp.Filetime `idl:"name:ftNextKeyGenerationTime" json:"next_key_generation_time"`
	// dwRevokedOrSwappedDnskeysLength: The length of the revoked or swapped DNSKEY RRSet.
	RevokedOrSwappedDNSKeysLength uint32 `idl:"name:dwRevokedOrSwappedDnskeysLength" json:"revoked_or_swapped_dns_keys_length"`
	// pRevokedOrSwappedDnskeysBuffer: Presigned DNSKEY RRSet for ZSK swap. This is a pointer
	// to a pointer that points to a buffer containing the enumerated records. The buffer
	// is a series of structures beginning with a DNS_RPC_NODE structure (section 2.2.2.2.3).
	// The records for the node will be represented by a series of DNS_RPC_RECORD structures
	// (section 2.2.2.2.5). The number of DNS_RPC_RECORD structures following a DNS_RPC_NODE
	// structure is given by the wRecordCount member of DNS_RPC_NODE.
	RevokedOrSwappedDNSKeysBuffer []byte `idl:"name:pRevokedOrSwappedDnskeysBuffer;size_is:(dwRevokedOrSwappedDnskeysLength)" json:"revoked_or_swapped_dns_keys_buffer"`
	// dwFinalDnskeysLength: Length of presigned DNSKEY RRSet.
	FinalDNSKeysLength uint32 `idl:"name:dwFinalDnskeysLength" json:"final_dns_keys_length"`
	// pFinalDnskeys: Presigned DNSKEY RRSet Post Rollover. This is a pointer to a pointer
	// that points to a buffer containing the enumerated records. The buffer is a series
	// of structures beginning with a DNS_RPC_NODE structure. The records for the node will
	// be represented by a series of DNS_RPC_RECORD structures. The number of DNS_RPC_RECORD
	// structures following a DNS_RPC_NODE structure is given by the wRecordCount member
	// of DNS_RPC_NODE.
	FinalDNSKeys []byte `idl:"name:pFinalDnskeys;size_is:(dwFinalDnskeysLength)" json:"final_dns_keys"`
	// eActiveKeyScope: Signing key scope for the SKD's active key. The signing key scope
	// is defined in KeySignScope (section 2.2.6.1.2).
	ActiveKeyScope KeySignScope `idl:"name:eActiveKeyScope" json:"active_key_scope"`
	// eStandByKeyScope: Signing key scope for the SKD's standby key. The signing key scope
	// is defined in KeySignScope.
	StandByKeyScope KeySignScope `idl:"name:eStandByKeyScope" json:"stand_by_key_scope"`
	// eNextKeyScope: Signing key scope for the SKD's next key. The signing key scope is
	// defined in KeySignScope.
	NextKeyScope KeySignScope `idl:"name:eNextKeyScope" json:"next_key_scope"`
	// contains filtered or unexported fields
}

SKDStateEx structure represents DNS_RPC_SKD_STATE_EX RPC structure.

The DNS_RPC_SKD_STATE_EX structure <52> represents the collection of extended dynamic configuration information of a signing key descriptor state.

func (*SKDStateEx) MarshalNDR 

func (o *SKDStateEx) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*SKDStateEx) UnmarshalNDR 

func (o *SKDStateEx) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type ServerInfo 

type ServerInfo struct {
	RPCStructureVersion uint32 `idl:"name:dwRpcStructureVersion" json:"rpc_structure_version"`

	Version                  uint32     `idl:"name:dwVersion" json:"version"`
	BootMethod               uint8      `idl:"name:fBootMethod" json:"boot_method"`
	AdminConfigured          bool       `idl:"name:fAdminConfigured" json:"admin_configured"`
	AllowUpdate              bool       `idl:"name:fAllowUpdate" json:"allow_update"`
	DSAvailable              bool       `idl:"name:fDsAvailable" json:"ds_available"`
	ServerName               string     `idl:"name:pszServerName;string" json:"server_name"`
	DSContainer              string     `idl:"name:pszDsContainer;string" json:"ds_container"`
	ServerAddrs              *AddrArray `idl:"name:aipServerAddrs" json:"server_addrs"`
	ListenAddrs              *AddrArray `idl:"name:aipListenAddrs" json:"listen_addrs"`
	Forwarders               *AddrArray `idl:"name:aipForwarders" json:"forwarders"`
	LogFilter                *AddrArray `idl:"name:aipLogFilter" json:"log_filter"`
	LogFilePath              string     `idl:"name:pwszLogFilePath;string" json:"log_file_path"`
	DomainName               string     `idl:"name:pszDomainName;string" json:"domain_name"`
	ForestName               string     `idl:"name:pszForestName;string" json:"forest_name"`
	DomainDirectoryPartition string     `idl:"name:pszDomainDirectoryPartition;string" json:"domain_directory_partition"`
	ForestDirectoryPartition string     `idl:"name:pszForestDirectoryPartition;string" json:"forest_directory_partition"`
	Extensions               string     `idl:"name:pExtensions;string" json:"extensions"`
	LogLevel                 uint32     `idl:"name:dwLogLevel" json:"log_level"`
	DebugLevel               uint32     `idl:"name:dwDebugLevel" json:"debug_level"`
	ForwardTimeout           uint32     `idl:"name:dwForwardTimeout" json:"forward_timeout"`
	RPCProtocol              uint32     `idl:"name:dwRpcProtocol" json:"rpc_protocol"`
	NameCheckFlag            uint32     `idl:"name:dwNameCheckFlag" json:"name_check_flag"`
	AddressAnswerLimitCount  uint32     `idl:"name:cAddressAnswerLimit" json:"address_answer_limit_count"`
	RecursionRetry           uint32     `idl:"name:dwRecursionRetry" json:"recursion_retry"`
	RecursionTimeout         uint32     `idl:"name:dwRecursionTimeout" json:"recursion_timeout"`
	MaxCacheTTL              uint32     `idl:"name:dwMaxCacheTtl" json:"max_cache_ttl"`
	DSPollingInterval        uint32     `idl:"name:dwDsPollingInterval" json:"ds_polling_interval"`
	LocalNetPriorityNetMask  uint32     `idl:"name:dwLocalNetPriorityNetMask" json:"local_net_priority_net_mask"`
	ScavengingInterval       uint32     `idl:"name:dwScavengingInterval" json:"scavenging_interval"`
	DefaultRefreshInterval   uint32     `idl:"name:dwDefaultRefreshInterval" json:"default_refresh_interval"`
	DefaultNoRefreshInterval uint32     `idl:"name:dwDefaultNoRefreshInterval" json:"default_no_refresh_interval"`
	LastScavengeTime         uint32     `idl:"name:dwLastScavengeTime" json:"last_scavenge_time"`
	EventLogLevel            uint32     `idl:"name:dwEventLogLevel" json:"event_log_level"`
	LogFileMaxSize           uint32     `idl:"name:dwLogFileMaxSize" json:"log_file_max_size"`
	DSForestVersion          uint32     `idl:"name:dwDsForestVersion" json:"ds_forest_version"`
	DSDomainVersion          uint32     `idl:"name:dwDsDomainVersion" json:"ds_domain_version"`
	DSDSAVersion             uint32     `idl:"name:dwDsDsaVersion" json:"ds_dsa_version"`
	ReadOnlyDC               bool       `idl:"name:fReadOnlyDC" json:"read_only_dc"`

	AutoReverseZones       bool `idl:"name:fAutoReverseZones" json:"auto_reverse_zones"`
	AutoCacheUpdate        bool `idl:"name:fAutoCacheUpdate" json:"auto_cache_update"`
	RecurseAfterForwarding bool `idl:"name:fRecurseAfterForwarding" json:"recurse_after_forwarding"`
	ForwardDelegations     bool `idl:"name:fForwardDelegations" json:"forward_delegations"`
	NoRecursion            bool `idl:"name:fNoRecursion" json:"no_recursion"`
	SecureResponses        bool `idl:"name:fSecureResponses" json:"secure_responses"`
	RoundRobin             bool `idl:"name:fRoundRobin" json:"round_robin"`
	LocalNetPriority       bool `idl:"name:fLocalNetPriority" json:"local_net_priority"`
	BindSecondaries        bool `idl:"name:fBindSecondaries" json:"bind_secondaries"`
	WriteAuthorityNS       bool `idl:"name:fWriteAuthorityNs" json:"write_authority_ns"`
	StrictFileParsing      bool `idl:"name:fStrictFileParsing" json:"strict_file_parsing"`
	LooseWildcarding       bool `idl:"name:fLooseWildcarding" json:"loose_wildcarding"`
	DefaultAgingState      bool `idl:"name:fDefaultAgingState" json:"default_aging_state"`
	// contains filtered or unexported fields
}

ServerInfo structure represents DNS_RPC_SERVER_INFO RPC structure.

The DNS_RPC_SERVER_INFO structure contains information about the DNS server's configuration and state. There are different versions of the DNS_RPC_SERVER_INFO structure. The DNS server MUST use one of the structures corresponding to the value of the dwClientVersion field in DNS Server Management Protocol method calls (section 3.1.4) as shown in the following table. If the method call does not specify the value of dwClientVersion, the DNS_RPC_SERVER_INFO_W2K version of the structure MUST be used. 

+------------+----------------------------------------------------+
|            |                                                    |
|   VALUE    |                     STRUCTURE                      |
|            |                                                    |
+------------+----------------------------------------------------+
+------------+----------------------------------------------------+
| 0x00000000 | DNS_RPC_SERVER_INFO_W2K (section 2.2.4.2.2.1)      |
+------------+----------------------------------------------------+
| 0x00060000 | DNS_RPC_SERVER_INFO_DOTNET (section 2.2.4.2.2.2)   |
+------------+----------------------------------------------------+
| 0x00070000 | DNS_RPC_SERVER_INFO_LONGHORN (section 2.2.4.2.2.3) |
+------------+----------------------------------------------------+

func (*ServerInfo) MarshalNDR 

func (o *ServerInfo) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*ServerInfo) UnmarshalNDR 

func (o *ServerInfo) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type ServerInfoLonghorn 

type ServerInfoLonghorn struct {
	RPCStructureVersion uint32 `idl:"name:dwRpcStructureVersion" json:"rpc_structure_version"`

	Version                  uint32     `idl:"name:dwVersion" json:"version"`
	BootMethod               uint8      `idl:"name:fBootMethod" json:"boot_method"`
	AdminConfigured          bool       `idl:"name:fAdminConfigured" json:"admin_configured"`
	AllowUpdate              bool       `idl:"name:fAllowUpdate" json:"allow_update"`
	DSAvailable              bool       `idl:"name:fDsAvailable" json:"ds_available"`
	ServerName               string     `idl:"name:pszServerName;string" json:"server_name"`
	DSContainer              string     `idl:"name:pszDsContainer;string" json:"ds_container"`
	ServerAddrs              *AddrArray `idl:"name:aipServerAddrs" json:"server_addrs"`
	ListenAddrs              *AddrArray `idl:"name:aipListenAddrs" json:"listen_addrs"`
	Forwarders               *AddrArray `idl:"name:aipForwarders" json:"forwarders"`
	LogFilter                *AddrArray `idl:"name:aipLogFilter" json:"log_filter"`
	LogFilePath              string     `idl:"name:pwszLogFilePath;string" json:"log_file_path"`
	DomainName               string     `idl:"name:pszDomainName;string" json:"domain_name"`
	ForestName               string     `idl:"name:pszForestName;string" json:"forest_name"`
	DomainDirectoryPartition string     `idl:"name:pszDomainDirectoryPartition;string" json:"domain_directory_partition"`
	ForestDirectoryPartition string     `idl:"name:pszForestDirectoryPartition;string" json:"forest_directory_partition"`
	Extensions               string     `idl:"name:pExtensions;string" json:"extensions"`
	LogLevel                 uint32     `idl:"name:dwLogLevel" json:"log_level"`
	DebugLevel               uint32     `idl:"name:dwDebugLevel" json:"debug_level"`
	ForwardTimeout           uint32     `idl:"name:dwForwardTimeout" json:"forward_timeout"`
	RPCProtocol              uint32     `idl:"name:dwRpcProtocol" json:"rpc_protocol"`
	NameCheckFlag            uint32     `idl:"name:dwNameCheckFlag" json:"name_check_flag"`
	AddressAnswerLimitCount  uint32     `idl:"name:cAddressAnswerLimit" json:"address_answer_limit_count"`
	RecursionRetry           uint32     `idl:"name:dwRecursionRetry" json:"recursion_retry"`
	RecursionTimeout         uint32     `idl:"name:dwRecursionTimeout" json:"recursion_timeout"`
	MaxCacheTTL              uint32     `idl:"name:dwMaxCacheTtl" json:"max_cache_ttl"`
	DSPollingInterval        uint32     `idl:"name:dwDsPollingInterval" json:"ds_polling_interval"`
	LocalNetPriorityNetMask  uint32     `idl:"name:dwLocalNetPriorityNetMask" json:"local_net_priority_net_mask"`
	ScavengingInterval       uint32     `idl:"name:dwScavengingInterval" json:"scavenging_interval"`
	DefaultRefreshInterval   uint32     `idl:"name:dwDefaultRefreshInterval" json:"default_refresh_interval"`
	DefaultNoRefreshInterval uint32     `idl:"name:dwDefaultNoRefreshInterval" json:"default_no_refresh_interval"`
	LastScavengeTime         uint32     `idl:"name:dwLastScavengeTime" json:"last_scavenge_time"`
	EventLogLevel            uint32     `idl:"name:dwEventLogLevel" json:"event_log_level"`
	LogFileMaxSize           uint32     `idl:"name:dwLogFileMaxSize" json:"log_file_max_size"`
	DSForestVersion          uint32     `idl:"name:dwDsForestVersion" json:"ds_forest_version"`
	DSDomainVersion          uint32     `idl:"name:dwDsDomainVersion" json:"ds_domain_version"`
	DSDSAVersion             uint32     `idl:"name:dwDsDsaVersion" json:"ds_dsa_version"`
	// fReadOnlyDC: A Boolean value that indicates whether the DNS server has access to
	// a directory server that is running in read-only mode, that is, whether the server
	// does not accept directory server write operations. The DNS server detects whether
	// this is the case by reading the supportedCapabilities attribute of the server's rootDse
	// object, looking for LDAP_CAP_ACTIVE_DIRECTORY_PARTIAL_SECRETS_OID (See [MS-ADTS]
	// section 3.1.1.3.4.3.6).
	ReadOnlyDC bool `idl:"name:fReadOnlyDC" json:"read_only_dc"`

	AutoReverseZones       bool `idl:"name:fAutoReverseZones" json:"auto_reverse_zones"`
	AutoCacheUpdate        bool `idl:"name:fAutoCacheUpdate" json:"auto_cache_update"`
	RecurseAfterForwarding bool `idl:"name:fRecurseAfterForwarding" json:"recurse_after_forwarding"`
	ForwardDelegations     bool `idl:"name:fForwardDelegations" json:"forward_delegations"`
	NoRecursion            bool `idl:"name:fNoRecursion" json:"no_recursion"`
	SecureResponses        bool `idl:"name:fSecureResponses" json:"secure_responses"`
	RoundRobin             bool `idl:"name:fRoundRobin" json:"round_robin"`
	LocalNetPriority       bool `idl:"name:fLocalNetPriority" json:"local_net_priority"`
	BindSecondaries        bool `idl:"name:fBindSecondaries" json:"bind_secondaries"`
	WriteAuthorityNS       bool `idl:"name:fWriteAuthorityNs" json:"write_authority_ns"`
	StrictFileParsing      bool `idl:"name:fStrictFileParsing" json:"strict_file_parsing"`
	LooseWildcarding       bool `idl:"name:fLooseWildcarding" json:"loose_wildcarding"`
	DefaultAgingState      bool `idl:"name:fDefaultAgingState" json:"default_aging_state"`
	// contains filtered or unexported fields
}

ServerInfoLonghorn structure represents DNS_RPC_SERVER_INFO_LONGHORN RPC structure.

In the DNS_RPC_SERVER_INFO_LONGHORN structure all fields have same definition as specified in section DNS_RPC_SERVER_INFO_DOTNET (section 2.2.4.2.2.2 ), with the following exceptions:<33>

func (*ServerInfoLonghorn) MarshalNDR 

func (o *ServerInfoLonghorn) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*ServerInfoLonghorn) UnmarshalNDR 

func (o *ServerInfoLonghorn) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type ServerInfoW2K 

type ServerInfoW2K struct {
	// dwVersion: The operating system version of the DNS server in DNSSRV_VERSION (section
	// 2.2.4.2.1).
	Version uint32 `idl:"name:dwVersion" json:"version"`
	// fBootMethod: The method by which the DNS server obtains information at the start
	// time. This MUST be set to one of the possible values as specified in DNS_BOOT_METHODS
	// (section 2.2.4.1.1).
	BootMethod uint8 `idl:"name:fBootMethod" json:"boot_method"`
	// fAdminConfigured: A Boolean field that specifies whether the DNS server has been
	// configured by an administrator. On a fresh installed server this value MUST be set
	// to FALSE. This value MUST be set to TRUE whenever a zone is created, or a record
	// is modified, or an Active Directory domain controller promotion (DCPROMO) configures
	// the DNS server.
	AdminConfigured bool `idl:"name:fAdminConfigured" json:"admin_configured"`
	// fAllowUpdate: A Boolean field that indicates whether the DNS server allows dynamic
	// DNS updates. This field MUST be set to FALSE if the server does not allow dynamic
	// zone-updates, otherwise set to TRUE.
	AllowUpdate bool `idl:"name:fAllowUpdate" json:"allow_update"`
	// fDsAvailable: A Boolean field that specifies whether a directory server is available
	// to the DNS server. It MUST be set to FALSE, if the server does not have access to
	// a directory server.
	DSAvailable bool `idl:"name:fDsAvailable" json:"ds_available"`
	// pszServerName: A pointer to a null-terminated UTF-8 string that contains the FQDN
	// of the DNS server.
	ServerName string `idl:"name:pszServerName;string" json:"server_name"`
	// pszDsContainer: A pointer to a null-terminated Unicode string that points to the
	// DNS server's container path as a distinguished name (DN) in the directory server.
	// If no directory server is configured, this value MUST be set to NULL. This value
	// is synthesized by the server by concatenating a constant container relative distinguished
	// name (RDN) and the result of an LDAP search operation to retrieve the defaultNamingContext
	// of the Active Directory server's rootDSE.<31>
	DSContainer string `idl:"name:pszDsContainer;string" json:"ds_container"`
	// aipServerAddrs: The list of IP addresses that are available on the server.
	ServerAddrs *IPv4Array `idl:"name:aipServerAddrs" json:"server_addrs"`
	// aipListenAddrs: The list of IP addresses that are explicitly configured by the administrator
	// on the DNS server that listens for the DNS requests. If this value is set to NULL
	// then the server listens to all available IP addresses.
	ListenAddrs *IPv4Array `idl:"name:aipListenAddrs" json:"listen_addrs"`
	// aipForwarders: The list of remote DNS servers to which this DNS server will forward
	// unresolved DNS requests.
	Forwarders *IPv4Array `idl:"name:aipForwarders" json:"forwarders"`
	// pExtension1: Reserved for future use and MUST be ignored by receiver.
	Extension1 uint32 `idl:"name:pExtension1" json:"extension1"`
	// pExtension2: Reserved for future use and MUST be ignored by receiver.
	Extension2 uint32 `idl:"name:pExtension2" json:"extension2"`
	// pExtension3: Reserved for future use and MUST be ignored by receiver.
	Extension3 uint32 `idl:"name:pExtension3" json:"extension3"`
	// pExtension4: Reserved for future use and MUST be ignored by receiver.
	Extension4 uint32 `idl:"name:pExtension4" json:"extension4"`
	// pExtension5: Reserved for future use and MUST be ignored by receiver.
	Extension5 uint32 `idl:"name:pExtension5" json:"extension5"`
	// dwLogLevel: This indicates which DNS packets will be logged and how they will be
	// logged. This field MUST be set to either zero or a combination (by bitwise OR) of
	// the possible values as specified under DNS_LOG_LEVELS (section 2.2.9.1.1). If this
	// value is set to zero, then no logging will be performed for DNS packets.
	LogLevel uint32 `idl:"name:dwLogLevel" json:"log_level"`
	// dwDebugLevel: Unused. Receivers MUST ignore.
	DebugLevel uint32 `idl:"name:dwDebugLevel" json:"debug_level"`
	// dwForwardTimeout: The time interval, in seconds, for which the DNS server waits for
	// a response from each server in the forwarders list.
	ForwardTimeout uint32 `idl:"name:dwForwardTimeout" json:"forward_timeout"`
	// dwRpcProtocol: This value indicates what RPC protocols this DNS server will accept
	// connections on. This value MUST be set to any combination of values specified in
	// DNS_RPC_PROTOCOLS (section 2.2.1.1.2).
	RPCProtocol uint32 `idl:"name:dwRpcProtocol" json:"rpc_protocol"`
	// dwNameCheckFlag: The level of domain name checking and validation enforced by the
	// DNS server. This value MUST be set one of the allowed values that are specified in
	// DNS_NAME_CHECK_FLAGS (section 2.2.4.1.2).
	NameCheckFlag uint32 `idl:"name:dwNameCheckFlag" json:"name_check_flag"`
	// cAddressAnswerLimit: The configured value for the maximum number of type A IP address
	// resource records that the DNS server can insert in the answer section of a response
	// to a UDP query of type A. If this value is set to 0x00000000 then the DNS server
	// MUST NOT enforce any artificial limit on number of records in a response and if response
	// becomes larger than the DNS UDP packet size then the truncation bit MUST be set [RFC1035].
	// If this property value is not 0x00000000 and the DNS server is unable to add the
	// specified number of records to the response message due to message size limitations,
	// it MUST return as many records as will fit in the message and the truncation bit
	// MUST NOT be set. The DNS server MUST NOT enforce this limit if the query is not of
	// type A. If the value of this property is not 0x00000000 the DNS server MUST enforce
	// this limit for UDP queries and MUST NOT enforce this limit for TCP queries. If the
	// LocalNetPriority property value is set to TRUE, the DNS server first orders the address
	// records as per the LocalNetPriority property and then MUST select the first cAddressAnswerLimit
	// type A records in this sorted list for inclusion in the response. The value MUST
	// be either zero or between 0x00000005 and 0x0000001C inclusive.
	AddressAnswerLimitCount uint32 `idl:"name:cAddressAnswerLimit" json:"address_answer_limit_count"`
	// dwRecursionRetry: The time-interval, in seconds, for which the DNS server waits before
	// it retries a recursive query to the remote DNS server from which it did not receive
	// a response. The values MUST be between 1 and 15 seconds inclusive.
	RecursionRetry uint32 `idl:"name:dwRecursionRetry" json:"recursion_retry"`
	// dwRecursionTimeout: The time-interval, in seconds, for which the DNS server waits
	// for a recursive query-response from a remote DNS server. The values MUST be between
	// 1 and 15 seconds inclusive.
	RecursionTimeout uint32 `idl:"name:dwRecursionTimeout" json:"recursion_timeout"`
	// dwMaxCacheTtl: The maximum time duration, in seconds, for which the DNS server will
	// cache a resource record obtained from a remote server in a successful query response.
	// The values for this MUST be between 0 to 30 days (but specified in seconds) inclusive.
	MaxCacheTTL uint32 `idl:"name:dwMaxCacheTtl" json:"max_cache_ttl"`
	// dwDsPollingInterval: The interval, in seconds, at which the DNS server will poll
	// a directory server to obtain updated information for any changes that have occurred
	// to zones loaded in the server. The values MUST be between 30 and 3600 seconds inclusive.
	DSPollingInterval uint32 `idl:"name:dwDsPollingInterval" json:"ds_polling_interval"`
	// dwScavengingInterval: The scavenging interval, in hours, on the DNS server. This
	// is the interval at which the server will execute the cleanup of stale DNS records.
	// The value MUST be between 0 and 8760 hours (1 year). If this value is zero then scavenging
	// is disabled.
	ScavengingInterval uint32 `idl:"name:dwScavengingInterval" json:"scavenging_interval"`
	// dwDefaultRefreshInterval: The default value of the refresh interval, in hours, for
	// new zones created on the DNS server. For any primary zone created on the server by
	// default this value is used as the refresh interval.
	DefaultRefreshInterval uint32 `idl:"name:dwDefaultRefreshInterval" json:"default_refresh_interval"`
	// dwDefaultNoRefreshInterval: The default value of the NoRefresh interval, in hours,
	// for new zones created on the DNS server. For any primary zone created on the server
	// by default this value is used as the NoRefresh interval.
	DefaultNoRefreshInterval uint32 `idl:"name:dwDefaultNoRefreshInterval" json:"default_no_refresh_interval"`

	// fAutoReverseZones: A Boolean value that indicates whether the DNS server is configured
	// to automatically create standard reverse lookup zones at boot time.
	AutoReverseZones bool `idl:"name:fAutoReverseZones" json:"auto_reverse_zones"`
	// fAutoCacheUpdate: A Boolean value that indicates whether the DNS server is configured
	// to automatically write-back cached root hints and delegation data to persistent storage.
	AutoCacheUpdate bool `idl:"name:fAutoCacheUpdate" json:"auto_cache_update"`
	// fRecurseAfterForwarding: A Boolean value that indicates whether the DNS server is
	// configured to use recursion in addition to forwarding. If this value is TRUE (0x01)
	// then if the DNS server does not have any forwarders configured or if forwarders are
	// unreachable then it MUST return failure, otherwise it MUST perform normal recursive
	// processing for this query as specified in [RFC1034] section 4.3.1.
	RecurseAfterForwarding bool `idl:"name:fRecurseAfterForwarding" json:"recurse_after_forwarding"`
	// fForwardDelegations: A Boolean value indicates whether or not the DNS server will
	// forward queries about delegated subzones to servers outside of its authoritative
	// zone. If this value is set to TRUE, then the DNS server forwards all name queries
	// about delegated subzones to forwarding servers in other zones; otherwise it will
	// send such queries within its authoritative zone to the corresponding subzone only.
	ForwardDelegations bool `idl:"name:fForwardDelegations" json:"forward_delegations"`
	// fNoRecursion: A Boolean value that indicates whether the DNS server will perform
	// recursive resolution for queries. If this value is TRUE then recursion MUST NOT be
	// performed even if the Recursion Desired (RD) bit ([RFC1035] section 4.1.1) is set
	// in the DNS query packet header. If this value is FALSE then recursion will be performed
	// as per [RFC1035].
	NoRecursion bool `idl:"name:fNoRecursion" json:"no_recursion"`
	// fSecureResponses: A Boolean value that indicates if the DNS server needs to screen
	// DNS records received in remote query responses against the zone of authority for
	// the remote server to prevent cache pollution. If it is set to TRUE, the DNS server
	// caches only the records that are in zone of authority for the remote server that
	// was queried. When set to FALSE, all records in the cache are saved.
	SecureResponses bool `idl:"name:fSecureResponses" json:"secure_responses"`
	// fRoundRobin: A Boolean value that indicates if the DNS server is configured to rotate
	// the order of DNS records it returns for a given name. If this value is set to FALSE
	// no round robin will be performed and DNS records will be returned in static, arbitrary
	// order.
	RoundRobin bool `idl:"name:fRoundRobin" json:"round_robin"`
	// fLocalNetPriority: A Boolean value that indicates if the DNS server is configured
	// to prioritize address records in a response based on the IP address of the DNS client
	// that submitted the query. If this is set to TRUE the DNS server will return address
	// records in the order of their closeness to the querying client's IP address by applying
	// the network mask pointed to by LocalNetPriorityNetMask. If this value is set to 0
	// then the DNS server returns records in the order in which they are obtained from
	// the database.
	LocalNetPriority bool `idl:"name:fLocalNetPriority" json:"local_net_priority"`
	// fBindSecondaries: A Boolean value that indicates if the DNS server allows zone transfers
	// to secondary DNS servers running older non-Microsoft software. If this value is set
	// to TRUE the DNS server sends zone transfer to secondaries via a slower mechanism,
	// with one resource record in each message.
	BindSecondaries bool `idl:"name:fBindSecondaries" json:"bind_secondaries"`
	// fWriteAuthorityNs: A Boolean value that indicates if the DNS server is enabled to
	// write NS records in the authority section of all successful authoritative responses.
	// If this value is TRUE then NS records will be included in the authority section of
	// responses, otherwise NS records will only be included in referral responses.
	WriteAuthorityNS bool `idl:"name:fWriteAuthorityNs" json:"write_authority_ns"`
	// fStrictFileParsing: A Boolean value that indicates if the DNS server is configured
	// to perform strict file parsing. When this value is set to TRUE and a record parsing
	// error is detected server will quit after indicating error. If this value is FALSE
	// parsing errors will cause that specific record to be ignored and the server will
	// continue to load the rest of the database.
	StrictFileParsing bool `idl:"name:fStrictFileParsing" json:"strict_file_parsing"`
	// fLooseWildcarding: A Boolean value that indicates if the DNS server is configured
	// to perform loose wildcarding [RFC1035], otherwise it returns FALSE. When a server
	// does not find a resource record that matches the name and type specified in the query
	// in the authoritative zone, then it searches for related wildcard records, ([RFC1034]
	// section 4.3.3), if configured to perform loose wildcarding will return the first
	// node it finds that has matching resource-record type, whereas if it is not then it
	// will return the first node that has any resource record.
	LooseWildcarding bool `idl:"name:fLooseWildcarding" json:"loose_wildcarding"`
	// fDefaultAgingState: A Boolean value that indicates if the default value of ageing
	// state for new primary zones created on the DNS server. For any primary zone created
	// on the server this value is used as its default aging state. If this is FALSE then
	// timestamps of records in the zone will not be tracked whereas when this value is
	// TRUE then the timestamps of records in the zone will be tracked.
	DefaultAgingState bool `idl:"name:fDefaultAgingState" json:"default_aging_state"`
	// contains filtered or unexported fields
}

ServerInfoW2K structure represents DNS_RPC_SERVER_INFO_W2K RPC structure.

The DNS_RPC_SERVER_INFO_W2K structure is used to specify general DNS server state and configuration.

func (*ServerInfoW2K) MarshalNDR 

func (o *ServerInfoW2K) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*ServerInfoW2K) UnmarshalNDR 

func (o *ServerInfoW2K) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type ServerInfo_NET 

type ServerInfo_NET struct {
	// dwRpcStructureVersion: The DNS management structure version number. The following
	// are possible values:
	//
	//	+------------+--------------------------------------------------------------------------+
	//	|            |                                                                          |
	//	|   VALUE    |                                 MEANING                                  |
	//	|            |                                                                          |
	//	+------------+--------------------------------------------------------------------------+
	//	+------------+--------------------------------------------------------------------------+
	//	| 0x00000001 | Structure is of type DNS_RPC_SERVER_INFO_DOTNET (section 2.2.4.2.2.2).   |
	//	+------------+--------------------------------------------------------------------------+
	//	| 0x00000002 | Structure is of type DNS_RPC_SERVER_INFO_LONGHORN (section 2.2.4.2.2.3). |
	//	+------------+--------------------------------------------------------------------------+
	RPCStructureVersion uint32 `idl:"name:dwRpcStructureVersion" json:"rpc_structure_version"`

	Version         uint32     `idl:"name:dwVersion" json:"version"`
	BootMethod      uint8      `idl:"name:fBootMethod" json:"boot_method"`
	AdminConfigured bool       `idl:"name:fAdminConfigured" json:"admin_configured"`
	AllowUpdate     bool       `idl:"name:fAllowUpdate" json:"allow_update"`
	DSAvailable     bool       `idl:"name:fDsAvailable" json:"ds_available"`
	ServerName      string     `idl:"name:pszServerName;string" json:"server_name"`
	DSContainer     string     `idl:"name:pszDsContainer;string" json:"ds_container"`
	ServerAddrs     *IPv4Array `idl:"name:aipServerAddrs" json:"server_addrs"`
	ListenAddrs     *IPv4Array `idl:"name:aipListenAddrs" json:"listen_addrs"`
	Forwarders      *IPv4Array `idl:"name:aipForwarders" json:"forwarders"`
	// aipLogFilter: The list of IP addresses used for debug log filtering. The DNS server
	// will log DNS traffic that is sent to or received from for these IP addresses and
	// will not log DNS traffic to or from other IP addresses. If this value is set to NULL
	// then the DNS server will not perform IP filtering when logging DNS traffic.
	LogFilter *IPv4Array `idl:"name:aipLogFilter" json:"log_filter"`
	// pwszLogFilePath: A pointer to a null-terminated Unicode string that contains an absolute
	// pathname or relative pathname or filename for the operational log file on the DNS
	// server. If this value is set to NULL, the log SHOULD be logged to an implementation
	// specific log file.
	LogFilePath string `idl:"name:pwszLogFilePath;string" json:"log_file_path"`
	// pszDomainName: A pointer to a null-terminated UTF-8 string that contains the name
	// of the directory server domain to which the DNS server belongs if directory server
	// is available. This value will be NULL if no directory server is available.
	DomainName string `idl:"name:pszDomainName;string" json:"domain_name"`
	// pszForestName: A pointer to a null-terminated UTF-8 string that contains the name
	// of the directory server forest to which the DNS server belongs if directory server
	// is available. This value will be NULL if no directory server is available.
	ForestName string `idl:"name:pszForestName;string" json:"forest_name"`
	// pszDomainDirectoryPartition: A pointer to a null-terminated UTF-8 string that contains
	// the base name for the domain wide DNS application directory partition.
	DomainDirectoryPartition string `idl:"name:pszDomainDirectoryPartition;string" json:"domain_directory_partition"`
	// pszForestDirectoryPartition: A pointer to a null-terminated UTF-8 string that contains
	// the base name for the forest-wide DNS application directory partition.
	ForestDirectoryPartition string `idl:"name:pszForestDirectoryPartition;string" json:"forest_directory_partition"`
	// pExtensions: Reserved for future use. Senders MUST set this to NULL and it MUST be
	// ignored by the receiver.
	Extensions              string `idl:"name:pExtensions;string" json:"extensions"`
	LogLevel                uint32 `idl:"name:dwLogLevel" json:"log_level"`
	DebugLevel              uint32 `idl:"name:dwDebugLevel" json:"debug_level"`
	ForwardTimeout          uint32 `idl:"name:dwForwardTimeout" json:"forward_timeout"`
	RPCProtocol             uint32 `idl:"name:dwRpcProtocol" json:"rpc_protocol"`
	NameCheckFlag           uint32 `idl:"name:dwNameCheckFlag" json:"name_check_flag"`
	AddressAnswerLimitCount uint32 `idl:"name:cAddressAnswerLimit" json:"address_answer_limit_count"`
	RecursionRetry          uint32 `idl:"name:dwRecursionRetry" json:"recursion_retry"`
	RecursionTimeout        uint32 `idl:"name:dwRecursionTimeout" json:"recursion_timeout"`
	MaxCacheTTL             uint32 `idl:"name:dwMaxCacheTtl" json:"max_cache_ttl"`
	DSPollingInterval       uint32 `idl:"name:dwDsPollingInterval" json:"ds_polling_interval"`
	// dwLocalNetPriorityNetMask: The net mask used by the DNS server to prioritize address
	// records in responses when the server is configured to enforce LocalNetPriority as
	// mentioned above.
	LocalNetPriorityNetMask  uint32 `idl:"name:dwLocalNetPriorityNetMask" json:"local_net_priority_net_mask"`
	ScavengingInterval       uint32 `idl:"name:dwScavengingInterval" json:"scavenging_interval"`
	DefaultRefreshInterval   uint32 `idl:"name:dwDefaultRefreshInterval" json:"default_refresh_interval"`
	DefaultNoRefreshInterval uint32 `idl:"name:dwDefaultNoRefreshInterval" json:"default_no_refresh_interval"`
	// dwLastScavengeTime: The timestamp at which the last scavenging cycle was executed
	// on the DNS server. If this value is set to 0 then no scavenging cycle has been run
	// since the server was last started.
	LastScavengeTime uint32 `idl:"name:dwLastScavengeTime" json:"last_scavenge_time"`
	// dwEventLogLevel: This value indicates what level of events will be logged by the
	// DNS server. This value MUST be set to one of the combination of the possible values
	// for this defined in DNS_EVENTLOG_TYPES (section 2.2.9.1.2).
	EventLogLevel uint32 `idl:"name:dwEventLogLevel" json:"event_log_level"`
	// dwLogFileMaxSize: The maximum allowed size, in bytes, for the log file.
	LogFileMaxSize uint32 `idl:"name:dwLogFileMaxSize" json:"log_file_max_size"`
	// dwDsForestVersion: This value indicates the directory server forest version being
	// used by the DNS server, stored in the ForceForestBehaviorVersion property.
	DSForestVersion uint32 `idl:"name:dwDsForestVersion" json:"ds_forest_version"`
	// dwDsDomainVersion: This value indicates the directory server domain version being
	// used by the DNS server, stored in the ForceDomainBehaviorVersion property.
	DSDomainVersion uint32 `idl:"name:dwDsDomainVersion" json:"ds_domain_version"`
	// dwDsDsaVersion: This value indicates the directory server local server version being
	// used by the DNS server, stored in the ForceDsaBehaviorVersion property.
	DSDSAVersion uint32 `idl:"name:dwDsDsaVersion" json:"ds_dsa_version"`

	AutoReverseZones       bool `idl:"name:fAutoReverseZones" json:"auto_reverse_zones"`
	AutoCacheUpdate        bool `idl:"name:fAutoCacheUpdate" json:"auto_cache_update"`
	RecurseAfterForwarding bool `idl:"name:fRecurseAfterForwarding" json:"recurse_after_forwarding"`
	ForwardDelegations     bool `idl:"name:fForwardDelegations" json:"forward_delegations"`
	NoRecursion            bool `idl:"name:fNoRecursion" json:"no_recursion"`
	SecureResponses        bool `idl:"name:fSecureResponses" json:"secure_responses"`
	RoundRobin             bool `idl:"name:fRoundRobin" json:"round_robin"`
	LocalNetPriority       bool `idl:"name:fLocalNetPriority" json:"local_net_priority"`
	BindSecondaries        bool `idl:"name:fBindSecondaries" json:"bind_secondaries"`
	WriteAuthorityNS       bool `idl:"name:fWriteAuthorityNs" json:"write_authority_ns"`
	StrictFileParsing      bool `idl:"name:fStrictFileParsing" json:"strict_file_parsing"`
	LooseWildcarding       bool `idl:"name:fLooseWildcarding" json:"loose_wildcarding"`
	DefaultAgingState      bool `idl:"name:fDefaultAgingState" json:"default_aging_state"`
	// contains filtered or unexported fields
}

ServerInfo_NET structure represents DNS_RPC_SERVER_INFO_DOTNET RPC structure.

In the DNS_RPC_SERVER_INFO_DOTNET structure all fields have same definition as specified in DNS_RPC_SERVER_INFO_W2K (section 2.2.4.2.2.1), with the following exceptions:<32>

func (*ServerInfo_NET) MarshalNDR 

func (o *ServerInfo_NET) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*ServerInfo_NET) UnmarshalNDR 

func (o *ServerInfo_NET) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type SigningValidationError 

type SigningValidationError struct {
	// dwRpcStructureVersion: The structure version number; this MUST be set to 0x00000001.
	RPCStructureVersion uint32 `idl:"name:dwRpcStructureVersion" json:"rpc_structure_version"`

	// guidSKD: The unique identifier for the signing key descriptor that caused the validation
	// error.
	SKD *dtyp.GUID `idl:"name:guidSKD" json:"skd"`
	// pwszSigningKeyPointerString: The signing key pointer string of the signing key that
	// caused the validation error.
	SigningKeyPointerString string `idl:"name:pwszSigningKeyPointerString;string" json:"signing_key_pointer_string"`
	// dwExtendedError: MUST be set to zero when sent.
	ExtendedError uint32 `idl:"name:dwExtendedError" json:"extended_error"`
	// contains filtered or unexported fields
}

SigningValidationError structure represents DNS_RPC_SIGNING_VALIDATION_ERROR RPC structure.

The DNS_RPC_SIGNING_VALIDATION_ERROR structure describes an error that occurred during the use of an SKD.

func (*SigningValidationError) MarshalNDR 

func (o *SigningValidationError) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*SigningValidationError) UnmarshalNDR 

func (o *SigningValidationError) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type Stat 

type Stat struct {
	StatID uint32 `idl:"name:StatId" json:"stat_id"`
	Length uint16 `idl:"name:wLength" json:"length"`
	Clear  bool   `idl:"name:fClear" json:"clear"`

	// Buffer: A variable length array of bytes that contains information specific to the
	// type of DNS server statistics, as specified by the StatId value in the Header.
	Buffer []byte `idl:"name:Buffer;size_is:(wLength)" json:"buffer"`
	// contains filtered or unexported fields
}

Stat structure represents DNSSRV_STAT RPC structure.

The DNSSRV_STATS structure carries server statistics information. This structure MUST be interpreted as one of the more specific statistics structures specified in sections 2.2.10.2.4 through 2.2.10.2.24, depending upon the StatId value in the Header member. This structure MUST be formatted as follows:

func (*Stat) MarshalNDR 

func (o *Stat) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*Stat) UnmarshalNDR 

func (o *Stat) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type StatHeader 

type StatHeader struct {
	// StatId: The type of statistics contained in the DNSSRV_STATS structure. This value
	// MUST be set to one of the allowed values specified in section 2.2.10.1.1.
	StatID uint32 `idl:"name:StatId" json:"stat_id"`
	// wLength: The length, in bytes, of the Buffer member in the DNSSRV_STATS structure
	// (section 2.2.10.2.2).
	Length uint16 `idl:"name:wLength" json:"length"`
	// fClear: A Boolean value that indicates whether the server is to clear the statistics
	// buffer for the server attribute indicated at by StatId.
	Clear bool `idl:"name:fClear" json:"clear"`
	// contains filtered or unexported fields
}

StatHeader structure represents DNSSRV_STAT_HEADER RPC structure.

The DNSSRV_STAT_HEADER structure precedes each DNSSRV_STATS structure (section 2.2.10.2.2) which provides DNS server runtime statistics. This structure MUST be formatted as follows:

func (*StatHeader) MarshalNDR 

func (o *StatHeader) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*StatHeader) UnmarshalNDR 

func (o *StatHeader) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type SystemTime 

type SystemTime struct {
	// wYear (2 bytes): The year, as a 16-bit, unsigned integer. Valid values are from 1601
	// to 30827.
	Year uint16 `idl:"name:wYear" json:"year"`
	// wMonth (2 bytes): The month from 1 (January) to 12 (December), as a 16-bit, unsigned
	// integer.
	Month uint16 `idl:"name:wMonth" json:"month"`
	// wDayOfWeek (2 bytes): The day of the week from 0 (Sunday) to 6 (Saturday), as a 16-bit,
	// unsigned integer.
	DayOfWeek uint16 `idl:"name:wDayOfWeek" json:"day_of_week"`
	// wDay (2 bytes): The day of the month from 1 to 31, as a 16-bit, unsigned integer.
	Day uint16 `idl:"name:wDay" json:"day"`
	// wHour (2 bytes): The hour from 0 to 23, as a 16-bit, unsigned integer.
	Hour uint16 `idl:"name:wHour" json:"hour"`
	// wMinute (2 bytes): The minute from 0 to 59, as a 16-bit, unsigned integer.
	Minute uint16 `idl:"name:wMinute" json:"minute"`
	// wSecond (2 bytes): The second from 0 to 59, as a 16-bit, unsigned integer.
	Second       uint16 `idl:"name:wSecond" json:"second"`
	Milliseconds uint16 `idl:"name:wMilliseconds" json:"milliseconds"`
}

SystemTime structure represents DNS_SYSTEMTIME RPC structure.

The DNS_SYSTEMTIME structure stores time values for DNS statistics. It is always populated by the server, which MUST supply valid values. This structure MUST be formatted as follows: 

+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 1 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 2 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 3 | 1 |
|   |   |   |   |   |   |   |   |   |   | 0 |   |   |   |   |   |   |   |   |   | 0 |   |   |   |   |   |   |   |   |   | 0 |   |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| wYear                                                         | wMonth                                                        |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| wDayOfWeek                                                    | wDay                                                          |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| wHour                                                         | wMinute                                                       |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| wSecond                                                       | wMillisecond                                                  |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+

func (*SystemTime) MarshalNDR 

func (o *SystemTime) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*SystemTime) UnmarshalNDR 

func (o *SystemTime) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type TrustAnchor 

type TrustAnchor struct {
	// dwRpcStructureVersion: The structure version number; this MUST be set to 0x00000001.
	RPCStructureVersion uint32 `idl:"name:dwRpcStructureVersion" json:"rpc_structure_version"`

	// wTrustAnchorType: The DNS record type corresponding to the trust anchor. This MUST
	// be set to one of the following values.
	//
	//	+------------------------+---------------------------------+
	//	|                        |                                 |
	//	|         VALUE          |             MEANING             |
	//	|                        |                                 |
	//	+------------------------+---------------------------------+
	//	+------------------------+---------------------------------+
	//	| DNS_TYPE_DS 0x002B     | A DS record type [RFC4034].     |
	//	+------------------------+---------------------------------+
	//	| DNS_TYPE_DNSKEY 0x0030 | A DNSKEY record type [RFC4034]. |
	//	+------------------------+---------------------------------+
	TrustAnchorType uint16 `idl:"name:wTrustAnchorType" json:"trust_anchor_type"`
	// wKeyTag: The DNSSEC key tag for this trust anchor. The key tag for a DS record trust
	// anchor MUST match the value of the record’s "Key Tag" field (see [RFC4034]). The
	// key tag for a DNSKEY record trust anchor MUST match the value calculated for the
	// DNSKEY record (see [RFC4034] Appendix B), with the exception that the REVOKE bit
	// of the DNSKEY flags field MUST be set to zero before the calculation.
	KeyTag uint16 `idl:"name:wKeyTag" json:"key_tag"`
	// wRRLength: The length of the RRData array.
	RRLength uint16 `idl:"name:wRRLength" json:"rr_length"`
	// eTrustAnchorState: The current state of the trust anchor. This MUST be one of the
	// following TRUSTANCHOR_STATE enumeration values (section 2.2.1.1.4).
	//
	//	+----------------------------------------+----------------------------------------------------------------------------------+
	//	|                                        |                                                                                  |
	//	|                 VALUE                  |                                     MEANING                                      |
	//	|                                        |                                                                                  |
	//	+----------------------------------------+----------------------------------------------------------------------------------+
	//	+----------------------------------------+----------------------------------------------------------------------------------+
	//	| TRUSTANCHOR_STATE_DSPENDING 0x00000001 | This trust anchor can be replaced with a matching DNSKEY trust anchor when the   |
	//	|                                        | associated trust point  has had a successful active refresh. If this state is    |
	//	|                                        | set, wTrustAnchorType MUST be DNS_TYPE_DS.                                       |
	//	+----------------------------------------+----------------------------------------------------------------------------------+
	//	| TRUSTANCHOR_STATE_DSINVALID 0x00000002 | The associated trust point has had a successful active refresh, but no           |
	//	|                                        | DNSKEY record was found that matches this trust anchor. If this state is set,    |
	//	|                                        | wTrustAnchorType MUST be DNS_TYPE_DS.                                            |
	//	+----------------------------------------+----------------------------------------------------------------------------------+
	//	| TRUSTANCHOR_STATE_ADDPEND 0x00000003   | This trust anchor will become valid after the expiration of the RFC 5011 add     |
	//	|                                        | hold-down time (see [RFC5011]). This corresponds to the "AddPend" state in RFC   |
	//	|                                        | 5011.                                                                            |
	//	+----------------------------------------+----------------------------------------------------------------------------------+
	//	| TRUSTANCHOR_STATE_VALID 0x00000004     | This trust anchor is trusted for DNSSEC proofs because it was either explicitly  |
	//	|                                        | added by the administrator or became valid after the expiration of the RFC 5011  |
	//	|                                        | add hold-down time (see [RFC5011]). This corresponds to the Valid state in RFC   |
	//	|                                        | 5011.                                                                            |
	//	+----------------------------------------+----------------------------------------------------------------------------------+
	//	| TRUSTANCHOR_STATE_MISSING 0x00000005   | This trust anchor was in the TRUSTANCHOR_STATE_VALID state but was missing in    |
	//	|                                        | the last successful active refresh. It is still trusted for DNSSEC proofs. This  |
	//	|                                        | corresponds to the Valid state in [RFC5011].                                     |
	//	+----------------------------------------+----------------------------------------------------------------------------------+
	//	| TRUSTANCHOR_STATE_REVOKED 0x00000006   | This trust anchor has been marked as revoked by the administrator for the trust  |
	//	|                                        | point's zone. It can never again be trusted for DNSSEC proofs. This corresponds  |
	//	|                                        | to the Revoked state in [RFC5011].                                               |
	//	+----------------------------------------+----------------------------------------------------------------------------------+
	TrustAnchorState TrustAnchorState `idl:"name:eTrustAnchorState" json:"trust_anchor_state"`
	// i64EnteredStateTime: The time at which this trust anchor entered its current state.
	// This is a 64-bit value representing the number of 100-nanosecond intervals since
	// January 1, 1601 (UTC).
	EnteredStateTime int64 `idl:"name:i64EnteredStateTime" json:"entered_state_time"`
	// i64NextStateTime: The time at which this trust anchor is scheduled to exit the current
	// state. This is a 64-bit value representing the number of 100-nanosecond intervals
	// since January 1, 1601 (UTC). The meaning is dependent on the value of eTrustAnchorState.
	//
	//	+----------------------------------------+----------------------------------------------------------------------------------+
	//	|                VALUE OF                |                                                                                  |
	//	|           ETRUSTANCHORSTATE            |                                     MEANING                                      |
	//	|                                        |                                                                                  |
	//	+----------------------------------------+----------------------------------------------------------------------------------+
	//	+----------------------------------------+----------------------------------------------------------------------------------+
	//	| TRUSTANCHOR_STATE_DSPENDING 0x00000001 | Reserved. The value of i64NextStateTime MUST be set to zero when sent and MUST   |
	//	|                                        | be ignored on receipt.                                                           |
	//	+----------------------------------------+----------------------------------------------------------------------------------+
	//	| TRUSTANCHOR_STATE_DSINVALID 0x00000002 | Reserved. The value of i64NextStateTime MUST be set to zero when sent and MUST   |
	//	|                                        | be ignored on receipt.                                                           |
	//	+----------------------------------------+----------------------------------------------------------------------------------+
	//	| TRUSTANCHOR_STATE_ADDPEND 0x00000003   | This trust anchor is scheduled to enter the TRUSTANCHOR_STATE_VALID state on     |
	//	|                                        | or after the value of i64NextStateTime. This MUST be equivalent to the value     |
	//	|                                        | of i64EnteredStateTime added to the value of the add hold-down time (see         |
	//	|                                        | [RFC5011]).                                                                      |
	//	+----------------------------------------+----------------------------------------------------------------------------------+
	//	| TRUSTANCHOR_STATE_VALID 0x00000004     | Reserved. The value of i64NextStateTime MUST be set to zero when sent and MUST   |
	//	|                                        | be ignored on receipt.                                                           |
	//	+----------------------------------------+----------------------------------------------------------------------------------+
	//	| TRUSTANCHOR_STATE_MISSING 0x00000005   | Reserved. The value of i64NextStateTime MUST be set to zero when sent and MUST   |
	//	|                                        | be ignored on receipt.                                                           |
	//	+----------------------------------------+----------------------------------------------------------------------------------+
	//	| TRUSTANCHOR_STATE_REVOKED 0x00000006   | This trust anchor will become eligible for deletion on or after the value of     |
	//	|                                        | i64NextStateTime. This MUST be equivalent to the value of i64EnteredStateTime    |
	//	|                                        | added to the value of the remove hold-down time (see [RFC5011]).                 |
	//	+----------------------------------------+----------------------------------------------------------------------------------+
	NextStateTime int64 `idl:"name:i64NextStateTime" json:"next_state_time"`

	// RRData: Binary data in the same format as DNS_RPC_RECORD_DNSKEY (section 2.2.2.2.4.15)
	// if wTrustAnchorType is DNS_TYPE_DNSKEY, or binary data in the same format as DNS_RPC_RECORD_DS
	// (section 2.2.2.2.4.12) if wTrustAnchorType is DNS_TYPE_DS.
	RRData []byte `idl:"name:RRData;size_is:(wRRLength)" json:"rr_data"`
	// contains filtered or unexported fields
}

TrustAnchor structure represents DNS_RPC_TRUST_ANCHOR RPC structure.

The DNS_RPC_TRUST_ANCHOR structure contains information about a trust anchor.

func (*TrustAnchor) MarshalNDR 

func (o *TrustAnchor) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*TrustAnchor) NDRSizeInfo 

func (o *TrustAnchor) NDRSizeInfo() []uint64

func (*TrustAnchor) UnmarshalNDR 

func (o *TrustAnchor) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type TrustAnchorList 

type TrustAnchorList struct {
	// dwRpcStructureVersion: The structure version number; this MUST be set to 0x00000001.
	RPCStructureVersion uint32 `idl:"name:dwRpcStructureVersion" json:"rpc_structure_version"`

	// dwTrustAnchorCount: The size of the TrustAnchorArray array.
	TrustAnchorCount uint32 `idl:"name:dwTrustAnchorCount" json:"trust_anchor_count"`
	// TrustAnchorArray: An array of pointers to DNS_RPC_TRUST_ANCHOR structures (section
	// 2.2.6.2.6).
	TrustAnchorArray []*TrustAnchor `idl:"name:TrustAnchorArray;size_is:(dwTrustAnchorCount)" json:"trust_anchor_array"`
	// contains filtered or unexported fields
}

TrustAnchorList structure represents DNS_RPC_TRUST_ANCHOR_LIST RPC structure.

The DNS_RPC_TRUST_ANCHOR_LIST structure contains zero or more DNS_RPC_TRUST_ANCHOR structures.

func (*TrustAnchorList) MarshalNDR 

func (o *TrustAnchorList) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*TrustAnchorList) NDRSizeInfo 

func (o *TrustAnchorList) NDRSizeInfo() []uint64

func (*TrustAnchorList) UnmarshalNDR 

func (o *TrustAnchorList) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type TrustAnchorState 

type TrustAnchorState uint16

TrustAnchorState type represents TRUSTANCHOR_STATE RPC enumeration.

The TRUSTANCHOR_STATE enumeration identifies the current state of the life cycle of a DNSSEC trust anchor. All states other than TRUSTANCHOR_STATE_DSPENDING and TRUSTANCHOR_STATE_DSINVALID correspond to the states given in [RFC5011] section 4.2. Only the TRUSTANCHOR_STATE_VALID and TRUSTANCHOR_STATE_MISSING trust anchors affect the DNS protocol (by acting as a DNSSEC trust anchor). None of the states affect the LDAP protocol [RFC4511]. 

var (
	// TRUSTANCHOR_STATE_INITIALIZED: Reserved. MUST NOT be sent by the server, MUST be
	// ignored by the receiver.
	TrustAnchorStateInitialized TrustAnchorState = 0
	// TRUSTANCHOR_STATE_DSPENDING: Indicates a DS trust anchor that can be replaced by
	// the DNSKEY trust anchor that matches the hash of the DS trust anchor after the next
	// [RFC5011] active refresh.
	TrustAnchorStateDspending TrustAnchorState = 1
	// TRUSTANCHOR_STATE_DSINVALID: Indicates a DS trust anchor that matches a DNSKEY record
	// that is not valid as a trust anchor because the SEP flag is not set or because the
	// algorithm is unsupported.
	TrustAnchorStateDsinvalid TrustAnchorState = 2
	// TRUSTANCHOR_STATE_ADDPEND: Indicates a DNSKEY trust anchor that has not exceeded
	// the [RFC5011] add-hold-down time. This trust anchor can become a valid trust anchor
	// after the hold-down time has been exceeded.
	TrustAnchorStateAddpend TrustAnchorState = 3
	// TRUSTANCHOR_STATE_VALID: Indicates a DNSKEY trust anchor that has exceeded the [RFC5011]
	// add-hold-down time, has been matched to (and has replaced) a DS trust anchor, or
	// has been added by the administrator. This trust anchor is trusted for DNSSEC operations,
	// and a copy exists in the TrustAnchors zone.
	TrustAnchorStateValid TrustAnchorState = 4
	// TRUSTANCHOR_STATE_MISSING: Indicates a DNSKEY trust anchor that is valid but was
	// not seen in the last [RFC5011] active refresh. This trust anchor is trusted for DNSSEC
	// operations, and a copy exists in the TrustAnchors zone.
	TrustAnchorStateMissing TrustAnchorState = 5
	// TRUSTANCHOR_STATE_REVOKED: Indicates a DNSKEY trust anchor that has been revoked
	// by the authoritative zone administrator according to [RFC5011]. This trust anchor
	// will be deleted when the [RFC5011] remove-hold-down time is exceeded.
	TrustAnchorStateRevoked TrustAnchorState = 6
	// TRUSTANCHOR_STATE_DELETED: Reserved. MUST NOT be sent by the server, MUST be ignored
	// by the receiver.
	TrustAnchorStateDeleted TrustAnchorState = 7
)

func (TrustAnchorState) String 

func (o TrustAnchorState) String() string

type TrustPoint 

type TrustPoint struct {
	// dwRpcStructureVersion: The structure version number; it MUST be set to 0x00000001.
	RPCStructureVersion uint32 `idl:"name:dwRpcStructureVersion" json:"rpc_structure_version"`

	// pszTrustPointName: The FQDN of the trust point or node in the TrustAnchors zone represented
	// by this structure. This MUST be a non-empty, non-NULL string.
	TrustPointName string `idl:"name:pszTrustPointName;string" json:"trust_point_name"`
	// eTrustPointState: A TRUSTPOINT_STATE enumeration value (section 2.2.1.1.3) containing
	// the current trust point state. This MUST be set to one of the following values. For
	// the TRUSTANCHOR_STATE enumeration values see section 2.2.1.1.4.
	//
	//	+--------------------------------------------+----------------------------------------------------------------------------------+
	//	|                                            |                                                                                  |
	//	|                   VALUE                    |                                     MEANING                                      |
	//	|                                            |                                                                                  |
	//	+--------------------------------------------+----------------------------------------------------------------------------------+
	//	+--------------------------------------------+----------------------------------------------------------------------------------+
	//	| TRUSTPOINT_STATE_INITIALIZED 0x00000000    | This structure represents a node in the TrustAnchors zone that does not contain  |
	//	|                                            | any trust anchors. This node is not a trust point.                               |
	//	+--------------------------------------------+----------------------------------------------------------------------------------+
	//	| TRUSTPOINT_STATE_DSPENDING 0x00000001      | This trust point contains only DS trust anchors (trust anchors in the            |
	//	|                                            | TRUSTANCHOR_STATE_DSPENDING or TRUSTANCHOR_STATE_DSINVALID state), rendering it  |
	//	|                                            | unusable for DNSSEC proofs.                                                      |
	//	+--------------------------------------------+----------------------------------------------------------------------------------+
	//	| TRUSTPOINT_STATE_ACTIVE 0x00000002         | This trust point contains at least one trust anchor in the                       |
	//	|                                            | TRUSTANCHOR_STATE_VALID or TRUSTANCHOR_STATE_MISSING state.                      |
	//	+--------------------------------------------+----------------------------------------------------------------------------------+
	//	| TRUSTPOINT_STATE_DELETE_PENDING 0x00000003 | This trust point contains only trust anchors in the TRUSTANCHOR_STATE_REVOKED    |
	//	|                                            | state.                                                                           |
	//	+--------------------------------------------+----------------------------------------------------------------------------------+
	TrustPointState TrustPointState `idl:"name:eTrustPointState" json:"trust_point_state"`
	// i64LastActiveRefreshTime: The time of the last active refresh. This is set to zero
	// to indicate that no active refresh has occurred. This is a 64-bit value representing
	// the number of 100-nanosecond intervals since January 1, 1601 Coordinated Universal
	// Time (UTC).
	LastActiveRefreshTime int64 `idl:"name:i64LastActiveRefreshTime" json:"last_active_refresh_time"`
	// i64NextActiveRefreshTime: The scheduled time of the next active refresh, or zero
	// to indicate that no active refresh is scheduled. This is a 64-bit value representing
	// the number of 100-nanosecond intervals since January 1, 1601 (UTC).
	NextActiveRefreshTime int64 `idl:"name:i64NextActiveRefreshTime" json:"next_active_refresh_time"`
	// i64LastSuccessfulActiveRefreshTime: The time of the last successful active refresh,
	// or zero to indicate that no active refresh has occurred. This is a 64-bit value representing
	// the number of 100-nanosecond intervals since January 1, 1601 (UTC). A successful
	// active refresh is defined as an active refresh resulting in retrieval of one or more
	// DNSKEY records for the trust point and, if this trust point has trust anchors in
	// the TRUSTANCHOR_STATE_VALID state, signifies that one or more of the retrieved DNSKEY
	// records was validated by DNSSEC.
	LastSuccessfulActiveRefreshTime int64 `idl:"name:i64LastSuccessfulActiveRefreshTime" json:"last_successful_active_refresh_time"`
	// dwLastActiveRefreshResult: The result of the last active refresh, either ERROR_SUCCESS
	// or a nonzero value to indicate that an error has occurred.
	LastActiveRefreshResult uint32 `idl:"name:dwLastActiveRefreshResult" json:"last_active_refresh_result"`
	// contains filtered or unexported fields
}

TrustPoint structure represents DNS_RPC_TRUST_POINT RPC structure.

The DNS_RPC_TRUST_POINT structure contains information about a trust point or a node in the TrustAnchors zone ([RFC5011]).

func (*TrustPoint) MarshalNDR 

func (o *TrustPoint) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*TrustPoint) UnmarshalNDR 

func (o *TrustPoint) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type TrustPointList 

type TrustPointList struct {
	// dwRpcStructureVersion: The structure version number; this MUST be set to 0x00000001.
	RPCStructureVersion uint32 `idl:"name:dwRpcStructureVersion" json:"rpc_structure_version"`

	// dwTrustPointCount: The size of the TrustPointArray array.
	TrustPointCount uint32 `idl:"name:dwTrustPointCount" json:"trust_point_count"`
	// TrustPointArray: An array of pointers to DNS_RPC_TRUST_POINT structures.
	TrustPointArray []*TrustPoint `idl:"name:TrustPointArray;size_is:(dwTrustPointCount)" json:"trust_point_array"`
	// contains filtered or unexported fields
}

TrustPointList structure represents DNS_RPC_TRUST_POINT_LIST RPC structure.

The DNS_RPC_TRUST_POINT_LIST structure contains zero or more DNS_RPC_TRUST_POINT structures.

func (*TrustPointList) MarshalNDR 

func (o *TrustPointList) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*TrustPointList) NDRSizeInfo 

func (o *TrustPointList) NDRSizeInfo() []uint64

func (*TrustPointList) UnmarshalNDR 

func (o *TrustPointList) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type TrustPointState 

type TrustPointState uint16

TrustPointState type represents TRUSTPOINT_STATE RPC enumeration.

The TRUSTPOINT_STATE enumeration identifies the current state of the life cycle of a DNSSEC trust point. The state of the trust point is determined by the states of its trust anchors and is given for informational purposes only; it does not affect the DNS or LDAP protocol. 

var (
	// TRUSTPOINT_STATE_INITIALIZED: Indicates a trust point that has no trust anchors but
	// has child nodes that do have trust anchors.
	TrustPointStateInitialized TrustPointState = 0
	// TRUSTPOINT_STATE_DSPENDING: Indicates a trust point that has only DS trust anchors
	// and is therefore ineffective for DNSSEC operations.
	TrustPointStateDspending TrustPointState = 1
	// TRUSTPOINT_STATE_ACTIVE: Indicates a trust point that has one or more DNSKEY trust
	// anchors. Queries covered by this trust point will be validated using the DNSKEY trust
	// anchors.
	TrustPointStateActive TrustPointState = 2
	// TRUSTPOINT_STATE_DELETE_PENDING: Indicates a trust point containing only revoked
	// DNSKEY trust anchors. When the [RFC5011] remove-hold-down time is exceeded for all
	// revoked trust anchors, this trust point will be deleted.
	TrustPointStateDeletePending TrustPointState = 3
	// TRUSTPOINT_STATE_DELETED: Reserved. MUST NOT be sent by the server, MUST be ignored
	// by the receiver.
	TrustPointStateDeleted TrustPointState = 4
)

func (TrustPointState) String 

func (o TrustPointState) String() string

type TypeID 

type TypeID uint16

TypeID type represents DNS_RPC_TYPEID RPC enumeration.

The DNS Server Management Protocol RPC methods use a generic and extensible data structure of type DNSSRV_RPC_UNION structure (section 2.2.1.2.6), which is a union of pointers to different data types. A DNS_RPC_TYPEID enumeration value is used to specify what data is being stored in an instance of the DNSSRV_RPC_UNION structure. When combined with a DNSSRV_RPC_UNION structure, the DNS_RPC_TYPEID enumeration allows the DNS RPC interface to communicate many different types of DNS server configuration and data in a single structure. 

var (
	// DNSSRV_TYPEID_ANY: Type is invalid.
	TypeIDAny TypeID = 1
	// DNSSRV_TYPEID_NULL: No data is provided.
	TypeIDNull TypeID = 0
	// DNSSRV_TYPEID_DWORD: A DWORD value.
	TypeIDDword TypeID = 1
	// DNSSRV_TYPEID_LPSTR: A pointer to a null-terminated UTF-8 [RFC3629] string.
	TypeIDString TypeID = 2
	// DNSSRV_TYPEID_LPWSTR: A pointer to a null-terminated Unicode string.
	TypeIDUnicodeString TypeID = 3
	// DNSSRV_TYPEID_IPARRAY: A pointer to an IP4_ARRAY. This structure is used to specify
	// a list of IPv4 addresses.
	TypeIDIPArray TypeID = 4
	// DNSSRV_TYPEID_BUFFER: A pointer to a DNS_RPC_BUFFER (section 2.2.1.2.2). This structure
	// is used to hold a generic buffer of the DNS server information. Interpretation of
	// the buffer depends upon the request.
	TypeIDBuffer TypeID = 5
	// DNSSRV_TYPEID_SERVER_INFO_W2K: A pointer to a structure of type DNS_RPC_SERVER_INFO_W2K
	// (section 2.2.4.2.2.1). This structure is used to specify general DNS server state
	// and configuration.
	TypeIDServerInfoW2K TypeID = 6
	// DNSSRV_TYPEID_STATS: A pointer to a structure of type DNSSRV_STATS (section 2.2.10.2.2).
	// The structure exposes internal statistics and counters.
	TypeIDStats TypeID = 7
	// DNSSRV_TYPEID_FORWARDERS_W2K: A pointer to a structure of type DNS_RPC_FORWARDERS_W2K
	// (section 2.2.5.2.10.1). This structure specifies the set of DNS servers this DNS
	// server will forward unresolved queries to.
	TypeIDForwardersW2K TypeID = 8
	// DNSSRV_TYPEID_ZONE_W2K: A pointer to a structure of type DNS_RPC_ZONE_W2K (section
	// 2.2.5.2.1.1). This structure is used to specify basic information about a DNS zone.
	TypeIDZoneW2K TypeID = 9
	// DNSSRV_TYPEID_ZONE_INFO_W2K: A pointer to a structure of type DNS_RPC_ZONE_INFO_W2K
	// (section 2.2.5.2.4.1). This structure is used to specify detailed DNS zone information.
	TypeIDZoneInfoW2K TypeID = 10
	// DNSSRV_TYPEID_ZONE_SECONDARIES_W2K: A pointer to a structure of type DNS_RPC_ZONE_SECONDARIES_W2K
	// (section 2.2.5.2.5.1). This structure is used to specify information about the secondary
	// servers for a primary DNS zone.
	TypeIDZoneSecondariesW2K TypeID = 11
	// DNSSRV_TYPEID_ZONE_DATABASE_W2K: A pointer to a structure of type DNS_RPC_ZONE_DATABASE_W2K
	// (section 2.2.5.2.6.1). This structure specifies how a DNS zone is stored in persistent
	// storage.
	TypeIDZoneDatabaseW2K TypeID = 12
	// DNSSRV_TYPEID_ZONE_TYPE_RESET_W2K: This value is not used.
	TypeIDZoneTypeResetW2K TypeID = 13
	// DNSSRV_TYPEID_ZONE_CREATE_W2K: A pointer to a structure of type DNS_RPC_ZONE_CREATE_INFO_W2K
	// (section 2.2.5.2.7.1). This structure is used to specify parameters required when
	// creating a new DNS zone.
	TypeIDZoneCreateW2K TypeID = 14
	// DNSSRV_TYPEID_NAME_AND_PARAM: A pointer to a structure of type DNS_RPC_NAME_AND_PARAM
	// (section 2.2.1.2.5). This is a general purpose structure used to associate a parameter
	// name with a DWORD value.
	TypeIDNameAndParam TypeID = 15
	// DNSSRV_TYPEID_ZONE_LIST_W2K: A pointer to a structure of type DNS_RPC_ZONE_LIST_W2K
	// (section 2.2.5.2.3.1). This structure is used to enumerate zones.
	TypeIDZoneListW2K TypeID = 16
	// DNSSRV_TYPEID_ZONE_RENAME: This value is not used.
	TypeIDZoneRename TypeID = 17
	// DNSSRV_TYPEID_ZONE_EXPORT: A pointer to a structure of type DNS_RPC_ZONE_EXPORT_INFO
	// (section 2.2.5.2.8). This structure is used to specify how to export a zone to a
	// file.
	TypeIDZoneExport TypeID = 18
	// DNSSRV_TYPEID_SERVER_INFO_DOTNET: A pointer to a structure of type DNS_RPC_SERVER_INFO_DOTNET
	// (section 2.2.4.2.2.2). This structure is used to specify general DNS server state
	// and configuration.
	TypeIDServerInfoNet TypeID = 19
	// DNSSRV_TYPEID_FORWARDERS_DOTNET: A pointer to a structure of type DNS_RPC_FORWARDERS_DOTNET
	// (section 2.2.5.2.10.2). This structure specifies the set of DNS servers this DNS
	// server will forward unresolved queries to.
	TypeIDForwardersNet TypeID = 20
	// DNSSRV_TYPEID_ZONE: A pointer to a structure of type DNS_RPC_ZONE (section 2.2.5.2.1).
	// This structure is used to specify basic information and a DNS zone.
	TypeIDZone TypeID = 21
	// DNSSRV_TYPEID_ZONE_INFO_DOTNET: A pointer to a structure of type DNS_RPC_ZONE_INFO_DOTNET
	// (section 2.2.5.2.4.2). This structure is used to specify detailed information about
	// a DNS zone.
	TypeIDZoneInfoNet TypeID = 22
	// DNSSRV_TYPEID_ZONE_SECONDARIES_DOTNET: A pointer to a structure of type DNS_RPC_ZONE_SECONDARIES_DOTNET
	// (section 2.2.5.2.5.2). This structure is used to specify information about the secondary
	// servers for a primary DNS zone.
	TypeIDZoneSecondariesNet TypeID = 23
	// DNSSRV_TYPEID_ZONE_DATABASE: A pointer to a structure of type DNS_RPC_ZONE_DATABASE
	// (section 2.2.5.2.6). This structure specifies how a DNS zone is stored in persistent
	// storage.
	TypeIDZoneDatabase TypeID = 24
	// DNSSRV_TYPEID_ZONE_TYPE_RESET_DOTNET: This value is not used.
	TypeIDZoneTypeResetNet TypeID = 25
	// DNSSRV_TYPEID_ZONE_CREATE_DOTNET: A pointer to a structure of type DNS_RPC_ZONE_CREATE_INFO_DOTNET.
	// This structure is used to specify parameters required when creating a new DNS zone.
	TypeIDZoneCreateNet TypeID = 26
	// DNSSRV_TYPEID_ZONE_LIST: A pointer to a structure of type DNS_RPC_ZONE_LIST (section
	// 2.2.5.2.3). This structure is used to enumerate zones.
	TypeIDZoneList TypeID = 27
	// DNSSRV_TYPEID_DP_ENUM: A pointer to a structure of type DNS_RPC_DP_ENUM (section
	// 2.2.7.2.3). This structure is used to specify basic information about an application
	// directory partition.
	TypeIDIddpEnum TypeID = 28
	// DNSSRV_TYPEID_DP_INFO: A pointer to a structure of type DNS_RPC_DP_INFO (section
	// 2.2.7.2.1). This structure specifies detailed information about a single application
	// directory partition.
	TypeIDIddpInfo TypeID = 29
	// DNSSRV_TYPEID_DP_LIST: A pointer to a structure of type DNS_RPC_DP_LIST (section
	// 2.2.7.2.4). This structure is used to enumerate application directory partitions.
	TypeIDIddpList TypeID = 30
	// DNSSRV_TYPEID_ENLIST_DP: A pointer to a structure of type DNS_RPC_ENLIST_DP (section
	// 2.2.7.2.5). This structure is used to request enlistment changes for an application
	// directory partition.
	TypeIDEnlistDP TypeID = 31
	// DNSSRV_TYPEID_ZONE_CHANGE_DP: A pointer to a structure of type DNS_RPC_ZONE_CHANGE_DP
	// (section 2.2.7.2.6). This structure is used to request that a DNS zone be moved from
	// one application directory partition to another.
	TypeIDZoneChangeDP TypeID = 32
	// DNSSRV_TYPEID_ENUM_ZONES_FILTER: A pointer to a structure of type DNS_RPC_ENUM_ZONES_FILTER
	// (section 2.2.5.2.9). This structure is used to filter DNS zones during enumeration.
	TypeIDEnumZonesFilter TypeID = 33
	// DNSSRV_TYPEID_ADDRARRAY: A pointer to a structure of type DNS_ADDR_ARRAY (section
	// 2.2.3.2.3). This structure is used to specify a list of IPv4 or IPv6 addresses.
	TypeIDAddrArray TypeID = 34
	// DNSSRV_TYPEID_SERVER_INFO: A pointer to a structure of type DNS_RPC_SERVER_INFO (section
	// 2.2.4.2.2). This structure is used to specify general DNS server state and configuration.
	TypeIDServerInfo TypeID = 35
	// DNSSRV_TYPEID_ZONE_INFO: A pointer to a structure of type DNS_RPC_ZONE_INFO (section
	// 2.2.5.2.4). This structure is used to specify detailed information about a DNS zone.
	TypeIDZoneInfo TypeID = 36
	// DNSSRV_TYPEID_FORWARDERS: A pointer to a structure of type DNS_RPC_FORWARDERS (section
	// 2.2.5.2.10). This structure specifies the set of DNS servers this DNS server will
	// forward unresolved queries to.
	TypeIDForwarders TypeID = 37
	// DNSSRV_TYPEID_ZONE_SECONDARIES: A pointer to a structure of type DNS_RPC_ZONE_SECONDARIES
	// (section 2.2.5.2.5). This structure is used to specify information about the secondary
	// servers for a primary DNS zone.
	TypeIDZoneSecondaries TypeID = 38
	// DNSSRV_TYPEID_ZONE_TYPE_RESET: This value is not used.
	TypeIDZoneTypeReset TypeID = 39
	// DNSSRV_TYPEID_ZONE_CREATE: A pointer to a structure of type DNS_RPC_ZONE_CREATE_INFO
	// (section 2.2.5.2.7). This structure is used to specify parameters required when creating
	// a new DNS zone.
	TypeIDZoneCreate TypeID = 40
	// DNSSRV_TYPEID_IP_VALIDATE: A pointer to a structure of type DNS_RPC_IP_VALIDATE (section
	// 2.2.3.2.4). This structure is used to request IP validation and to return the results
	// of IP validation.
	TypeIDIPValidate TypeID = 41
	// DNSSRV_TYPEID_AUTOCONFIGURE: A pointer to a structure of type DNS_RPC_AUTOCONFIGURE
	// (section 2.2.8.2.1). This structure is used to request DNS server autoconfiguration.
	TypeIDAutoConfigure TypeID = 42
	// DNSSRV_TYPEID_UTF8_STRING_LIST: A pointer to a structure of type DNS_RPC_UTF8_STRING_LIST
	// (section 2.2.1.2.3). This structure is used to represent a list of UTF-8 [RFC3629]
	// strings.
	TypeIDUTF8StringList TypeID = 43
	// DNSSRV_TYPEID_UNICODE_STRING_LIST: A pointer to a structure of type DNS_RPC_UNICODE_STRING_LIST
	// (section 2.2.1.2.4). This structure is used to represent a list of Unicode strings.
	TypeIDUnicodeStringList TypeID = 44
	// DNSSRV_TYPEID_SKD: A pointer to a structure of type DNS_RPC_SKD (section 2.2.6.2.1).
	// This structure is used to specify detailed signing key descriptor (SKD) information.
	TypeIDSKD TypeID = 45
	// DNSSRV_TYPEID_SKD_LIST: A pointer to a structure of type DNS_RPC_SKD_LIST (section
	// 2.2.6.2.2). This structure is used to enumerate signing key descriptors.
	TypeIDSKDList TypeID = 46
	// DNSSRV_TYPEID_SKD_STATE: A pointer to a structure of type DNS_RPC_SKD_STATE (section
	// 2.2.6.2.3). This structure is used to specify detailed signing key descriptor state
	// information.
	TypeIDSKDState TypeID = 47
	// DNSSRV_TYPEID_SIGNING_VALIDATION_ERROR: A pointer to a structure of type DNS_RPC_SIGNING_VALIDATION_ERROR
	// (section 2.2.6.2.8). This structure is used to specify signing key descriptor validation
	// error information.
	TypeIDSigningValidationError TypeID = 48
	// DNSSRV_TYPEID_TRUST_POINT_LIST: A pointer to a structure of type DNS_RPC_TRUST_POINT_LIST
	// (section 2.2.6.2.5). This structure is used to enumerate trust points.
	TypeIDTrustPointList TypeID = 49
	// DNSSRV_TYPEID_TRUST_ANCHOR_LIST: A pointer to a structure of type DNS_RPC_TRUST_ANCHOR_LIST
	// (section 2.2.6.2.7). This structure is used to enumerate trust anchors.
	TypeIDTrustAnchorList TypeID = 50
	// DNSSRV_TYPEID_ZONE_SIGNING_SETTINGS: A pointer to a structure of type DNS_RPC_ZONE_DNSSEC_SETTINGS
	// (section 2.2.6.2.9). This structure is used to specify the DNSSEC settings for file-backed
	// zones.
	TypeIDZoneSigningSettings TypeID = 51
	// DNSSRV_TYPEID_ZONE_SCOPE_ENUM: A pointer to a structure of type DNS_RPC_ENUM_ZONE_SCOPE_LIST
	// (section 2.2.13.1.1). This structure is used to enumerate zone scopes or cache scopes.
	TypeIDZoneScopeEnum TypeID = 52
	// DNSSRV_TYPEID_ZONE_STATS: A pointer to a structure of type DNS_RPC_ZONE_STATS_V1
	// (section 2.2.12.2.5). This structure is used to enumerate the zone statistics.
	TypeIDZoneStats TypeID = 53
	// DNSSRV_TYPEID_ZONE_SCOPE_CREATE: A pointer to a structure of type DNS_RPC_ZONE_SCOPE_CREATE_INFO_V1
	// (section 2.2.13.1.2.1). This structure is used to create the zone scope or cache
	// scope.
	TypeIDZoneScopeCreate TypeID = 54
	// DNSSRV_TYPEID_ZONE_SCOPE_INFO: A pointer to a structure of type DNS_RPC_ZONE_SCOPE_INFO_V1
	// (section 2.2.13.1.3.1). This structure is used to get the zone scope or cache scope
	// information.
	TypeIDZoneScopeInfo TypeID = 55
	// DNSSRV_TYPEID_SCOPE_ENUM: A pointer to a structure of type DNS_RPC_ENUM_SCOPE_LIST
	// (section 2.2.14.1.1). The structure is used to enumerate the server scopes configured
	// on the DNS server.
	TypeIDScopeEnum TypeID = 56
	// DNSSRV_TYPEID_CLIENT_SUBNET_RECORD: A pointer to a structure of type DNS_RPC_CLIENT_SUBNET_RECORD
	// (section 2.2.15.2.1). The structure is used to enumerate the client subnet records
	// configured on the DNS server.
	TypeIDClientSubnetRecord TypeID = 57
	// DNSSRV_TYPEID_POLICY: A pointer to a structure of type DNS_RPC_POLICY (section 2.2.15.2.5).
	TypeIDPolicy TypeID = 58
	// DNSSRV_TYPEID_POLICY_NAME: A pointer to a structure of type DNS_RPC_POLICY_NAME (section
	// 2.2.15.2.6).
	TypeIDPolicyName TypeID = 59
	// DNSSRV_TYPEID_POLICY_ENUM: A pointer to a structure of type DNS_RPC_ENUMERATE_POLICY_LIST
	// (section 2.2.15.2.7). The structure is used to enumerate the DNS policy configured
	// on the DNS server.
	TypeIDPolicyEnum TypeID = 60
	// DNSSRV_TYPEID_RRL: A pointer to a structure of type DNS_RPC_RRL_PARAMS (section 2.2.16.2.1).
	// This structure is used to configure parameters for Response Rate Limiting (RRL).
	TypeIDRRL TypeID = 61
	// DNSSRV_TYPEID_VIRTUALIZATION_INSTANCE:A pointer to a structure of type DNS_RPC_VIRTUALIZATION_INSTANCE
	// (section 2.2.17.1.1).
	TypeIDVirtualizationInstance TypeID = 62
	// DNSSRV_TYPEID_VIRTUALIZATION_INSTANCE_ENUM: A pointer to a structure of type DNS_RPC_ENUM_VIRTUALIZATION_INSTANCE_LIST
	// (section 2.2.17.1.3). This structure is used to enumerate the virtualization instances
	// in the DNS Server.
	//
	// Clients and servers of the DNS Server Management Protocol SHOULD<5> support all values
	// above.
	TypeIDVirtualizationInstanceEnum TypeID = 63
)

func (TypeID) String 

func (o TypeID) String() string

type UTF8StringList 

type UTF8StringList struct {
	// dwCount: The number of strings present in the pszStrings array.
	Count uint32 `idl:"name:dwCount" json:"count"`
	// pszStrings: A variable length array of pointers to null-terminated UTF-8 strings.
	Strings string `idl:"name:pszStrings;size_is:(dwCount);string" json:"strings"`
}

UTF8StringList structure represents DNS_RPC_UTF8_STRING_LIST RPC structure.

The DNS_RPC_UTF8_STRING_LIST structure contains a list of null-terminated UTF-8 strings. This structure is used by the DNS Server Management Protocol while processing R_DnssrvOperations2 (section 3.1.4.6) and R_DnssrvQuery2 (section 3.1.4.7) method calls, with operations type "GlobalQueryBlockList".

func (*UTF8StringList) MarshalNDR 

func (o *UTF8StringList) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*UTF8StringList) UnmarshalNDR 

func (o *UTF8StringList) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type UnicodeStringList 

type UnicodeStringList struct {
	// dwCount: The number of strings present in the pwszStrings array.
	Count uint32 `idl:"name:dwCount" json:"count"`
	// pwszStrings: A variable-length array of pointers to null-terminated Unicode strings.
	Strings string `idl:"name:pwszStrings;size_is:(dwCount);string" json:"strings"`
}

UnicodeStringList structure represents DNS_RPC_UNICODE_STRING_LIST RPC structure.

The DNS_RPC_UNICODE_STRING_LIST structure contains a list of null-terminated Unicode strings. This structure is used by the DNS Server Management Protocol while processing the R_DnssrvComplexOperation2 (section 3.1.4.8) method call, with operations of type "EnumerateKeyStorageProviders".

func (*UnicodeStringList) MarshalNDR 

func (o *UnicodeStringList) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*UnicodeStringList) UnmarshalNDR 

func (o *UnicodeStringList) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type Union 

type Union struct {
	// Types that are assignable to Value
	//
	// *Union_Null
	// *Union_Dword
	// *Union_String
	// *Union_UnicodeString
	// *Union_IPArray
	// *Union_Buffer
	// *Union_ServerInfoW2K
	// *Union_Stats
	// *Union_ForwardersW2K
	// *Union_ZoneW2K
	// *Union_ZoneInfoW2K
	// *Union_SecondariesW2K
	// *Union_DatabaseW2K
	// *Union_ZoneCreateW2K
	// *Union_NameAndParam
	// *Union_ZoneListW2K
	// *Union_ServerInfoDotNet
	// *Union_ForwardersDotNet
	// *Union_Zone
	// *Union_ZoneInfoDotNet
	// *Union_SecondariesDotNet
	// *Union_Database
	// *Union_ZoneCreateDotNet
	// *Union_ZoneList
	// *Union_ZoneExport
	// *Union_DirectoryPartition
	// *Union_DirectoryPartitionEnum
	// *Union_DirectoryPartitionList
	// *Union_EnlistDirectoryPartition
	// *Union_ZoneChangeDirectoryPartition
	// *Union_EnumZonesFilter
	// *Union_AddrArray
	// *Union_ServerInfo
	// *Union_ZoneCreate
	// *Union_Forwarders
	// *Union_Secondaries
	// *Union_IPValidate
	// *Union_ZoneInfo
	// *Union_AutoConfigure
	// *Union_UTF8StringList
	// *Union_UnicodeStringList
	// *Union_SKD
	// *Union_SKDList
	// *Union_SKDState
	// *Union_SigningValidationError
	// *Union_TrustPointList
	// *Union_TrustAnchorList
	// *Union_ZoneDNSSecuritySettings
	// *Union_ZoneScopeList
	// *Union_ZoneStats
	// *Union_ScopeCreate
	// *Union_ScopeInfo
	// *Union_ScopeList
	// *Union_SubnetList
	// *Union_Policy
	// *Union_PolicyName
	// *Union_PolicyList
	// *Union_RRLParams
	// *Union_VirtualizationInstance
	// *Union_VirtualizationInstanceList
	Value is_Union `json:"value"`
}

Union structure represents DNSSRV_RPC_UNION RPC union.

The DNSSRV_RPC_UNION specifies a collection of all possible messages structures that can be exchanged between a client and server communicating using the DNS Server Management Protocol. This is used by the R_DnssrvOperation2 (section 3.1.4.6), R_DnssrvQuery2 (section 3.1.4.7) and R_DnssrvComplexOperation2 (section 3.1.4.8) method calls. The exact message format inside DNSSRV_RPC_UNION is identified by an accompanying DNS_RPC_TYPEID (section 2.2.1.1.1) value. Clients and servers of the DNS Server Management Protocol SHOULD<7> support all members of DNSSRV_RPC_UNION.

func (*Union) GetValue 

func (o *Union) GetValue() any

func (*Union) MarshalUnionNDR 

func (o *Union) MarshalUnionNDR(ctx context.Context, w ndr.Writer, sw uint32) error

func (*Union) NDRSwitchValue 

func (o *Union) NDRSwitchValue(sw uint32) uint32

func (*Union) UnmarshalUnionNDR 

func (o *Union) UnmarshalUnionNDR(ctx context.Context, w ndr.Reader, sw uint32) error

type Union_AddrArray 

type Union_AddrArray struct {
	// AddrArray: A pointer to a structure of type DNS_ADDR_ARRAY (section 2.2.3.2.3). This
	// structure is used to specify a list of IPv4 or IPv6 addresses.
	AddrArray *AddrArray `idl:"name:AddrArray" json:"addr_array"`
}

Union_AddrArray structure represents DNSSRV_RPC_UNION RPC union arm.

It has following labels: 34

func (*Union_AddrArray) MarshalNDR 

func (o *Union_AddrArray) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*Union_AddrArray) UnmarshalNDR 

func (o *Union_AddrArray) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type Union_AutoConfigure 

type Union_AutoConfigure struct {
	// AutoConfigure: A pointer to a structure of type DNS_RPC_AUTOCONFIGURE (section 2.2.8.2.1).
	// This structure is used to request DNS server autoconfiguration.
	AutoConfigure *AutoConfigure `idl:"name:AutoConfigure" json:"auto_configure"`
}

Union_AutoConfigure structure represents DNSSRV_RPC_UNION RPC union arm.

It has following labels: 42

func (*Union_AutoConfigure) MarshalNDR 

func (o *Union_AutoConfigure) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*Union_AutoConfigure) UnmarshalNDR 

func (o *Union_AutoConfigure) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type Union_Buffer 

type Union_Buffer struct {
	// Buffer: A pointer to a DNS_RPC_BUFFER (section 2.2.1.2.2).
	Buffer *Buffer `idl:"name:Buffer" json:"buffer"`
}

Union_Buffer structure represents DNSSRV_RPC_UNION RPC union arm.

It has following labels: 5

func (*Union_Buffer) MarshalNDR 

func (o *Union_Buffer) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*Union_Buffer) UnmarshalNDR 

func (o *Union_Buffer) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type Union_Database 

type Union_Database struct {
	// Database: A pointer to a structure of type DNS_RPC_ZONE_DATABASE (section 2.2.5.2.6).
	// This structure specifies how a DNS zone is stored in persistent storage.
	Database *ZoneDatabase `idl:"name:Database" json:"database"`
}

Union_Database structure represents DNSSRV_RPC_UNION RPC union arm.

It has following labels: 24

func (*Union_Database) MarshalNDR 

func (o *Union_Database) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*Union_Database) UnmarshalNDR 

func (o *Union_Database) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type Union_DatabaseW2K 

type Union_DatabaseW2K struct {
	// DatabaseW2K: A pointer to a structure of type DNS_RPC_ZONE_DATABASE_W2K (section
	// 2.2.5.2.6.1). This structure specifies how a DNS zone is stored in persistent storage.
	DatabaseW2K *ZoneDatabaseW2K `idl:"name:DatabaseW2K" json:"database_w2k"`
}

Union_DatabaseW2K structure represents DNSSRV_RPC_UNION RPC union arm.

It has following labels: 12

func (*Union_DatabaseW2K) MarshalNDR 

func (o *Union_DatabaseW2K) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*Union_DatabaseW2K) UnmarshalNDR 

func (o *Union_DatabaseW2K) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type Union_DirectoryPartition 

type Union_DirectoryPartition struct {
	// DirectoryPartition: A pointer to a structure of type DNS_RPC_DP_INFO (section 2.2.7.2.1).
	// This structure specifies detailed information about a single application directory
	// partition.
	DirectoryPartition *DPInfo `idl:"name:DirectoryPartition" json:"directory_partition"`
}

Union_DirectoryPartition structure represents DNSSRV_RPC_UNION RPC union arm.

It has following labels: 29

func (*Union_DirectoryPartition) MarshalNDR 

func (o *Union_DirectoryPartition) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*Union_DirectoryPartition) UnmarshalNDR 

func (o *Union_DirectoryPartition) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type Union_DirectoryPartitionEnum 

type Union_DirectoryPartitionEnum struct {
	// DirectoryPartitionEnum: A pointer to a structure of type DNS_RPC_DP_ENUM (section
	// 2.2.7.2.3). This structure is used to specify basic information about an application
	// directory partition.
	DirectoryPartitionEnum *DPEnum `idl:"name:DirectoryPartitionEnum" json:"directory_partition_enum"`
}

Union_DirectoryPartitionEnum structure represents DNSSRV_RPC_UNION RPC union arm.

It has following labels: 28

func (*Union_DirectoryPartitionEnum) MarshalNDR 

func (o *Union_DirectoryPartitionEnum) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*Union_DirectoryPartitionEnum) UnmarshalNDR 

func (o *Union_DirectoryPartitionEnum) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type Union_DirectoryPartitionList 

type Union_DirectoryPartitionList struct {
	// DirectoryPartitionList: A pointer to a structure of type DNS_RPC_DP_LIST (section
	// 2.2.7.2.4). This structure is used to enumerate the Application Directory Partition
	// Table.
	DirectoryPartitionList *DPList `idl:"name:DirectoryPartitionList" json:"directory_partition_list"`
}

Union_DirectoryPartitionList structure represents DNSSRV_RPC_UNION RPC union arm.

It has following labels: 30

func (*Union_DirectoryPartitionList) MarshalNDR 

func (o *Union_DirectoryPartitionList) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*Union_DirectoryPartitionList) UnmarshalNDR 

func (o *Union_DirectoryPartitionList) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type Union_Dword 

type Union_Dword struct {
	// Dword: Data is a DWORD value.
	Dword uint32 `idl:"name:Dword" json:"dword"`
}

Union_Dword structure represents DNSSRV_RPC_UNION RPC union arm.

It has following labels: 1

func (*Union_Dword) MarshalNDR 

func (o *Union_Dword) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*Union_Dword) UnmarshalNDR 

func (o *Union_Dword) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type Union_EnlistDirectoryPartition 

type Union_EnlistDirectoryPartition struct {
	// EnlistDirectoryPartition: A pointer to a structure of type DNS_RPC_ENLIST_DP (section
	// 2.2.7.2.5). This structure is used to request enlistment changes for an application
	// directory partition.
	EnlistDirectoryPartition *EnlistDP `idl:"name:EnlistDirectoryPartition" json:"enlist_directory_partition"`
}

Union_EnlistDirectoryPartition structure represents DNSSRV_RPC_UNION RPC union arm.

It has following labels: 31

func (*Union_EnlistDirectoryPartition) MarshalNDR 

func (o *Union_EnlistDirectoryPartition) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*Union_EnlistDirectoryPartition) UnmarshalNDR 

func (o *Union_EnlistDirectoryPartition) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type Union_EnumZonesFilter 

type Union_EnumZonesFilter struct {
	// EnumZonesFilter: A pointer to a structure of type DNS_RPC_ENUM_ZONES_FILTER (section
	// 2.2.5.2.9). This structure is used to filter DNS zones during enumeration.
	EnumZonesFilter *EnumZonesFilter `idl:"name:EnumZonesFilter" json:"enum_zones_filter"`
}

Union_EnumZonesFilter structure represents DNSSRV_RPC_UNION RPC union arm.

It has following labels: 33

func (*Union_EnumZonesFilter) MarshalNDR 

func (o *Union_EnumZonesFilter) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*Union_EnumZonesFilter) UnmarshalNDR 

func (o *Union_EnumZonesFilter) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type Union_Forwarders 

type Union_Forwarders struct {
	// Forwarders: A pointer to a structure of type DNS_RPC_FORWARDERS (section 2.2.5.2.10).
	// This structure specifies the set of DNS servers this DNS server will forward unresolved
	// queries to.
	Forwarders *Forwarders `idl:"name:Forwarders" json:"forwarders"`
}

Union_Forwarders structure represents DNSSRV_RPC_UNION RPC union arm.

It has following labels: 37

func (*Union_Forwarders) MarshalNDR 

func (o *Union_Forwarders) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*Union_Forwarders) UnmarshalNDR 

func (o *Union_Forwarders) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type Union_ForwardersDotNet 

type Union_ForwardersDotNet struct {
	// ForwardersDotNet: A pointer to a structure of type DNS_RPC_FORWARDERS_DOTNET (section
	// 2.2.5.2.10.2). This structure specifies the set of DNS servers this DNS server will
	// forward unresolved queries to.
	ForwardersDotNet *Forwarders_NET `idl:"name:ForwardersDotNet" json:"forwarders_dot_net"`
}

Union_ForwardersDotNet structure represents DNSSRV_RPC_UNION RPC union arm.

It has following labels: 20

func (*Union_ForwardersDotNet) MarshalNDR 

func (o *Union_ForwardersDotNet) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*Union_ForwardersDotNet) UnmarshalNDR 

func (o *Union_ForwardersDotNet) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type Union_ForwardersW2K 

type Union_ForwardersW2K struct {
	// ForwardersW2K: A pointer to a structure of type DNS_RPC_FORWARDERS_W2K (section 2.2.5.2.10.1).
	// This structure specifies the set of DNS servers this DNS server will forward unresolved
	// queries to.
	ForwardersW2K *ForwardersW2K `idl:"name:ForwardersW2K" json:"forwarders_w2k"`
}

Union_ForwardersW2K structure represents DNSSRV_RPC_UNION RPC union arm.

It has following labels: 8

func (*Union_ForwardersW2K) MarshalNDR 

func (o *Union_ForwardersW2K) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*Union_ForwardersW2K) UnmarshalNDR 

func (o *Union_ForwardersW2K) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type Union_IPArray 

type Union_IPArray struct {
	// IpArray: An array of IPv4 addresses in IP4_ARRAY (section 2.2.3.2.1) format.
	IPArray *IPv4Array `idl:"name:IpArray" json:"ip_array"`
}

Union_IPArray structure represents DNSSRV_RPC_UNION RPC union arm.

It has following labels: 4

func (*Union_IPArray) MarshalNDR 

func (o *Union_IPArray) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*Union_IPArray) UnmarshalNDR 

func (o *Union_IPArray) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type Union_IPValidate 

type Union_IPValidate struct {
	// IpValidate: A pointer to a structure of type DNS_RPC_IP_VALIDATE (section 2.2.3.2.4).
	// This structure is used to request IP validation and to return the results of IP validation.
	IPValidate *IPValidate `idl:"name:IpValidate" json:"ip_validate"`
}

Union_IPValidate structure represents DNSSRV_RPC_UNION RPC union arm.

It has following labels: 41

func (*Union_IPValidate) MarshalNDR 

func (o *Union_IPValidate) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*Union_IPValidate) UnmarshalNDR 

func (o *Union_IPValidate) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type Union_NameAndParam 

type Union_NameAndParam struct {
	// NameAndParam: A pointer to a structure of type DNS_RPC_NAME_AND_PARAM (section 2.2.1.2.5).
	// This is a general purpose structure used to associate a parameter name with a DWORD
	// value.
	NameAndParam *NameAndParam `idl:"name:NameAndParam" json:"name_and_param"`
}

Union_NameAndParam structure represents DNSSRV_RPC_UNION RPC union arm.

It has following labels: 15

func (*Union_NameAndParam) MarshalNDR 

func (o *Union_NameAndParam) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*Union_NameAndParam) UnmarshalNDR 

func (o *Union_NameAndParam) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type Union_Null 

type Union_Null struct {
	// Null: No data is provided.
	Null uint8 `idl:"name:Null" json:"null"`
}

Union_Null structure represents DNSSRV_RPC_UNION RPC union arm.

It has following labels: 0

func (*Union_Null) MarshalNDR 

func (o *Union_Null) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*Union_Null) UnmarshalNDR 

func (o *Union_Null) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type Union_Policy 

type Union_Policy struct {
	// pPolicy: A pointer to a structure of type DNS_RPC_POLICY (section 2.2.15.2.5). This
	// structure is used to retrieve details of a DNS Policy in the DNS server.
	Policy *Policy `idl:"name:pPolicy" json:"policy"`
}

Union_Policy structure represents DNSSRV_RPC_UNION RPC union arm.

It has following labels: 58

func (*Union_Policy) MarshalNDR 

func (o *Union_Policy) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*Union_Policy) UnmarshalNDR 

func (o *Union_Policy) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type Union_PolicyList 

type Union_PolicyList struct {
	// pPolicyList: A pointer to a structure of type DNS_RPC_ENUMERATE_POLICY_LIST (section
	// 2.2.15.2.7). This structure contains a list of DNS_RPC_POLICY_NAME structures.
	PolicyList *EnumeratePolicyList `idl:"name:pPolicyList" json:"policy_list"`
}

Union_PolicyList structure represents DNSSRV_RPC_UNION RPC union arm.

It has following labels: 60

func (*Union_PolicyList) MarshalNDR 

func (o *Union_PolicyList) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*Union_PolicyList) UnmarshalNDR 

func (o *Union_PolicyList) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type Union_PolicyName 

type Union_PolicyName struct {
	// pPolicyName: A pointer to a structure of type DNS_RPC_POLICY_NAME (section 2.2.15.2.6).
	// This structure is used while enumerating DNS Policies in a DNS server per level.
	PolicyName *PolicyName `idl:"name:pPolicyName" json:"policy_name"`
}

Union_PolicyName structure represents DNSSRV_RPC_UNION RPC union arm.

It has following labels: 59

func (*Union_PolicyName) MarshalNDR 

func (o *Union_PolicyName) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*Union_PolicyName) UnmarshalNDR 

func (o *Union_PolicyName) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type Union_RRLParams 

type Union_RRLParams struct {
	// pRRLParams: A pointer to a structure of type DNS_RPC_RRL_PARAMS (section 2.2.16.2.1).
	// This structure contains the configuration parameters for Response Rate Limiting (RRL).
	RRLParams *RRLParams `idl:"name:pRRLParams" json:"rrl_params"`
}

Union_RRLParams structure represents DNSSRV_RPC_UNION RPC union arm.

It has following labels: 61

func (*Union_RRLParams) MarshalNDR 

func (o *Union_RRLParams) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*Union_RRLParams) UnmarshalNDR 

func (o *Union_RRLParams) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type Union_SKD 

type Union_SKD struct {
	// Skd: A pointer to a structure of type DNS_RPC_SKD (section 2.2.6.2.1). This structure
	// is used to specify detailed signing key descriptor (SKD) information.
	SKD *SKD `idl:"name:Skd" json:"skd"`
}

Union_SKD structure represents DNSSRV_RPC_UNION RPC union arm.

It has following labels: 45

func (*Union_SKD) MarshalNDR 

func (o *Union_SKD) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*Union_SKD) UnmarshalNDR 

func (o *Union_SKD) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type Union_SKDList 

type Union_SKDList struct {
	// SkdList: A pointer to a structure of type DNS_RPC_SKD_LIST (section 2.2.6.2.2). This
	// structure is used to enumerate signing key descriptors.
	SKDList *SKDList `idl:"name:SkdList" json:"skd_list"`
}

Union_SKDList structure represents DNSSRV_RPC_UNION RPC union arm.

It has following labels: 46

func (*Union_SKDList) MarshalNDR 

func (o *Union_SKDList) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*Union_SKDList) UnmarshalNDR 

func (o *Union_SKDList) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type Union_SKDState 

type Union_SKDState struct {
	// SkdState: A pointer to a structure of type DNS_RPC_SKD_STATE (section 2.2.6.2.3).
	// This structure is used to specify detailed signing key descriptor state information.
	SKDState *SKDState `idl:"name:SkdState" json:"skd_state"`
}

Union_SKDState structure represents DNSSRV_RPC_UNION RPC union arm.

It has following labels: 47

func (*Union_SKDState) MarshalNDR 

func (o *Union_SKDState) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*Union_SKDState) UnmarshalNDR 

func (o *Union_SKDState) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type Union_ScopeCreate 

type Union_ScopeCreate struct {
	// ScopeCreate: A pointer to a structure of type DNS_RPC_ZONE_SCOPE_CREATE_INFO_V1 (section
	// 2.2.13.1.2.1). This structure is used to create a zone scope or cache scope.
	ScopeCreate *ZoneScopeCreateInfoV1 `idl:"name:ScopeCreate" json:"scope_create"`
}

Union_ScopeCreate structure represents DNSSRV_RPC_UNION RPC union arm.

It has following labels: 54

func (*Union_ScopeCreate) MarshalNDR 

func (o *Union_ScopeCreate) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*Union_ScopeCreate) UnmarshalNDR 

func (o *Union_ScopeCreate) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type Union_ScopeInfo 

type Union_ScopeInfo struct {
	// ScopeInfo: A pointer to a structure of type DNS_RPC_ZONE_SCOPE_INFO_V1 (section 2.2.13.1.3.1).
	// This structure is used to specify detailed DNS zone scope or cache scope information.
	ScopeInfo *ZoneScopeInfoV1 `idl:"name:ScopeInfo" json:"scope_info"`
}

Union_ScopeInfo structure represents DNSSRV_RPC_UNION RPC union arm.

It has following labels: 55

func (*Union_ScopeInfo) MarshalNDR 

func (o *Union_ScopeInfo) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*Union_ScopeInfo) UnmarshalNDR 

func (o *Union_ScopeInfo) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type Union_ScopeList 

type Union_ScopeList struct {
	// ScopeList: A pointer to a structure of type DNS_RPC_ENUM_SCOPE_LIST (section 2.2.14.1.1).
	// This structure is used to retrieve all the server scopes configured on the DNS server.
	ScopeList *EnumScopeList `idl:"name:ScopeList" json:"scope_list"`
}

Union_ScopeList structure represents DNSSRV_RPC_UNION RPC union arm.

It has following labels: 56

func (*Union_ScopeList) MarshalNDR 

func (o *Union_ScopeList) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*Union_ScopeList) UnmarshalNDR 

func (o *Union_ScopeList) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type Union_Secondaries 

type Union_Secondaries struct {
	// Secondaries: A pointer to a structure of type DNS_RPC_ZONE_SECONDARIES (section 2.2.5.2.5).
	// This structure is used to specify information about the secondary servers for a primary
	// DNS zone.
	Secondaries *ZoneSecondaries `idl:"name:Secondaries" json:"secondaries"`
}

Union_Secondaries structure represents DNSSRV_RPC_UNION RPC union arm.

It has following labels: 38

func (*Union_Secondaries) MarshalNDR 

func (o *Union_Secondaries) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*Union_Secondaries) UnmarshalNDR 

func (o *Union_Secondaries) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type Union_SecondariesDotNet 

type Union_SecondariesDotNet struct {
	// SecondariesDotNet: A pointer to a structure of type DNS_RPC_ZONE_SECONDARIES_DOTNET
	// (section 2.2.5.2.5.2). This structure is used to specify information about the secondary
	// servers for a primary DNS zone.
	SecondariesDotNet *ZoneSecondaries_NET `idl:"name:SecondariesDotNet" json:"secondaries_dot_net"`
}

Union_SecondariesDotNet structure represents DNSSRV_RPC_UNION RPC union arm.

It has following labels: 23

func (*Union_SecondariesDotNet) MarshalNDR 

func (o *Union_SecondariesDotNet) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*Union_SecondariesDotNet) UnmarshalNDR 

func (o *Union_SecondariesDotNet) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type Union_SecondariesW2K 

type Union_SecondariesW2K struct {
	// SecondariesW2K: A pointer to a structure of type DNS_RPC_ZONE_SECONDARIES_W2K (section
	// 2.2.5.2.5.1). This structure is used to specify information about the secondary servers
	// for a primary DNS zone.
	SecondariesW2K *ZoneSecondariesW2K `idl:"name:SecondariesW2K" json:"secondaries_w2k"`
}

Union_SecondariesW2K structure represents DNSSRV_RPC_UNION RPC union arm.

It has following labels: 11

func (*Union_SecondariesW2K) MarshalNDR 

func (o *Union_SecondariesW2K) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*Union_SecondariesW2K) UnmarshalNDR 

func (o *Union_SecondariesW2K) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type Union_ServerInfo 

type Union_ServerInfo struct {
	// ServerInfo: A pointer to a structure of type DNS_RPC_SERVER_INFO (section 2.2.4.2.2).
	// This structure is used to specify general DNS server state and configuration.
	ServerInfo *ServerInfo `idl:"name:ServerInfo" json:"server_info"`
}

Union_ServerInfo structure represents DNSSRV_RPC_UNION RPC union arm.

It has following labels: 35

func (*Union_ServerInfo) MarshalNDR 

func (o *Union_ServerInfo) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*Union_ServerInfo) UnmarshalNDR 

func (o *Union_ServerInfo) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type Union_ServerInfoDotNet 

type Union_ServerInfoDotNet struct {
	// ServerInfoDotNet: A pointer to a structure of type DNS_RPC_SERVER_INFO_DOTNET (section
	// 2.2.4.2.2.2). This structure is used to specify the general DNS server state and
	// configuration.
	ServerInfoDotNet *ServerInfo_NET `idl:"name:ServerInfoDotNet" json:"server_info_dot_net"`
}

Union_ServerInfoDotNet structure represents DNSSRV_RPC_UNION RPC union arm.

It has following labels: 19

func (*Union_ServerInfoDotNet) MarshalNDR 

func (o *Union_ServerInfoDotNet) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*Union_ServerInfoDotNet) UnmarshalNDR 

func (o *Union_ServerInfoDotNet) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type Union_ServerInfoW2K 

type Union_ServerInfoW2K struct {
	// ServerInfoW2K: A pointer to a structure of type DNS_RPC_SERVER_INFO_W2K (section
	// 2.2.4.2.2.1). This structure is used to specify the general DNS server state and
	// configuration.
	ServerInfoW2K *ServerInfoW2K `idl:"name:ServerInfoW2K" json:"server_info_w2k"`
}

Union_ServerInfoW2K structure represents DNSSRV_RPC_UNION RPC union arm.

It has following labels: 6

func (*Union_ServerInfoW2K) MarshalNDR 

func (o *Union_ServerInfoW2K) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*Union_ServerInfoW2K) UnmarshalNDR 

func (o *Union_ServerInfoW2K) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type Union_SigningValidationError 

type Union_SigningValidationError struct {
	// SigningValidationError: A pointer to a structure of type DNS_RPC_SIGNING_VALIDATION_ERROR
	// (section 2.2.6.2.8). This structure is used to specify signing key descriptor validation
	// error information.
	SigningValidationError *SigningValidationError `idl:"name:SigningValidationError" json:"signing_validation_error"`
}

Union_SigningValidationError structure represents DNSSRV_RPC_UNION RPC union arm.

It has following labels: 48

func (*Union_SigningValidationError) MarshalNDR 

func (o *Union_SigningValidationError) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*Union_SigningValidationError) UnmarshalNDR 

func (o *Union_SigningValidationError) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type Union_Stats 

type Union_Stats struct {
	// Stats: A pointer to a structure of type DNSSRV_STATS (section 2.2.10.2.2). The structure
	// exposes internal statistics and counters.
	Stats *Stat `idl:"name:Stats" json:"stats"`
}

Union_Stats structure represents DNSSRV_RPC_UNION RPC union arm.

It has following labels: 7

func (*Union_Stats) MarshalNDR 

func (o *Union_Stats) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*Union_Stats) UnmarshalNDR 

func (o *Union_Stats) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type Union_String 

type Union_String struct {
	// String: A pointer to a null-terminated UTF-8 string or a NULL pointer.
	String string `idl:"name:String;string" json:"string"`
}

Union_String structure represents DNSSRV_RPC_UNION RPC union arm.

It has following labels: 2

func (*Union_String) MarshalNDR 

func (o *Union_String) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*Union_String) UnmarshalNDR 

func (o *Union_String) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type Union_SubnetList 

type Union_SubnetList struct {
	// SubnetList: A pointer to a structure of type DNS_RPC_CLIENT_SUBNET_RECORD (section
	// 2.2.15.2.1). This structure is used to retrieve details of a client subnet record
	// in the DNS server.
	SubnetList *ClientSubnetRecord `idl:"name:SubnetList" json:"subnet_list"`
}

Union_SubnetList structure represents DNSSRV_RPC_UNION RPC union arm.

It has following labels: 57

func (*Union_SubnetList) MarshalNDR 

func (o *Union_SubnetList) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*Union_SubnetList) UnmarshalNDR 

func (o *Union_SubnetList) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type Union_TrustAnchorList 

type Union_TrustAnchorList struct {
	// TrustAnchorList: A pointer to a structure of type DNS_RPC_TRUST_ANCHOR_LIST (section
	// 2.2.6.2.7). This structure is used to enumerate trust anchors.
	TrustAnchorList *TrustAnchorList `idl:"name:TrustAnchorList" json:"trust_anchor_list"`
}

Union_TrustAnchorList structure represents DNSSRV_RPC_UNION RPC union arm.

It has following labels: 50

func (*Union_TrustAnchorList) MarshalNDR 

func (o *Union_TrustAnchorList) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*Union_TrustAnchorList) UnmarshalNDR 

func (o *Union_TrustAnchorList) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type Union_TrustPointList 

type Union_TrustPointList struct {
	// TrustPointList: A pointer to a structure of type DNS_RPC_TRUST_POINT_LIST (section
	// 2.2.6.2.5). This structure is used to enumerate trust points.
	TrustPointList *TrustPointList `idl:"name:TrustPointList" json:"trust_point_list"`
}

Union_TrustPointList structure represents DNSSRV_RPC_UNION RPC union arm.

It has following labels: 49

func (*Union_TrustPointList) MarshalNDR 

func (o *Union_TrustPointList) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*Union_TrustPointList) UnmarshalNDR 

func (o *Union_TrustPointList) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type Union_UTF8StringList 

type Union_UTF8StringList struct {
	// Utf8StringList: A pointer to a structure of type DNS_RPC_UTF8_STRING_LIST (section
	// 2.2.1.2.3). This structure is used to represent a list of UTF-8 [RFC3629] strings.
	UTF8StringList *UTF8StringList `idl:"name:Utf8StringList" json:"utf8_string_list"`
}

Union_UTF8StringList structure represents DNSSRV_RPC_UNION RPC union arm.

It has following labels: 43

func (*Union_UTF8StringList) MarshalNDR 

func (o *Union_UTF8StringList) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*Union_UTF8StringList) UnmarshalNDR 

func (o *Union_UTF8StringList) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type Union_UnicodeString 

type Union_UnicodeString struct {
	// WideString: A pointer to a null-terminated Unicode string or a NULL pointer.
	UnicodeString string `idl:"name:WideString;string" json:"unicode_string"`
}

Union_UnicodeString structure represents DNSSRV_RPC_UNION RPC union arm.

It has following labels: 3

func (*Union_UnicodeString) MarshalNDR 

func (o *Union_UnicodeString) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*Union_UnicodeString) UnmarshalNDR 

func (o *Union_UnicodeString) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type Union_UnicodeStringList 

type Union_UnicodeStringList struct {
	// UnicodeStringList: A pointer to a structure of type DNS_RPC_UNICODE_STRING_LIST (section
	// 2.2.1.2.4). This structure is used to represent a list of Unicode strings.
	UnicodeStringList *UnicodeStringList `idl:"name:UnicodeStringList" json:"unicode_string_list"`
}

Union_UnicodeStringList structure represents DNSSRV_RPC_UNION RPC union arm.

It has following labels: 44

func (*Union_UnicodeStringList) MarshalNDR 

func (o *Union_UnicodeStringList) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*Union_UnicodeStringList) UnmarshalNDR 

func (o *Union_UnicodeStringList) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type Union_VirtualizationInstance 

type Union_VirtualizationInstance struct {
	// VirtualizationInstance: A pointer to a structure of type DNS_RPC_VIRTUALIZATION_INSTANCE
	// (section 2.2.17.1.1). This structure is used to retrieve details of a virtualization
	// instance in the DNS server.
	VirtualizationInstance *VirtualizationInstance `idl:"name:VirtualizationInstance" json:"virtualization_instance"`
}

Union_VirtualizationInstance structure represents DNSSRV_RPC_UNION RPC union arm.

It has following labels: 62

func (*Union_VirtualizationInstance) MarshalNDR 

func (o *Union_VirtualizationInstance) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*Union_VirtualizationInstance) UnmarshalNDR 

func (o *Union_VirtualizationInstance) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type Union_VirtualizationInstanceList 

type Union_VirtualizationInstanceList struct {
	// VirtualizationInstanceList: A pointer to a structure of type DNS_RPC_ENUM_VIRTUALIZATION_INSTANCE_LIST
	// (section 2.2.17.1.3). This structure is used to enumerate virtualization instances
	// in a DNS server.
	VirtualizationInstanceList *EnumVirtualizationInstanceList `idl:"name:VirtualizationInstanceList" json:"virtualization_instance_list"`
}

Union_VirtualizationInstanceList structure represents DNSSRV_RPC_UNION RPC union arm.

It has following labels: 63

func (*Union_VirtualizationInstanceList) MarshalNDR 

func (o *Union_VirtualizationInstanceList) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*Union_VirtualizationInstanceList) UnmarshalNDR 

func (o *Union_VirtualizationInstanceList) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type Union_Zone 

type Union_Zone struct {
	// Zone: A pointer to a structure of type DNS_RPC_ZONE (section 2.2.5.2.1). This structure
	// is used to specify basic information about a DNS zone.
	Zone *Zone `idl:"name:Zone" json:"zone"`
}

Union_Zone structure represents DNSSRV_RPC_UNION RPC union arm.

It has following labels: 21

func (*Union_Zone) MarshalNDR 

func (o *Union_Zone) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*Union_Zone) UnmarshalNDR 

func (o *Union_Zone) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type Union_ZoneChangeDirectoryPartition 

type Union_ZoneChangeDirectoryPartition struct {
	// ZoneChangeDirectoryPartition: A pointer to a structure of type DNS_RPC_ZONE_CHANGE_DP
	// (section 2.2.7.2.6). This structure is used to request that a DNS zone be moved from
	// one application directory partition to another.
	ZoneChangeDirectoryPartition *ZoneChangeDP `idl:"name:ZoneChangeDirectoryPartition" json:"zone_change_directory_partition"`
}

Union_ZoneChangeDirectoryPartition structure represents DNSSRV_RPC_UNION RPC union arm.

It has following labels: 32

func (*Union_ZoneChangeDirectoryPartition) MarshalNDR 

func (o *Union_ZoneChangeDirectoryPartition) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*Union_ZoneChangeDirectoryPartition) UnmarshalNDR 

func (o *Union_ZoneChangeDirectoryPartition) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type Union_ZoneCreate 

type Union_ZoneCreate struct {
	// ZoneCreate: A pointer to a structure of type DNS_RPC_ZONE_CREATE_INFO (section 2.2.5.2.7).
	// This structure is used to specify the parameters required when creating a new DNS
	// zone.
	ZoneCreate *ZoneCreateInfo `idl:"name:ZoneCreate" json:"zone_create"`
}

Union_ZoneCreate structure represents DNSSRV_RPC_UNION RPC union arm.

It has following labels: 40

func (*Union_ZoneCreate) MarshalNDR 

func (o *Union_ZoneCreate) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*Union_ZoneCreate) UnmarshalNDR 

func (o *Union_ZoneCreate) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type Union_ZoneCreateDotNet 

type Union_ZoneCreateDotNet struct {
	// ZoneCreateDotNet: A pointer to a structure of type DNS_RPC_ZONE_CREATE_INFO_DOTNET
	// (section 2.2.5.2.7.2). This structure is used to specify the parameters required
	// when creating a new DNS zone.
	ZoneCreateDotNet *ZoneCreateInfo_NET `idl:"name:ZoneCreateDotNet" json:"zone_create_dot_net"`
}

Union_ZoneCreateDotNet structure represents DNSSRV_RPC_UNION RPC union arm.

It has following labels: 26

func (*Union_ZoneCreateDotNet) MarshalNDR 

func (o *Union_ZoneCreateDotNet) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*Union_ZoneCreateDotNet) UnmarshalNDR 

func (o *Union_ZoneCreateDotNet) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type Union_ZoneCreateW2K 

type Union_ZoneCreateW2K struct {
	// ZoneCreateW2K: A pointer to a structure of type DNS_RPC_ZONE_CREATE_INFO_W2K (section
	// 2.2.5.2.7.1). This structure is used to specify the parameters required when creating
	// a new DNS zone.
	ZoneCreateW2K *ZoneCreateInfoW2K `idl:"name:ZoneCreateW2K" json:"zone_create_w2k"`
}

Union_ZoneCreateW2K structure represents DNSSRV_RPC_UNION RPC union arm.

It has following labels: 14

func (*Union_ZoneCreateW2K) MarshalNDR 

func (o *Union_ZoneCreateW2K) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*Union_ZoneCreateW2K) UnmarshalNDR 

func (o *Union_ZoneCreateW2K) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type Union_ZoneDNSSecuritySettings 

type Union_ZoneDNSSecuritySettings struct {
	// ZoneDnsSecSettings: A pointer to a structure of type DNS_RPC_ZONE_DNSSEC_SETTINGS
	// (section 2.2.6.2.9). This structure is used to list the DNSSEC settings of a zone.
	ZoneDNSSecuritySettings *ZoneDnssecSettings `idl:"name:ZoneDnsSecSettings" json:"zone_dns_security_settings"`
}

Union_ZoneDNSSecuritySettings structure represents DNSSRV_RPC_UNION RPC union arm.

It has following labels: 51

func (*Union_ZoneDNSSecuritySettings) MarshalNDR 

func (o *Union_ZoneDNSSecuritySettings) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*Union_ZoneDNSSecuritySettings) UnmarshalNDR 

func (o *Union_ZoneDNSSecuritySettings) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type Union_ZoneExport 

type Union_ZoneExport struct {
	// ZoneExport: A pointer to a structure of type DNS_RPC_ZONE_EXPORT_INFO (section 2.2.5.2.8).
	// This structure is used to specify how a zone is exported to file.
	ZoneExport *ZoneExportInfo `idl:"name:ZoneExport" json:"zone_export"`
}

Union_ZoneExport structure represents DNSSRV_RPC_UNION RPC union arm.

It has following labels: 18

func (*Union_ZoneExport) MarshalNDR 

func (o *Union_ZoneExport) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*Union_ZoneExport) UnmarshalNDR 

func (o *Union_ZoneExport) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type Union_ZoneInfo 

type Union_ZoneInfo struct {
	// ZoneInfo: A pointer to a structure of type DNS_RPC_ZONE_INFO (section 2.2.5.2.4).
	// This structure is used to specify detailed DNS zone information.
	ZoneInfo *ZoneInfo `idl:"name:ZoneInfo" json:"zone_info"`
}

Union_ZoneInfo structure represents DNSSRV_RPC_UNION RPC union arm.

It has following labels: 36

func (*Union_ZoneInfo) MarshalNDR 

func (o *Union_ZoneInfo) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*Union_ZoneInfo) UnmarshalNDR 

func (o *Union_ZoneInfo) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type Union_ZoneInfoDotNet 

type Union_ZoneInfoDotNet struct {
	// ZoneInfoDotNet: A pointer to a structure of type DNS_RPC_ZONE_INFO_DOTNET (section
	// 2.2.5.2.4.2). This structure is used to specify detailed DNS zone information.
	ZoneInfoDotNet *ZoneInfo_NET `idl:"name:ZoneInfoDotNet" json:"zone_info_dot_net"`
}

Union_ZoneInfoDotNet structure represents DNSSRV_RPC_UNION RPC union arm.

It has following labels: 22

func (*Union_ZoneInfoDotNet) MarshalNDR 

func (o *Union_ZoneInfoDotNet) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*Union_ZoneInfoDotNet) UnmarshalNDR 

func (o *Union_ZoneInfoDotNet) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type Union_ZoneInfoW2K 

type Union_ZoneInfoW2K struct {
	// ZoneInfoW2K: A pointer to a structure of type DNS_RPC_ZONE_INFO_W2K (section 2.2.5.2.4.1).
	// This structure is used to specify detailed DNS zone information.
	ZoneInfoW2K *ZoneInfoW2K `idl:"name:ZoneInfoW2K" json:"zone_info_w2k"`
}

Union_ZoneInfoW2K structure represents DNSSRV_RPC_UNION RPC union arm.

It has following labels: 10

func (*Union_ZoneInfoW2K) MarshalNDR 

func (o *Union_ZoneInfoW2K) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*Union_ZoneInfoW2K) UnmarshalNDR 

func (o *Union_ZoneInfoW2K) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type Union_ZoneList 

type Union_ZoneList struct {
	// ZoneList: A pointer to a structure of type DNS_RPC_ZONE_LIST (section 2.2.5.2.3).
	// This structure is used to enumerate zones.
	ZoneList *ZoneList `idl:"name:ZoneList" json:"zone_list"`
}

Union_ZoneList structure represents DNSSRV_RPC_UNION RPC union arm.

It has following labels: 27

func (*Union_ZoneList) MarshalNDR 

func (o *Union_ZoneList) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*Union_ZoneList) UnmarshalNDR 

func (o *Union_ZoneList) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type Union_ZoneListW2K 

type Union_ZoneListW2K struct {
	// ZoneListW2K: A pointer to a structure of type DNS_RPC_ZONE_LIST_W2K (section 2.2.5.2.3.1).
	// This structure is used to enumerate zones.
	ZoneListW2K *ZoneListW2K `idl:"name:ZoneListW2K" json:"zone_list_w2k"`
}

Union_ZoneListW2K structure represents DNSSRV_RPC_UNION RPC union arm.

It has following labels: 16

func (*Union_ZoneListW2K) MarshalNDR 

func (o *Union_ZoneListW2K) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*Union_ZoneListW2K) UnmarshalNDR 

func (o *Union_ZoneListW2K) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type Union_ZoneScopeList 

type Union_ZoneScopeList struct {
	// ZoneScopeList: A pointer to a structure of type DNS_RPC_ENUM_ZONE_SCOPE_LIST (section
	// 2.2.13.1.1). This structure is used to enumerate zone scopes in a specified zone
	// or cache scopes in a cache zone.
	ZoneScopeList *EnumZoneScopeList `idl:"name:ZoneScopeList" json:"zone_scope_list"`
}

Union_ZoneScopeList structure represents DNSSRV_RPC_UNION RPC union arm.

It has following labels: 52

func (*Union_ZoneScopeList) MarshalNDR 

func (o *Union_ZoneScopeList) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*Union_ZoneScopeList) UnmarshalNDR 

func (o *Union_ZoneScopeList) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type Union_ZoneStats 

type Union_ZoneStats struct {
	// ZoneStats: A pointer to a structure of type DNS_RPC_ZONE_STATS_V1 (section 2.2.12.2.5).
	// This structure is used to enumerate the zone statistics.
	ZoneStats *ZoneStatsV1 `idl:"name:ZoneStats" json:"zone_stats"`
}

Union_ZoneStats structure represents DNSSRV_RPC_UNION RPC union arm.

It has following labels: 53

func (*Union_ZoneStats) MarshalNDR 

func (o *Union_ZoneStats) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*Union_ZoneStats) UnmarshalNDR 

func (o *Union_ZoneStats) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type Union_ZoneW2K 

type Union_ZoneW2K struct {
	// ZoneW2K: A pointer to a structure of type DNS_RPC_ZONE_W2K (section 2.2.5.2.1.1).
	// This structure is used to specify basic information about a DNS zone.
	ZoneW2K *ZoneW2K `idl:"name:ZoneW2K" json:"zone_w2k"`
}

Union_ZoneW2K structure represents DNSSRV_RPC_UNION RPC union arm.

It has following labels: 9

func (*Union_ZoneW2K) MarshalNDR 

func (o *Union_ZoneW2K) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*Union_ZoneW2K) UnmarshalNDR 

func (o *Union_ZoneW2K) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type VirtualizationInstance 

type VirtualizationInstance struct {
	RPCStructureVersion uint32 `idl:"name:dwRpcStructureVersion" json:"rpc_structure_version"`

	Flags            uint32 `idl:"name:dwFlags" json:"flags"`
	VirtualizationID string `idl:"name:pwszVirtualizationID" json:"virtualization_id"`
	FriendlyName     string `idl:"name:pwszFriendlyName" json:"friendly_name"`
	Description      string `idl:"name:pwszDescription" json:"description"`
	// contains filtered or unexported fields
}

VirtualizationInstance structure represents DNS_RPC_VIRTUALIZATION_INSTANCE RPC structure.

The following example describes how to create a new virtualization instance named "example_vi1" in the DNS server.

The client calls R_DnssrvOperation4 (section 3.1.4.16) and provides the following parameters:

* *DNS_RPC_CURRENT_CLIENT_VER* (section 2.2.1.2.1 ( a237781b-b048-495d-844b-10ffb38df2a8 ) ) as the client version.

* Zero as the settings flag.

* A Unicode string containing the FQDN of the DNS server on which the virtualization instance is to be created.

* Zero as the context.

* CreateVirtualizationInstance as the operation.

* DNSSRV_TYPEID_VIRTUALIZATION_INSTANCE as the type ID.

* Create a DNS_RPC_VIRTUALIZATION_INSTANCE (section 2.2.17.1.1 ( 44d991d5-392a-48e7-827f-a1ccbe22ddef ) ) structure with dwFlags as zero and pwszVirtualizationID as "example_vi1". Pass this structure as RPC data.

The DNS server returns ERROR_SUCCESS if the operation was successful or a Windows error code if the operation fails.

func (*VirtualizationInstance) MarshalNDR 

func (o *VirtualizationInstance) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*VirtualizationInstance) UnmarshalNDR 

func (o *VirtualizationInstance) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type VirtualizationInstanceInfo 

type VirtualizationInstanceInfo struct {
	// pwszVirtualizationID: A NULL-terminated Unicode string that uniquely identifies a
	// particular virtualization instance in the DNS server. The maximum length of this
	// identifier is limited to 64 characters.
	VirtualizationID string `idl:"name:pwszVirtualizationID" json:"virtualization_id"`
	// pwszFriendlyName: A NULL-terminated Unicode string that contains a user-friendly
	// name of the DNS virtualization instance.
	FriendlyName string `idl:"name:pwszFriendlyName" json:"friendly_name"`
	// pwszDescription: A NULL-terminated Unicode string that contains a description of
	// the DNS virtualization instance.
	Description string `idl:"name:pwszDescription" json:"description"`
}

VirtualizationInstanceInfo structure represents DNS_RPC_VIRTUALIZATION_INSTANCE_INFO RPC structure.

The DNS_RPC_VIRTUALIZATION_INSTANCE_INFO structure contains the details of a virtualization instance when the virtualization instances in the DNS server are enumerated (section 3.1.4.15).

func (*VirtualizationInstanceInfo) MarshalNDR 

func (o *VirtualizationInstanceInfo) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*VirtualizationInstanceInfo) UnmarshalNDR 

func (o *VirtualizationInstanceInfo) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type Zone 

type Zone struct {
	RPCStructureVersion uint32 `idl:"name:dwRpcStructureVersion" json:"rpc_structure_version"`

	ZoneName string `idl:"name:pszZoneName;string" json:"zone_name"`
	Flags    uint32 `idl:"name:Flags" json:"flags"`
	ZoneType uint8  `idl:"name:ZoneType" json:"zone_type"`
	Version  uint8  `idl:"name:Version" json:"version"`
	DPFlags  uint32 `idl:"name:dwDpFlags" json:"dp_flags"`
	DPFQDN   string `idl:"name:pszDpFqdn;string" json:"dp_fqdn"`
	// contains filtered or unexported fields
}

Zone structure represents DNS_RPC_ZONE RPC structure.

The DNS_RPC_ZONE structure contains basic information about a zone present on the DNS server. There are different versions of the DNS_RPC_ZONE structure. The DNS server MAY<38> decide to use one of these structures depending upon the value of the dwClientVersion field in DNS Server Management Protocol method calls (section 3.1.4) as follows in the table provided. If the method call does not specify the value of dwClientVersion, the DNS_RPC_ZONE_W2K version of the structure MUST be used. 

+------------+-------------------------------------------+
|            |                                           |
|   VALUE    |                 STRUCTURE                 |
|            |                                           |
+------------+-------------------------------------------+
+------------+-------------------------------------------+
| 0x00000000 | DNS_RPC_ZONE_W2K (section 2.2.5.2.1.1)    |
+------------+-------------------------------------------+
| 0x00060000 | DNS_RPC_ZONE_DOTNET (section 2.2.5.2.1.2) |
+------------+-------------------------------------------+

func (*Zone) MarshalNDR 

func (o *Zone) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*Zone) UnmarshalNDR 

func (o *Zone) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type ZoneChangeDP 

type ZoneChangeDP struct {
	// dwRpcStructureVersion: As specified in section 2.2.7.2.5.
	RPCStructureVersion uint32 `idl:"name:dwRpcStructureVersion" json:"rpc_structure_version"`

	// pszDestPartition: A pointer to a null-terminated UTF-8 string that specifies the
	// distinguished name for a new application directory partition to which a zone is to
	// be moved.
	DestinationPartition string `idl:"name:pszDestPartition;string" json:"destination_partition"`
	// contains filtered or unexported fields
}

ZoneChangeDP structure represents DNS_RPC_ZONE_CHANGE_DP RPC structure.

The DNS_RPC_ZONE_CHANGE_DP structure contains information required to move a zone to a different application directory partition on the DNS server.<61>

func (*ZoneChangeDP) MarshalNDR 

func (o *ZoneChangeDP) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*ZoneChangeDP) UnmarshalNDR 

func (o *ZoneChangeDP) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type ZoneCreateInfo 

type ZoneCreateInfo struct {
	RPCStructureVersion uint32 `idl:"name:dwRpcStructureVersion" json:"rpc_structure_version"`

	ZoneName               string     `idl:"name:pszZoneName;string" json:"zone_name"`
	ZoneType               uint32     `idl:"name:dwZoneType" json:"zone_type"`
	AllowUpdate            uint32     `idl:"name:fAllowUpdate" json:"allow_update"`
	Aging                  uint32     `idl:"name:fAging" json:"aging"`
	Flags                  uint32     `idl:"name:dwFlags" json:"flags"`
	DataFile               string     `idl:"name:pszDataFile;string" json:"data_file"`
	DSIntegrated           uint32     `idl:"name:fDsIntegrated" json:"ds_integrated"`
	LoadExisting           uint32     `idl:"name:fLoadExisting" json:"load_existing"`
	Admin                  string     `idl:"name:pszAdmin;string" json:"admin"`
	Masters                *AddrArray `idl:"name:aipMasters" json:"masters"`
	Secondaries            *AddrArray `idl:"name:aipSecondaries" json:"secondaries"`
	SecureSecondaries      uint32     `idl:"name:fSecureSecondaries" json:"secure_secondaries"`
	NotifyLevel            uint32     `idl:"name:fNotifyLevel" json:"notify_level"`
	Timeout                uint32     `idl:"name:dwTimeout" json:"timeout"`
	RecurseAfterForwarding uint32     `idl:"name:fRecurseAfterForwarding" json:"recurse_after_forwarding"`
	DPFlags                uint32     `idl:"name:dwDpFlags" json:"dp_flags"`
	DPFQDN                 string     `idl:"name:pszDpFqdn;string" json:"dp_fqdn"`
	// contains filtered or unexported fields
}

ZoneCreateInfo structure represents DNS_RPC_ZONE_CREATE_INFO RPC structure.

The DNS_RPC_ZONE_CREATE_INFO structure contains information required to create a zone or reset a zone's information on the DNS server. There are different versions of the DNS_RPC_ZONE_CREATE_INFO structure. The DNS server MUST use the structure corresponding to the value of dwClientVersion in DNS Server Management Protocol method calls (section 3.1.4) as shown in the following table, or if the method call does not specify the value of dwClientVersion, the DNS_RPC_ZONE_CREATE_INFO_W2K version of the structure MUST be used. 

+------------+---------------------------------------------------------+
|            |                                                         |
|   VALUE    |                        STRUCTURE                        |
|            |                                                         |
+------------+---------------------------------------------------------+
+------------+---------------------------------------------------------+
| 0x00000000 | DNS_RPC_ZONE_CREATE_INFO_W2K (section 2.2.5.2.7.1)      |
+------------+---------------------------------------------------------+
| 0x00060000 | DNS_RPC_ZONE_CREATE_INFO_DOTNET (section 2.2.5.2.7.2)   |
+------------+---------------------------------------------------------+
| 0x00070000 | DNS_RPC_ZONE_CREATE_INFO_LONGHORN (section 2.2.5.2.7.3) |
+------------+---------------------------------------------------------+

func (*ZoneCreateInfo) MarshalNDR 

func (o *ZoneCreateInfo) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*ZoneCreateInfo) UnmarshalNDR 

func (o *ZoneCreateInfo) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type ZoneCreateInfoLonghorn 

type ZoneCreateInfoLonghorn struct {
	// dwRpcStructureVersion: As specified in section 2.2.5.2.4.3.
	RPCStructureVersion uint32 `idl:"name:dwRpcStructureVersion" json:"rpc_structure_version"`

	ZoneName     string `idl:"name:pszZoneName;string" json:"zone_name"`
	ZoneType     uint32 `idl:"name:dwZoneType" json:"zone_type"`
	AllowUpdate  uint32 `idl:"name:fAllowUpdate" json:"allow_update"`
	Aging        uint32 `idl:"name:fAging" json:"aging"`
	Flags        uint32 `idl:"name:dwFlags" json:"flags"`
	DataFile     string `idl:"name:pszDataFile;string" json:"data_file"`
	DSIntegrated uint32 `idl:"name:fDsIntegrated" json:"ds_integrated"`
	LoadExisting uint32 `idl:"name:fLoadExisting" json:"load_existing"`
	Admin        string `idl:"name:pszAdmin;string" json:"admin"`
	// aipMasters: As specified in section 2.2.5.2.4.3.
	Masters *AddrArray `idl:"name:aipMasters" json:"masters"`
	// aipSecondaries: As specified in section 2.2.5.2.4.3.
	//
	// If the DNS RPC client sends an older version of DNS_RPC_ZONE_CREATE_INFO structure
	// such as DNS_RPC_ZONE_CREATE_INFO_W2K (section 2.2.5.2.7.1) or DNS_RPC_ZONE_CREATE_INFO_DOTNET
	// (section 2.2.5.2.7.2), then the DNS RPC server MUST construct a current version of
	// DNS_RPC_ZONE_CREATE_INFO structure such as DNS_RPC_ZONE_CREATE_INFO_LONGHORN, using
	// steps as specified below:
	//
	// *
	//
	// Copy the same value for fields that are common to input and current version of DNS_RPC_ZONE_CREATE_INFO
	// structures.
	//
	// *
	//
	// dwRpcStructureVersion field MUST be set to 2.
	//
	// *
	//
	// The values for aipMasters and aipSecondaries fields MUST be obtained from input structure
	// as IP4_ARRAY type and MUST be converted to DNS_ADDR_ARRAY type, and then assigned
	// to aipMasters and aipSecondaries fields in the DNS_RPC_ZONE_CREATE_INFO_LONGHORN
	// structure.
	//
	// *Note* DNS_RPC_ZONE_CREATE_INFO_W2K (section 2.2.5.2.7.1) and DNS_RPC_ZONE_CREATE_INFO_DOTNET
	// (section 2.2.5.2.7.2), do not support IPv6 ( a95b05da-f1fd-4db3-94b4-817fdaa1f642#gt_64c29bb6-c8b2-4281-9f3a-c1eb5d2288aa
	// ) address list of *aipMasters* and *aipSecondaries*.
	//
	// *
	//
	// All other fields that are defined only in DNS_RPC_ZONE_CREATE_INFO_LONGHORN and are
	// not defined in DNS_RPC_ZONE_CREATE_INFO_W2K (section 2.2.5.2.7.1) or DNS_RPC_ZONE_CREATE_INFO_DOTNET
	// (section 2.2.5.2.7.2) structure MUST be set to 0.
	Secondaries            *AddrArray `idl:"name:aipSecondaries" json:"secondaries"`
	SecureSecondaries      uint32     `idl:"name:fSecureSecondaries" json:"secure_secondaries"`
	NotifyLevel            uint32     `idl:"name:fNotifyLevel" json:"notify_level"`
	Timeout                uint32     `idl:"name:dwTimeout" json:"timeout"`
	RecurseAfterForwarding uint32     `idl:"name:fRecurseAfterForwarding" json:"recurse_after_forwarding"`
	DPFlags                uint32     `idl:"name:dwDpFlags" json:"dp_flags"`
	DPFQDN                 string     `idl:"name:pszDpFqdn;string" json:"dp_fqdn"`
	// contains filtered or unexported fields
}

ZoneCreateInfoLonghorn structure represents DNS_RPC_ZONE_CREATE_INFO_LONGHORN RPC structure.

In the DNS_RPC_ZONE_CREATE_INFO_LONGHORN structure all fields have same definition as specified in section DNS_RPC_ZONE_CREATE_INFO_DOTNET (section 2.2.5.2.7.2), with the following exceptions:

func (*ZoneCreateInfoLonghorn) MarshalNDR 

func (o *ZoneCreateInfoLonghorn) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*ZoneCreateInfoLonghorn) UnmarshalNDR 

func (o *ZoneCreateInfoLonghorn) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type ZoneCreateInfoW2K 

type ZoneCreateInfoW2K struct {
	// pszZoneName: As specified in section 2.2.5.2.4.1.
	ZoneName string `idl:"name:pszZoneName;string" json:"zone_name"`
	// dwZoneType: The zone type. This MUST be set to one of the allowed values specified
	// in DNS_ZONE_TYPE (section 2.2.5.1.1), and it MUST NOT be either DNS_ZONE_TYPE_CACHE
	// or DNS_ZONE_TYPE_SECONDARY_CACHE.
	ZoneType uint32 `idl:"name:dwZoneType" json:"zone_type"`
	// fAllowUpdate: As specified in section 2.2.5.2.4.1.
	AllowUpdate uint32 `idl:"name:fAllowUpdate" json:"allow_update"`
	// fAging: As specified in section 2.2.5.2.4.1.
	Aging uint32 `idl:"name:fAging" json:"aging"`
	// dwFlags: The zone creation behavior that the DNS server is to follow while creating
	// the zone. This field is only used when the operation is ZoneCreate. The DNS server
	// MUST ignore the value of this field when the operation is ZoneTypeReset. This field
	// MUST be set to any combination of the following values:
	//
	//	+-----------------------------------------------+----------------------------------------------------------------------------------+
	//	|                                               |                                                                                  |
	//	|                     VALUE                     |                                     MEANING                                      |
	//	|                                               |                                                                                  |
	//	+-----------------------------------------------+----------------------------------------------------------------------------------+
	//	+-----------------------------------------------+----------------------------------------------------------------------------------+
	//	| DNS_ZONE_LOAD_OVERWRITE_MEMORY 0x00000010     | If dwZoneType is not set to the value DNS_ZONE_TYPE_PRIMARY (section 2.2.5.1.1), |
	//	|                                               | then this flag MUST be ignored. Otherwise, the DNS server MUST attempt to find   |
	//	|                                               | and load the zone database from persistent storage instead of creating a new     |
	//	|                                               | empty zone database. If the value of fDsIntegrated is 0x00000001 then the DNS    |
	//	|                                               | server MUST search for a pre-existing zone database in the directory server,     |
	//	|                                               | otherwise the DNS server MUST search for a pre-existing zone database in a       |
	//	|                                               | file. If a pre-existing zone database is not found then it continues with zone   |
	//	|                                               | creation, however if a pre-existing zone database is found but could not be      |
	//	|                                               | loaded, the DNS server MUST fail the operation and return an error.              |
	//	+-----------------------------------------------+----------------------------------------------------------------------------------+
	//	| DNS_ZONE_CREATE_FOR_DCPROMO 0x00001000        | If this flag is set, the DNS server MUST create the zone such that it is         |
	//	|                                               | directory server-integrated and stored in the DNS domain partition.              |
	//	+-----------------------------------------------+----------------------------------------------------------------------------------+
	//	| DNS_ZONE_CREATE_FOR_DCPROMO_FOREST 0x00004000 | If this flag is set, the DNS server MUST create the zone such that it is         |
	//	|                                               | directory server-integrated and stored in the DNS forest partition.              |
	//	+-----------------------------------------------+----------------------------------------------------------------------------------+
	Flags uint32 `idl:"name:dwFlags" json:"flags"`
	// pszDataFile: As specified in section 2.2.5.2.4.1.
	DataFile string `idl:"name:pszDataFile;string" json:"data_file"`
	// fDsIntegrated: A value of 0x00000001 indicates that the zone is to be created to
	// use the directory server for persistent storage, and 0x00000000 indicates it is not.
	// If this is set to 0x00000001 the caller MUST specify the application directory partition
	// information in pszDpFqdn (section 2.2.5.2.7.2); in this case the DNS server MUST
	// ignore the value of pszDataFile.
	DSIntegrated uint32 `idl:"name:fDsIntegrated" json:"ds_integrated"`
	// fLoadExisting: If the operation is ZoneCreate this field is interpreted as a Boolean
	// value. If set to TRUE this has the same effect as specifying DNS_ZONE_LOAD_OVERWRITE_MEMORY
	// in the dwFlags field. If the operation is ZoneTypeReset, this field can be set to
	// one of the following values; however, the DNS server MUST ignore the value of this
	// field if fDsIntegrated is not TRUE or dwZoneType is not DNS_ZONE_TYPE_PRIMARY (section
	// 2.2.5.1.1).
	//
	//	+-------------------------------------------+----------------------------------------------------------------------------------+
	//	|                                           |                                                                                  |
	//	|                   VALUE                   |                                     MEANING                                      |
	//	|                                           |                                                                                  |
	//	+-------------------------------------------+----------------------------------------------------------------------------------+
	//	+-------------------------------------------+----------------------------------------------------------------------------------+
	//	| DNS_ZONE_LOAD_OVERWRITE_MEMORY 0x00000010 | The server MUST attempt to find and load the zone database from persistent       |
	//	|                                           | storage instead of retaining the existing in-memory zone database by searching   |
	//	|                                           | for a pre-existing zone database in the directory server. If a pre-existing zone |
	//	|                                           | database is not found, then the server MUST fail the operation and return an     |
	//	|                                           | error.                                                                           |
	//	+-------------------------------------------+----------------------------------------------------------------------------------+
	//	| DNS_ZONE_LOAD_OVERWRITE_DS 0x00000020     | If this flag is set and if the zone already exists in the database, then the     |
	//	|                                           | server MUST overwrite the existing zone database with current in-memory zone     |
	//	|                                           | database.                                                                        |
	//	+-------------------------------------------+----------------------------------------------------------------------------------+
	LoadExisting uint32 `idl:"name:fLoadExisting" json:"load_existing"`
	// pszAdmin: A pointer to a null-terminated UTF-8 string containing the administrator's
	// email name (in the format specified in [RFC1035] section 8) or NULL to cause the
	// DNS server to use a default value "hostmaster", followed by the name of the zone.
	// This value MUST be used to populate the zone administrator email field in the SOA
	// record in the new zone.
	Admin string `idl:"name:pszAdmin;string" json:"admin"`
	// aipMasters: As specified in section 2.2.5.2.4.1.
	Masters *IPv4Array `idl:"name:aipMasters" json:"masters"`
	// aipSecondaries: As specified in section 2.2.5.2.4.1.
	Secondaries *IPv4Array `idl:"name:aipSecondaries" json:"secondaries"`
	// fSecureSecondaries: As specified in section 2.2.5.2.4.1.
	SecureSecondaries uint32 `idl:"name:fSecureSecondaries" json:"secure_secondaries"`
	// fNotifyLevel: As specified in section 2.2.5.2.4.1.
	NotifyLevel uint32 `idl:"name:fNotifyLevel" json:"notify_level"`
	// contains filtered or unexported fields
}

ZoneCreateInfoW2K structure represents DNS_RPC_ZONE_CREATE_INFO_W2K RPC structure.

The DNS_RPC_ZONE_CREATE_INFO_W2K structure is used to specify parameters required when creating a new DNS zone.

func (*ZoneCreateInfoW2K) MarshalNDR 

func (o *ZoneCreateInfoW2K) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*ZoneCreateInfoW2K) UnmarshalNDR 

func (o *ZoneCreateInfoW2K) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type ZoneCreateInfo_NET 

type ZoneCreateInfo_NET struct {
	// dwRpcStructureVersion: As specified in section 2.2.5.2.4.2.
	RPCStructureVersion uint32 `idl:"name:dwRpcStructureVersion" json:"rpc_structure_version"`

	ZoneName          string     `idl:"name:pszZoneName;string" json:"zone_name"`
	ZoneType          uint32     `idl:"name:dwZoneType" json:"zone_type"`
	AllowUpdate       uint32     `idl:"name:fAllowUpdate" json:"allow_update"`
	Aging             uint32     `idl:"name:fAging" json:"aging"`
	Flags             uint32     `idl:"name:dwFlags" json:"flags"`
	DataFile          string     `idl:"name:pszDataFile;string" json:"data_file"`
	DSIntegrated      uint32     `idl:"name:fDsIntegrated" json:"ds_integrated"`
	LoadExisting      uint32     `idl:"name:fLoadExisting" json:"load_existing"`
	Admin             string     `idl:"name:pszAdmin;string" json:"admin"`
	Masters           *IPv4Array `idl:"name:aipMasters" json:"masters"`
	Secondaries       *IPv4Array `idl:"name:aipSecondaries" json:"secondaries"`
	SecureSecondaries uint32     `idl:"name:fSecureSecondaries" json:"secure_secondaries"`
	NotifyLevel       uint32     `idl:"name:fNotifyLevel" json:"notify_level"`
	// dwTimeout: Equivalent to dwForwarderTimeout specified in section 2.2.5.2.4.2.
	Timeout uint32 `idl:"name:dwTimeout" json:"timeout"`
	// fRecurseAfterForwarding: Equivalent to fForwarderSlave specified in section 2.2.5.2.4.2.
	RecurseAfterForwarding uint32 `idl:"name:fRecurseAfterForwarding" json:"recurse_after_forwarding"`
	// dwDpFlags: As specified in section 2.2.5.2.4.2. However, only the following values
	// can be used and of these values more than one MUST NOT be specified: DNS_DP_LEGACY,
	// DNS_DP_DOMAIN_DEFAULT, and DNS_DP_FOREST_DEFAULT. This field is set to zero if the
	// zone is not to be created to use the directory server for persistent storage. The
	// DNS server returns an error if any value not listed above is specified or if more
	// than one of the allowable values are specified.
	DPFlags uint32 `idl:"name:dwDpFlags" json:"dp_flags"`
	// pszDpFqdn: As specified in section 2.2.5.2.4.2.
	DPFQDN string `idl:"name:pszDpFqdn;string" json:"dp_fqdn"`
	// contains filtered or unexported fields
}

ZoneCreateInfo_NET structure represents DNS_RPC_ZONE_CREATE_INFO_DOTNET RPC structure.

In the DNS_RPC_ZONE_CREATE_INFO_DOTNET structure all fields have same definition as specified in section DNS_RPC_ZONE_CREATE_INFO_W2K (section 2.2.5.2.7.1), with the following exceptions:

func (*ZoneCreateInfo_NET) MarshalNDR 

func (o *ZoneCreateInfo_NET) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*ZoneCreateInfo_NET) UnmarshalNDR 

func (o *ZoneCreateInfo_NET) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type ZoneDatabase 

type ZoneDatabase struct {
	RPCStructureVersion uint32 `idl:"name:dwRpcStructureVersion" json:"rpc_structure_version"`

	DSIntegrated uint32 `idl:"name:fDsIntegrated" json:"ds_integrated"`
	FileName     string `idl:"name:pszFileName;string" json:"file_name"`
	// contains filtered or unexported fields
}

ZoneDatabase structure represents DNS_RPC_ZONE_DATABASE RPC structure.

The DNS_RPC_ZONE_DATABASE structure contains information about the persistent data store for a zone on the DNS server. There are different versions of the DNS_RPC_ZONE_DATABASE structure. The DNS server MUST use the structure corresponding to the value of dwClientVersion in DNS Server Management Protocol method calls (section 3.1.4) as shown in the following table, or if the method call does not specify the value of dwClientVersion, the DNS_RPC_ZONE_DATABASE_W2K (section 2.2.5.2.6.1) version of the structure MUST be used. 

+------------+----------------------------------------------------+
|            |                                                    |
|   VALUE    |                     STRUCTURE                      |
|            |                                                    |
+------------+----------------------------------------------------+
+------------+----------------------------------------------------+
| 0x00000000 | DNS_RPC_ZONE_DATABASE_W2K (section 2.2.5.2.6.1)    |
+------------+----------------------------------------------------+
| 0x00060000 | DNS_RPC_ZONE_DATABASE_DOTNET (section 2.2.5.2.6.2) |
+------------+----------------------------------------------------+

func (*ZoneDatabase) MarshalNDR 

func (o *ZoneDatabase) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*ZoneDatabase) UnmarshalNDR 

func (o *ZoneDatabase) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type ZoneDatabaseW2K 

type ZoneDatabaseW2K struct {
	// fDsIntegrated: This MUST be set TRUE (0x00000001) if the zone is stored in a directory
	// server, or FALSE (0x00000000) if not.
	DSIntegrated uint32 `idl:"name:fDsIntegrated" json:"ds_integrated"`
	// pszFileName: A pointer to a null-terminated UTF-8 string that specifies the name
	// of the file in which this zone is stored, or NULL if this zone is to be stored in
	// a directory server or in a file with the default file name for the zone.
	FileName string `idl:"name:pszFileName;string" json:"file_name"`
}

ZoneDatabaseW2K structure represents DNS_RPC_ZONE_DATABASE_W2K RPC structure.

The DNS_RPC_ZONE_DATABASE_W2K structure specifies how a DNS zone is stored in persistent storage.

func (*ZoneDatabaseW2K) MarshalNDR 

func (o *ZoneDatabaseW2K) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*ZoneDatabaseW2K) UnmarshalNDR 

func (o *ZoneDatabaseW2K) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type ZoneDatabase_NET 

type ZoneDatabase_NET struct {
	// dwRpcStructureVersion: The DNS management structure version number. This MUST be
	// set to 0x00000001.
	RPCStructureVersion uint32 `idl:"name:dwRpcStructureVersion" json:"rpc_structure_version"`

	DSIntegrated uint32 `idl:"name:fDsIntegrated" json:"ds_integrated"`
	FileName     string `idl:"name:pszFileName;string" json:"file_name"`
	// contains filtered or unexported fields
}

ZoneDatabase_NET structure represents DNS_RPC_ZONE_DATABASE_DOTNET RPC structure.

In the DNS_RPC_ZONE_DATABASE_DOTNET structure all fields have same definition as specified in section DNS_RPC_ZONE_DATABASE_W2K (section 2.2.5.2.6.1), with the following exceptions:

func (*ZoneDatabase_NET) MarshalNDR 

func (o *ZoneDatabase_NET) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*ZoneDatabase_NET) UnmarshalNDR 

func (o *ZoneDatabase_NET) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type ZoneDnssecSettings 

type ZoneDnssecSettings struct {
	// dwRpcStructureVersion: The structure version number; this MUST be set to 0x00000001.
	RPCStructureVersion uint32 `idl:"name:dwRpcStructureVersion" json:"rpc_structure_version"`

	// fIsSigned: States whether or not the zone is signed.
	IsSigned uint32 `idl:"name:fIsSigned" json:"is_signed"`
	// fSignWithNSEC3: States whether the zone has NSEC3 Authenticated Denial of Existence
	// support.
	SignWithNSEC3 uint32 `idl:"name:fSignWithNSEC3" json:"sign_with_nsec3"`
	// fNSEC3OptOut: States whether the zone has unsecure delegations.
	NSEC3OptOut uint32 `idl:"name:fNSEC3OptOut" json:"nsec3_opt_out"`
	// dwMaintainTrustAnchor: States whether Trust Anchors are maintained for this zone.
	MaintainTrustAnchor uint32 `idl:"name:dwMaintainTrustAnchor" json:"maintain_trust_anchor"`
	// fParentHasSecureDelegation: Delegation Status (Secure\UnSecure) for this zone from
	// the parent.
	ParentHasSecureDelegation uint32 `idl:"name:fParentHasSecureDelegation" json:"parent_has_secure_delegation"`
	// dwDSRecordAlgorithms: Algorithms used for generating a hash of the DNSKEY record.
	DSRecordAlgorithms uint32 `idl:"name:dwDSRecordAlgorithms" json:"ds_record_algorithms"`
	// fRFC5011KeyRollovers: 5011 rollover status (Enabled\Disabled) for this zone.
	Rfc5011KeyRollovers uint32 `idl:"name:fRFC5011KeyRollovers" json:"rfc5011_key_rollovers"`
	// bNSEC3HashAlgorithm: Algorithm used for generating NSEC3 hash (see [RFC5155] section
	// 5).
	NSEC3HashAlgorithm uint8 `idl:"name:bNSEC3HashAlgorithm" json:"nsec3_hash_algorithm"`
	// bNSEC3RandomSaltLength: Length of Salt used in generating NSEC3 records for this
	// zone (see [RFC5155] section 5).
	NSEC3RandomSaltLength uint8 `idl:"name:bNSEC3RandomSaltLength" json:"nsec3_random_salt_length"`
	// wNSEC3IterationCount: Iteration count for generating NSEC3 records for this zone
	// (see [RFC5155] section 5).
	NSEC3IterationCount uint16 `idl:"name:wNSEC3IterationCount" json:"nsec3_iteration_count"`
	// pwszNSEC3UserSalt: User defined salt used for generating NSEC3 records for this zone
	// (see [RFC5155] section 5).
	NSEC3UserSalt string `idl:"name:pwszNSEC3UserSalt" json:"nsec3_user_salt"`
	// dwDNSKEYRecordSetTtl: Time-to-live (TTL) for the DNSKEY resource record.
	DNSKEYRecordSetTTL uint32 `idl:"name:dwDNSKEYRecordSetTtl" json:"dnskey_record_set_ttl"`
	// dwDSRecordSetTtl: TTL for the DS Resource Record.
	DSRecordSetTTL uint32 `idl:"name:dwDSRecordSetTtl" json:"ds_record_set_ttl"`
	// dwSignatureInceptionOffset: Time in seconds for Inception of Signatures for RRSIGs
	// as defined in [RFC4034] section 3.1.5.
	SignatureInceptionOffset uint32 `idl:"name:dwSignatureInceptionOffset" json:"signature_inception_offset"`
	// dwSecureDelegationPollingPeriod: The interval, in seconds, to refresh the set of
	// delegation signer (DS) records in a secure delegation.
	SecureDelegationPollingPeriod uint32 `idl:"name:dwSecureDelegationPollingPeriod" json:"secure_delegation_polling_period"`
	// dwPropagationTime: The time, in seconds, that it takes for zone data changes to propagate
	// to other copies of the zone.
	PropagationTime uint32 `idl:"name:dwPropagationTime" json:"propagation_time"`
	// cbNSEC3CurrentSaltLength: Length of the Current User salt for building an NSEC3 chain
	// of zone records.
	NSEC3CurrentSaltLength uint32 `idl:"name:cbNSEC3CurrentSaltLength" json:"nsec3_current_salt_length"`
	// pbNSEC3CurrentSalt: Pointer to the pwszNSEC3UserSalt for building an NSEC3 chain
	// of zone records.
	NSEC3CurrentSalt []byte `idl:"name:pbNSEC3CurrentSalt;size_is:(cbNSEC3CurrentSaltLength)" json:"nsec3_current_salt"`
	// CurrentRollingSKDGuid: Unique identifier of a rolling SKD of a zone, if any.
	CurrentRollingSKDGUID *dtyp.GUID `idl:"name:CurrentRollingSKDGuid" json:"current_rolling_skd_guid"`
	BufferLength          uint32     `idl:"name:dwBufferLength" json:"buffer_length"`
	Buffer                []byte     `idl:"name:pBuffer;size_is:(dwBufferLength)" json:"buffer"`
	// dwCount: The number of signing key descriptors present in the array of signing key
	// descriptors pointed to by SkdArray.
	Count uint32 `idl:"name:dwCount" json:"count"`
	// pZoneSkdArray: A list of SKDs for a zone. This is the array of the DNS_RPC_ZONE_SKD
	// structure.
	ZoneSKDArray []*ZoneSKD `idl:"name:pZoneSkdArray;size_is:(dwCount)" json:"zone_skd_array"`
	// contains filtered or unexported fields
}

ZoneDnssecSettings structure represents DNS_RPC_ZONE_DNSSEC_SETTINGS RPC structure.

The DNS_RPC_ZONE_DNSSEC_SETTINGS structure SHOULD<50>  represent the DNSSEC properties of a zone.

func (*ZoneDnssecSettings) MarshalNDR 

func (o *ZoneDnssecSettings) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*ZoneDnssecSettings) NDRSizeInfo 

func (o *ZoneDnssecSettings) NDRSizeInfo() []uint64

func (*ZoneDnssecSettings) UnmarshalNDR 

func (o *ZoneDnssecSettings) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type ZoneExportInfo 

type ZoneExportInfo struct {
	// dwRpcStructureVersion: The structure version number; this MUST be set to 0x00000001.
	RPCStructureVersion uint32 `idl:"name:dwRpcStructureVersion" json:"rpc_structure_version"`

	// pszZoneExportFile: A pointer to a null-terminated UTF-8 string that specifies the
	// name of the file to which a zone is exported by the DNS server.
	ZoneExportFile string `idl:"name:pszZoneExportFile;string" json:"zone_export_file"`
	// contains filtered or unexported fields
}

ZoneExportInfo structure represents DNS_RPC_ZONE_EXPORT_INFO RPC structure.

The DNS_RPC_ZONE_EXPORT_INFO structure contains the information file to which a zone is exported on the DNS server.<44>

func (*ZoneExportInfo) MarshalNDR 

func (o *ZoneExportInfo) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*ZoneExportInfo) UnmarshalNDR 

func (o *ZoneExportInfo) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type ZoneInfo 

type ZoneInfo struct {
	RPCStructureVersion uint32 `idl:"name:dwRpcStructureVersion" json:"rpc_structure_version"`

	ZoneName                 string     `idl:"name:pszZoneName;string" json:"zone_name"`
	ZoneType                 uint32     `idl:"name:dwZoneType" json:"zone_type"`
	Reverse                  uint32     `idl:"name:fReverse" json:"reverse"`
	AllowUpdate              uint32     `idl:"name:fAllowUpdate" json:"allow_update"`
	Paused                   uint32     `idl:"name:fPaused" json:"paused"`
	Shutdown                 uint32     `idl:"name:fShutdown" json:"shutdown"`
	AutoCreated              uint32     `idl:"name:fAutoCreated" json:"auto_created"`
	UseDatabase              uint32     `idl:"name:fUseDatabase" json:"use_database"`
	DataFile                 string     `idl:"name:pszDataFile;string" json:"data_file"`
	Masters                  *AddrArray `idl:"name:aipMasters" json:"masters"`
	SecureSecondaries        uint32     `idl:"name:fSecureSecondaries" json:"secure_secondaries"`
	NotifyLevel              uint32     `idl:"name:fNotifyLevel" json:"notify_level"`
	Secondaries              *AddrArray `idl:"name:aipSecondaries" json:"secondaries"`
	Notify                   *AddrArray `idl:"name:aipNotify" json:"notify"`
	UseWINS                  uint32     `idl:"name:fUseWins" json:"use_wins"`
	UseNbstat                uint32     `idl:"name:fUseNbstat" json:"use_nbstat"`
	Aging                    uint32     `idl:"name:fAging" json:"aging"`
	NoRefreshInterval        uint32     `idl:"name:dwNoRefreshInterval" json:"no_refresh_interval"`
	RefreshInterval          uint32     `idl:"name:dwRefreshInterval" json:"refresh_interval"`
	AvailForScavengeTime     uint32     `idl:"name:dwAvailForScavengeTime" json:"avail_for_scavenge_time"`
	ScavengeServers          *AddrArray `idl:"name:aipScavengeServers" json:"scavenge_servers"`
	ForwarderTimeout         uint32     `idl:"name:dwForwarderTimeout" json:"forwarder_timeout"`
	ForwarderSlave           uint32     `idl:"name:fForwarderSlave" json:"forwarder_slave"`
	LocalMasters             *AddrArray `idl:"name:aipLocalMasters" json:"local_masters"`
	DPFlags                  uint32     `idl:"name:dwDpFlags" json:"dp_flags"`
	DPFQDN                   string     `idl:"name:pszDpFqdn;string" json:"dp_fqdn"`
	ZoneDN                   string     `idl:"name:pwszZoneDn;string" json:"zone_dn"`
	LastSuccessfulSOACheck   uint32     `idl:"name:dwLastSuccessfulSoaCheck" json:"last_successful_soa_check"`
	LastSuccessfulXFR        uint32     `idl:"name:dwLastSuccessfulXfr" json:"last_successful_xfr"`
	QueuedForBackgroundLoad  uint32     `idl:"name:fQueuedForBackgroundLoad" json:"queued_for_background_load"`
	BackgroundLoadInProgress uint32     `idl:"name:fBackgroundLoadInProgress" json:"background_load_in_progress"`
	ReadOnlyZone             bool       `idl:"name:fReadOnlyZone" json:"read_only_zone"`
	LastXFRAttempt           uint32     `idl:"name:dwLastXfrAttempt" json:"last_xfr_attempt"`
	LastXFRResult            uint32     `idl:"name:dwLastXfrResult" json:"last_xfr_result"`
	// contains filtered or unexported fields
}

ZoneInfo structure represents DNS_RPC_ZONE_INFO RPC structure.

The DNS_RPC_ZONE_INFO structure contains the detailed information about a zone present on the DNS server. The DNS server uses this structure to return information about a zone while responding to R_DnssrvQuery2 (section 3.1.4.7) method calls with operation type "ZoneInfo". There are different versions of DNS_RPC_ZONE_INFO. The DNS server MUST use the structures corresponding to the passed-in value for the dwClientVersion field in DNS Server Management Protocol method calls (section 3.1.4) in the following table, or if the method call does not specify the value of dwClientVersion, the DNS_RPC_ZONE_ INFO_W2K version of the structure MUST be used. 

+------------+---------------------------------------------------+
|            |                                                   |
|   VALUE    |                     STRUCTURE                     |
|            |                                                   |
+------------+---------------------------------------------------+
+------------+---------------------------------------------------+
| 0x00000000 | DNS_RPC_ZONE_INFO_W2K (section 2.2.5.2.4.1)       |
+------------+---------------------------------------------------+
| 0x00060000 | DNS_RPC_ ZONE_INFO_DOTNET (section 2.2.5.2.4.2)   |
+------------+---------------------------------------------------+
| 0x00070000 | DNS_RPC_ ZONE_INFO_LONGHORN (section 2.2.5.2.4.3) |
+------------+---------------------------------------------------+

func (*ZoneInfo) MarshalNDR 

func (o *ZoneInfo) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*ZoneInfo) UnmarshalNDR 

func (o *ZoneInfo) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type ZoneInfoLonghorn 

type ZoneInfoLonghorn struct {
	// dwRpcStructureVersion: The DNS server management structure version number. It SHOULD<43>
	// be set to 0x00000002.
	RPCStructureVersion uint32 `idl:"name:dwRpcStructureVersion" json:"rpc_structure_version"`

	ZoneName    string `idl:"name:pszZoneName;string" json:"zone_name"`
	ZoneType    uint32 `idl:"name:dwZoneType" json:"zone_type"`
	Reverse     uint32 `idl:"name:fReverse" json:"reverse"`
	AllowUpdate uint32 `idl:"name:fAllowUpdate" json:"allow_update"`
	Paused      uint32 `idl:"name:fPaused" json:"paused"`
	Shutdown    uint32 `idl:"name:fShutdown" json:"shutdown"`
	AutoCreated uint32 `idl:"name:fAutoCreated" json:"auto_created"`
	UseDatabase uint32 `idl:"name:fUseDatabase" json:"use_database"`
	DataFile    string `idl:"name:pszDataFile;string" json:"data_file"`
	// aipMasters: A pointer to a structure of type DNS_ADDR_ARRAY (section 2.2.3.2.3) that
	// specifies a list of IP addresses of the remote DNS servers that can be sources of
	// information for this zone on which to perform zone transfers by a secondary. This
	// value is applicable for secondary, stub and forwarder zones only and MUST be NULL
	// for all other zone types.
	Masters           *AddrArray `idl:"name:aipMasters" json:"masters"`
	SecureSecondaries uint32     `idl:"name:fSecureSecondaries" json:"secure_secondaries"`
	NotifyLevel       uint32     `idl:"name:fNotifyLevel" json:"notify_level"`
	// aipSecondaries: A pointer to a structure of type DNS_ADDR_ARRAY (section 2.2.3.2.3)
	// that specifies a list of IP addresses of the remote DNS servers that are secondary
	// DNS servers for this zone, or NULL if there are no secondary DNS servers. If fSecureSecondaries
	// is set to ZONE_SECSECURE_LIST_ONLY, then only zone transfers from IP addresses in
	// this list will be honored.
	Secondaries *AddrArray `idl:"name:aipSecondaries" json:"secondaries"`
	// aipNotify: A pointer to a structure of type DNS_ADDR_ARRAY (section 2.2.3.2.3) that
	// specifies a list of IP addresses of the remote DNS servers that are secondaries for
	// this zone, for which this DNS server is acting as master and the DNS server will
	// send zone notifications to these secondary servers, as directed by the value of fNotifyLevel
	// above.
	Notify               *AddrArray `idl:"name:aipNotify" json:"notify"`
	UseWINS              uint32     `idl:"name:fUseWins" json:"use_wins"`
	UseNbstat            uint32     `idl:"name:fUseNbstat" json:"use_nbstat"`
	Aging                uint32     `idl:"name:fAging" json:"aging"`
	NoRefreshInterval    uint32     `idl:"name:dwNoRefreshInterval" json:"no_refresh_interval"`
	RefreshInterval      uint32     `idl:"name:dwRefreshInterval" json:"refresh_interval"`
	AvailForScavengeTime uint32     `idl:"name:dwAvailForScavengeTime" json:"avail_for_scavenge_time"`
	// aipScavengeServers: A pointer to a structure of type DNS_ADDR_ARRAY (section 2.2.3.2.3)
	// that specifies a list of IP addresses of the DNS servers that will perform scavenging
	// for this zone. This value is applicable for zones of type DNS_ZONE_TYPE_PRIMARY (section
	// 2.2.5.1.1) only. If this value is NULL, there are no restrictions on which DNS server
	// can perform scavenging for this zone.
	ScavengeServers  *AddrArray `idl:"name:aipScavengeServers" json:"scavenge_servers"`
	ForwarderTimeout uint32     `idl:"name:dwForwarderTimeout" json:"forwarder_timeout"`
	ForwarderSlave   uint32     `idl:"name:fForwarderSlave" json:"forwarder_slave"`
	// aipLocalMasters: A pointer to a structure of type DNS_ADDR_ARRAY (section 2.2.3.2.3)
	// that specifies a list of IP addresses of primary DNS servers for this zone. If this
	// value is not NULL then it overrides the masters servers list configured in the directory
	// server.
	LocalMasters           *AddrArray `idl:"name:aipLocalMasters" json:"local_masters"`
	DPFlags                uint32     `idl:"name:dwDpFlags" json:"dp_flags"`
	DPFQDN                 string     `idl:"name:pszDpFqdn;string" json:"dp_fqdn"`
	ZoneDN                 string     `idl:"name:pwszZoneDn;string" json:"zone_dn"`
	LastSuccessfulSOACheck uint32     `idl:"name:dwLastSuccessfulSoaCheck" json:"last_successful_soa_check"`
	LastSuccessfulXFR      uint32     `idl:"name:dwLastSuccessfulXfr" json:"last_successful_xfr"`
	// fQueuedForBackgroundLoad: This MUST be set to 0x00000001 if this zone is has not
	// yet been loaded from persistent storage.
	QueuedForBackgroundLoad uint32 `idl:"name:fQueuedForBackgroundLoad" json:"queued_for_background_load"`
	// fBackgroundLoadInProgress: This MUST be set to 0x00000001 if this zone is currently
	// being loaded from persistent storage, or 0x00000000 if it has been loaded.
	BackgroundLoadInProgress uint32 `idl:"name:fBackgroundLoadInProgress" json:"background_load_in_progress"`
	// fReadOnlyZone: This MUST be set to 0x00000001 if this zone is backed by a read-only
	// store that will not accept write operations, or 0x00000000 if not.
	ReadOnlyZone bool `idl:"name:fReadOnlyZone" json:"read_only_zone"`
	// dwLastXfrAttempt: The time-stamp at which last zone transfer was attempted by a DNS
	// server. This field is applicable only for zones which are secondary or not-authoritative.
	// For all other zones senders MUST set this value to zero and receivers MUST ignore
	// it.
	LastXFRAttempt uint32 `idl:"name:dwLastXfrAttempt" json:"last_xfr_attempt"`
	// dwLastXfrResult: The result of the last zone transfer attempted by server. This field
	// is applicable only for zones which are secondary or not-authoritative, and in this
	// case it MUST be either a Win32 error code, or 0xFFFFFFFF to indicate that a zone
	// transfer is currently in progress. For all other zones senders MUST set this value
	// to zero and receivers MUST ignore it.
	LastXFRResult uint32 `idl:"name:dwLastXfrResult" json:"last_xfr_result"`
	// contains filtered or unexported fields
}

ZoneInfoLonghorn structure represents DNS_RPC_ZONE_INFO_LONGHORN RPC structure.

In the DNS_RPC_ZONE_INFO_LONGHORN structure all fields have same definition as specified in section DNS_RPC_ZONE_INFO_DOTNET (section 2.2.5.2.4.2), with the following exceptions:

func (*ZoneInfoLonghorn) MarshalNDR 

func (o *ZoneInfoLonghorn) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*ZoneInfoLonghorn) UnmarshalNDR 

func (o *ZoneInfoLonghorn) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type ZoneInfoW2K 

type ZoneInfoW2K struct {
	// pszZoneName: A pointer to a null-terminated Unicode string that contains a zone name.
	ZoneName string `idl:"name:pszZoneName;string" json:"zone_name"`
	// dwZoneType: The zone type. This MUST be set to one of the allowed values as specified
	// in DNS_ZONE_TYPE (section 2.2.5.1.1).
	ZoneType uint32 `idl:"name:dwZoneType" json:"zone_type"`
	// fReverse: A Boolean value where TRUE (0x00000001) indicates this is a reverse lookup
	// zone and FALSE (0x00000000) indicates this is a forward lookup zone.
	Reverse uint32 `idl:"name:fReverse" json:"reverse"`
	// fAllowUpdate: A value that indicates what kind dynamic updates, as specified in [RFC2136],
	// are allowed for this zone. This MUST be set to one of the following values:
	//
	//	+---------------------------------+----------------------------------------------------------------------------------+
	//	|                                 |                                                                                  |
	//	|         CONSTANT/VALUE          |                                   DESCRIPTION                                    |
	//	|                                 |                                                                                  |
	//	+---------------------------------+----------------------------------------------------------------------------------+
	//	+---------------------------------+----------------------------------------------------------------------------------+
	//	| ZONE_UPDATE_OFF 0x00000000      | No updates are allowed for the zone.                                             |
	//	+---------------------------------+----------------------------------------------------------------------------------+
	//	| ZONE_UPDATE_UNSECURE 0x00000001 | All updates (secure and unsecure) are allowed for the zone.                      |
	//	+---------------------------------+----------------------------------------------------------------------------------+
	//	| ZONE_UPDATE_SECURE 0x00000002   | The zone only allows secure updates, that is, DNS packet MUST have a TSIG        |
	//	|                                 | [RFC2845] present in the additional section.                                     |
	//	+---------------------------------+----------------------------------------------------------------------------------+
	AllowUpdate uint32 `idl:"name:fAllowUpdate" json:"allow_update"`
	// fPaused: A Boolean value indicates whether zone operations are currently paused.
	// TRUE indicates that the DNS server does not use this zone to answer queries or accept
	// updates. FALSE indicates that the zone is handled normally.
	Paused uint32 `idl:"name:fPaused" json:"paused"`
	// fShutdown: A Boolean value that indicates whether this zone is currently shut down.
	Shutdown uint32 `idl:"name:fShutdown" json:"shutdown"`
	// fAutoCreated: A Boolean value that indicates whether this zone was autocreated by
	// the DNS server at boot time or when a virtualization instance is created via the
	// CreateVirtualizationInstance RPC operation (section 3.1.4.1).
	AutoCreated uint32 `idl:"name:fAutoCreated" json:"auto_created"`
	// fUseDatabase: A Boolean value that indicates whether this zone is stored in a directory
	// server.
	UseDatabase uint32 `idl:"name:fUseDatabase" json:"use_database"`
	// pszDataFile: A pointer to a null-terminated UTF-8 character string that specifies
	// the name (with no path) of the zone file for a file-based zone or NULL if this zone
	// is not stored in a file.
	DataFile string `idl:"name:pszDataFile;string" json:"data_file"`
	// aipMasters: A pointer to a structure of type IP4_ARRAY (section 2.2.3.2.1) that specifies
	// a list of IPv4 addresses of the remote DNS servers that can be sources of information
	// for this zone to perform zone transfers by a secondary. This value is applicable
	// for secondary, stub and forwarder zones only and MUST be NULL for all other zone
	// types.
	Masters *IPv4Array `idl:"name:aipMasters" json:"masters"`
	// fSecureSecondaries: The secondary security settings configured for a zone on the
	// master DNS server. The DNS server MUST respond to zone transfer requests from a secondary
	// server according to the behavior description corresponding to this flag's value as
	// specified in DNS_ZONE_SECONDARY_SECURITY (section 2.2.5.1.2). This value MUST be
	// set to one of the allowed values as specified in DNS_ZONE_SECONDARY_SECURITY (section
	// 2.2.5.1.2).
	SecureSecondaries uint32 `idl:"name:fSecureSecondaries" json:"secure_secondaries"`
	// fNotifyLevel: This parameter is ignored, and for dwZoneType parameter setting DNS_ZONE_TYPE_PRIMARY
	// (specified in section 2.2.5.1.1) and for DNS servers that are not directory service-integrated,
	// the zone notification setting is set to ZONE_NOTIFY_ALL_SECONDARIES. Otherwise, it
	// is set to ZONE_NOTIFY_LIST_ONLY, as specified in section 2.2.5.1.3.
	NotifyLevel uint32 `idl:"name:fNotifyLevel" json:"notify_level"`
	// aipSecondaries: A pointer to a structure of type IP4_ARRAY (section 2.2.3.2.1) that
	// specifies a list of IPv4 addresses of the remote DNS servers that are secondary DNS
	// servers for this zone, or NULL if there are no secondary DNS servers. If fSecureSecondaries
	// is set to ZONE_SECSECURE_LIST_ONLY then only zone transfers from IP addresses in
	// this list will be honored.
	Secondaries *IPv4Array `idl:"name:aipSecondaries" json:"secondaries"`
	// aipNotify: A pointer to a structure of type IP4_ARRAY (section 2.2.3.2.1) that specifies
	// a list of IPv4 addresses of the remote DNS servers that are secondaries for this
	// zone, for which this DNS server is acting as master and the DNS server will send
	// zone notifications to these secondary servers, as directed by the value of fNotifyLevel
	// above.
	Notify *IPv4Array `idl:"name:aipNotify" json:"notify"`
	// fUseWins: A Boolean value that indicates whether WINS resource record lookup is enabled
	// for this forward lookup zones.
	UseWINS uint32 `idl:"name:fUseWins" json:"use_wins"`
	// fUseNbstat: A Boolean value that indicates whether WINS-R resource record lookup
	// is enabled for this reverse lookup zones.
	UseNbstat uint32 `idl:"name:fUseNbstat" json:"use_nbstat"`
	// fAging: A Boolean value where TRUE (0x00000001) indicates that aging is enabled for
	// resource records in this zone, so the time-stamps of records in the zone will be
	// updated when server receives dynamic update request for that record; whereas FALSE(0x00000000)
	// indicates, that the time-stamps of the records in the zone will not be updated.
	Aging uint32 `idl:"name:fAging" json:"aging"`
	// dwNoRefreshInterval: The time interval, in hours, that is configured as NoRefresh
	// interval value for this zone. This value determines the time interval between the
	// last update of a record's time-stamp and the earliest instance when that time-stamp
	// can be refreshed.
	NoRefreshInterval uint32 `idl:"name:dwNoRefreshInterval" json:"no_refresh_interval"`
	// dwRefreshInterval: The time interval, in hours, that is configured as the refresh
	// interval value for this zone. Records that have not been refreshed by the expiration
	// of this interval are eligible to be removed during the next scavenging cycle performed
	// by the DNS server.
	RefreshInterval uint32 `idl:"name:dwRefreshInterval" json:"refresh_interval"`
	// dwAvailForScavengeTime: The time interval, in hours, that is available before the
	// scheduled next scavenging cycle for this zone.
	AvailForScavengeTime uint32 `idl:"name:dwAvailForScavengeTime" json:"avail_for_scavenge_time"`
	// aipScavengeServers: A pointer to a structure of type IP4_ARRAY (section 2.2.3.2.1)
	// that specifies a list of IPv4 addresses of the DNS servers that will perform scavenging
	// for this zone. This value is applicable for zones of type DNS_ZONE_TYPE_PRIMARY (section
	// DNS_ZONE_TYPE) only. If this value is NULL,  there are no restrictions on which
	// DNS server can perform scavenging for this zone.
	ScavengeServers *IPv4Array `idl:"name:aipScavengeServers" json:"scavenge_servers"`
	// contains filtered or unexported fields
}

ZoneInfoW2K structure represents DNS_RPC_ZONE_INFO_W2K RPC structure.

The DNS_RPC_ZONE_INFO_W2K structure is used to specify detailed DNS zone information.

func (*ZoneInfoW2K) MarshalNDR 

func (o *ZoneInfoW2K) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*ZoneInfoW2K) UnmarshalNDR 

func (o *ZoneInfoW2K) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type ZoneInfo_NET 

type ZoneInfo_NET struct {
	// dwRpcStructureVersion: The DNS server management structure version number. This value
	// SHOULD<42> be set to 0x00000001.
	RPCStructureVersion uint32 `idl:"name:dwRpcStructureVersion" json:"rpc_structure_version"`

	ZoneName             string     `idl:"name:pszZoneName;string" json:"zone_name"`
	ZoneType             uint32     `idl:"name:dwZoneType" json:"zone_type"`
	Reverse              uint32     `idl:"name:fReverse" json:"reverse"`
	AllowUpdate          uint32     `idl:"name:fAllowUpdate" json:"allow_update"`
	Paused               uint32     `idl:"name:fPaused" json:"paused"`
	Shutdown             uint32     `idl:"name:fShutdown" json:"shutdown"`
	AutoCreated          uint32     `idl:"name:fAutoCreated" json:"auto_created"`
	UseDatabase          uint32     `idl:"name:fUseDatabase" json:"use_database"`
	DataFile             string     `idl:"name:pszDataFile;string" json:"data_file"`
	Masters              *IPv4Array `idl:"name:aipMasters" json:"masters"`
	SecureSecondaries    uint32     `idl:"name:fSecureSecondaries" json:"secure_secondaries"`
	NotifyLevel          uint32     `idl:"name:fNotifyLevel" json:"notify_level"`
	Secondaries          *IPv4Array `idl:"name:aipSecondaries" json:"secondaries"`
	Notify               *IPv4Array `idl:"name:aipNotify" json:"notify"`
	UseWINS              uint32     `idl:"name:fUseWins" json:"use_wins"`
	UseNbstat            uint32     `idl:"name:fUseNbstat" json:"use_nbstat"`
	Aging                uint32     `idl:"name:fAging" json:"aging"`
	NoRefreshInterval    uint32     `idl:"name:dwNoRefreshInterval" json:"no_refresh_interval"`
	RefreshInterval      uint32     `idl:"name:dwRefreshInterval" json:"refresh_interval"`
	AvailForScavengeTime uint32     `idl:"name:dwAvailForScavengeTime" json:"avail_for_scavenge_time"`
	ScavengeServers      *IPv4Array `idl:"name:aipScavengeServers" json:"scavenge_servers"`
	// dwForwarderTimeout (4 bytes): The forwarder timeout value for a zone, in seconds.
	// This is the number of seconds the DNS server waits for response from a remote DNS
	// server for a forwarded query. This value is applicable for zones of type DNS_ZONE_TYPE_FORWARDER
	// (section 2.2.5.1.1). For all other zone types, senders MUST set this value to zero
	// and receivers MUST ignore it.
	ForwarderTimeout uint32 `idl:"name:dwForwarderTimeout" json:"forwarder_timeout"`
	// fForwarderSlave: A Boolean value indicating whether the DNS server is not allowed
	// to perform recursion while resolving names for this zone. The DNS server MUST fail
	// queries after getting failure from all forwarded servers, if the value is TRUE (0x00000001).
	// Otherwise normal recursion MUST be performed. This value is applicable for zones
	// of type DNS_ZONE_TYPE_FORWARDER (section 2.2.5.1.1). For all other zone types, senders
	// MUST set this value to zero and receivers MUST ignore it.
	ForwarderSlave uint32 `idl:"name:fForwarderSlave" json:"forwarder_slave"`
	// aipLocalMasters: A pointer to a structure of type IP4_ARRAY (section 2.2.3.2.1) that
	// specifies a list of IPv4 addresses of primary DNS servers for this zone. If this
	// value is not NULL then it overrides the master servers list configured in the directory
	// server.
	LocalMasters *IPv4Array `idl:"name:aipLocalMasters" json:"local_masters"`
	// dwDpFlags: Flag value that specifies information about the application directory
	// partition in which this zone is stored. This MUST be set to any combination of the
	// DNS_RPC_DP_FLAGS (section 2.2.7.1.1) or zero if this zone is not stored in a directory
	// server.
	DPFlags uint32 `idl:"name:dwDpFlags" json:"dp_flags"`
	// pszDpFqdn: A pointer to a null-terminated UTF-8 string that specifies the FQDN of
	// the application directory partition in which this zone is stored. If the zone is
	// not stored in an application directory partition this value MUST be NULL.
	DPFQDN string `idl:"name:pszDpFqdn;string" json:"dp_fqdn"`
	// pwszZoneDn: Pointer to a null-terminated Unicode string that specifies the distinguished
	// name for the zone if the zone is stored the directory server. This field is applicable
	// for directory server integrated zones only. The value MUST be NULL if this zone is
	// not stored in the directory server.
	ZoneDN string `idl:"name:pwszZoneDn;string" json:"zone_dn"`
	// dwLastSuccessfulSoaCheck: The time-stamp at which last SOA record was received successfully
	// from the primary DNS server for this zone. This field is applicable only for zones
	// which are secondary or non-authoritative. For all other zones this value MUST be
	// set to zero by senders and MUST be ignored by receivers.
	LastSuccessfulSOACheck uint32 `idl:"name:dwLastSuccessfulSoaCheck" json:"last_successful_soa_check"`
	// dwLastSuccessfulXfr: The time-stamp at which last zone transfer was completed successfully
	// from the primary DNS server for this zone. This field is applicable only for zones
	// which are secondary or non-authoritative. For all other zones this value MUST be
	// set to zero by senders and MUST be ignored by receivers.
	LastSuccessfulXFR uint32 `idl:"name:dwLastSuccessfulXfr" json:"last_successful_xfr"`
	// contains filtered or unexported fields
}

ZoneInfo_NET structure represents DNS_RPC_ZONE_INFO_DOTNET RPC structure.

In the DNS_RPC_ZONE_INFO_DOTNET structure all fields have same definition as specified in section DNS_RPC_ZONE_INFO_W2K (section 2.2.5.2.4.1), with the following exceptions:

func (*ZoneInfo_NET) MarshalNDR 

func (o *ZoneInfo_NET) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*ZoneInfo_NET) UnmarshalNDR 

func (o *ZoneInfo_NET) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type ZoneList 

type ZoneList struct {
	RPCStructureVersion uint32 `idl:"name:dwRpcStructureVersion" json:"rpc_structure_version"`

	ZoneCount uint32      `idl:"name:dwZoneCount" json:"zone_count"`
	ZoneArray []*Zone_NET `idl:"name:ZoneArray;size_is:(dwZoneCount)" json:"zone_array"`
	// contains filtered or unexported fields
}

ZoneList structure represents DNS_RPC_ZONE_LIST RPC structure.

The DNS_RPC_ZONE_LIST structure contains the information about a list of zones present on the DNS server. There are different versions of the DNS_RPC_ZONE_LIST structure. The DNS server SHOULD<41> use one of these structures depending upon the passed-in value for the dwClientVersion field in DNS Server Management Protocol method calls (section 3.1.4) as shown in the following table. If the method call does not specify the value of dwClientVersion, the DNS_RPC_ZONE_LIST_W2K version of the structure MUST be used. 

+------------+------------------------------------------------+
|            |                                                |
|   VALUE    |                   STRUCTURE                    |
|            |                                                |
+------------+------------------------------------------------+
+------------+------------------------------------------------+
| 0x00000000 | DNS_RPC_ZONE_LIST_W2K (section 2.2.5.2.3.1)    |
+------------+------------------------------------------------+
| 0x00060000 | DNS_RPC_ZONE_LIST_DOTNET (section 2.2.5.2.3.2) |
+------------+------------------------------------------------+

func (*ZoneList) MarshalNDR 

func (o *ZoneList) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*ZoneList) NDRSizeInfo 

func (o *ZoneList) NDRSizeInfo() []uint64

func (*ZoneList) UnmarshalNDR 

func (o *ZoneList) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type ZoneListW2K 

type ZoneListW2K struct {
	// dwZoneCount: The number of zones present in the array of zones pointed to by ZoneArray.
	ZoneCount uint32 `idl:"name:dwZoneCount" json:"zone_count"`
	// ZoneArray: An array of structures of type DNS_RPC_ZONE_W2K (section 2.2.5.2.1.1).
	// Each element of the array represents one zone.
	ZoneArray []*ZoneW2K `idl:"name:ZoneArray;size_is:(dwZoneCount)" json:"zone_array"`
}

ZoneListW2K structure represents DNS_RPC_ZONE_LIST_W2K RPC structure.

The DNS_RPC_ZONE_LIST_W2K structure is used to enumerate zones.

func (*ZoneListW2K) MarshalNDR 

func (o *ZoneListW2K) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*ZoneListW2K) NDRSizeInfo 

func (o *ZoneListW2K) NDRSizeInfo() []uint64

func (*ZoneListW2K) UnmarshalNDR 

func (o *ZoneListW2K) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type ZoneList_NET 

type ZoneList_NET struct {
	// dwRpcStructureVersion: The DNS management structure version number. This MUST be
	// set to 0x00000001.
	RPCStructureVersion uint32 `idl:"name:dwRpcStructureVersion" json:"rpc_structure_version"`

	ZoneCount uint32      `idl:"name:dwZoneCount" json:"zone_count"`
	ZoneArray []*Zone_NET `idl:"name:ZoneArray;size_is:(dwZoneCount)" json:"zone_array"`
	// contains filtered or unexported fields
}

ZoneList_NET structure represents DNS_RPC_ZONE_LIST_DOTNET RPC structure.

In the DNS_RPC_ZONE_LIST_DOTNET structure all fields have same definition as specified in section DNS_RPC_ZONE_LIST_W2K (section 2.2.5.2.3.1), with the following exceptions:

func (*ZoneList_NET) MarshalNDR 

func (o *ZoneList_NET) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*ZoneList_NET) NDRSizeInfo 

func (o *ZoneList_NET) NDRSizeInfo() []uint64

func (*ZoneList_NET) UnmarshalNDR 

func (o *ZoneList_NET) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type ZoneQueryStats 

type ZoneQueryStats struct {
	// RecordType: The type of record for which the query was received. The value SHOULD
	// be of type DNS_ZONE_STATS_TYPE (section 2.2.12.1.1).
	RecordType ZoneStatsType `idl:"name:RecordType" json:"record_type"`
	// QueriesResponded: The total number of queries to which the server responded for a
	// specific zone.
	QueriesResponded uint64 `idl:"name:QueriesResponded" json:"queries_responded"`
	// QueriesReceived: The total number of queries received by the server for a specific
	// zone.
	QueriesReceived uint64 `idl:"name:QueriesReceived" json:"queries_received"`
	// QueriesFailure: The total number of queries for which the server responded with server
	// failure for a specific zone.
	QueriesFailure uint64 `idl:"name:QueriesFailure" json:"queries_failure"`
	// QueriesNameError: The total number of queries for which the server responded with
	// a name error for a specific zone.
	QueriesNameError uint64 `idl:"name:QueriesNameError" json:"queries_name_error"`
}

ZoneQueryStats structure represents DNSSRV_ZONE_QUERY_STATS RPC structure.

The DNSSRV_ZONE_QUERY_STATS structure<81> contains per-zone per-record-type statistics.

func (*ZoneQueryStats) MarshalNDR 

func (o *ZoneQueryStats) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*ZoneQueryStats) UnmarshalNDR 

func (o *ZoneQueryStats) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type ZoneRRLStats 

type ZoneRRLStats struct {
	// Type: The DNS query type for which statistics are required. The value is of type
	// DNS_ZONE_STATS_TYPE (section 2.2.12.1.1).
	Type ZoneStatsType `idl:"name:Type" json:"type"`
	// TotalResponsesSent: The total number of responses sent on a specified zone when RRL
	// is enabled.
	TotalResponsesSent uint32 `idl:"name:TotalResponsesSent" json:"total_responses_sent"`
	// TotalResponsesDropped: The total number responses dropped on a specified zone when
	// RRL is enabled.
	TotalResponsesDropped uint32 `idl:"name:TotalResponsesDropped" json:"total_responses_dropped"`
	// TotalResponsesTruncated: The total number of responses sent with a truncated bit
	// set on a specified zone when RRL is enabled.
	TotalResponsesTruncated uint32 `idl:"name:TotalResponsesTruncated" json:"total_responses_truncated"`
	// TotalResponsesLeaked: The total number of responses sent after exhaustion of available
	// responses on a specified zone when RRL is enabled.
	TotalResponsesLeaked uint32 `idl:"name:TotalResponsesLeaked" json:"total_responses_leaked"`
}

ZoneRRLStats structure represents DNSSRV_ZONE_RRL_STATS RPC structure.

The DNSSRV_ZONE_RRL_STATS structure SHOULD<85> contain zone statistics about Response Rate Limiting.

func (*ZoneRRLStats) MarshalNDR 

func (o *ZoneRRLStats) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*ZoneRRLStats) UnmarshalNDR 

func (o *ZoneRRLStats) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type ZoneSKD 

type ZoneSKD struct {
	// dwRpcStructureVersion: The structure version number; this MUST be set to 0x00000001.
	RPCStructureVersion uint32 `idl:"name:dwRpcStructureVersion" json:"rpc_structure_version"`

	// pSkd: The static properties of a zone SKD. This is a DNS_RPC_SKD structure (section
	// 2.2.6.2.1).
	SKD *SKD `idl:"name:pSkd" json:"skd"`
	// pSkdState: The dynamic properties of a zone SKD. This is a DNS_RPC_SKD_STATE structure
	// (section 2.2.6.2.3).
	SKDState *SKDState `idl:"name:pSkdState" json:"skd_state"`
	// pSkdStateEx: The extended dynamic properties of a zone SKD. This is a DNS_RPC_SKD_STATE_EX
	// structure (section 2.2.6.2.11).
	SKDStateEx *SKDStateEx `idl:"name:pSkdStateEx" json:"skd_state_ex"`
	// contains filtered or unexported fields
}

ZoneSKD structure represents DNS_RPC_ZONE_SKD RPC structure.

The DNS_RPC_ZONE_SKD structure<51> groups all the properties of a signing key descriptor of a zone.

func (*ZoneSKD) MarshalNDR 

func (o *ZoneSKD) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*ZoneSKD) UnmarshalNDR 

func (o *ZoneSKD) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type ZoneScopeCreateInfo 

type ZoneScopeCreateInfo ZoneScopeCreateInfoV1

ZoneScopeCreateInfo structure represents DNS_RPC_ZONE_SCOPE_CREATE_INFO RPC structure.

func (*ZoneScopeCreateInfo) MarshalNDR 

func (o *ZoneScopeCreateInfo) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*ZoneScopeCreateInfo) UnmarshalNDR 

func (o *ZoneScopeCreateInfo) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

func (*ZoneScopeCreateInfo) ZoneScopeCreateInfoV1 

func (o *ZoneScopeCreateInfo) ZoneScopeCreateInfoV1() *ZoneScopeCreateInfoV1

type ZoneScopeCreateInfoV1 

type ZoneScopeCreateInfoV1 struct {
	// dwFlags: Specifies the behavior that the DNS server SHOULD follow when creating the
	// scope. This field is used only when the operation is CreateZoneScope. For any other
	// value than the following, a new empty zone scope is created:
	//
	//	+-------------------------------------------+----------------------------------------------------------------------------------+
	//	|                                           |                                                                                  |
	//	|                   VALUE                   |                                     MEANING                                      |
	//	|                                           |                                                                                  |
	//	+-------------------------------------------+----------------------------------------------------------------------------------+
	//	+-------------------------------------------+----------------------------------------------------------------------------------+
	//	| DNS_ZONE_LOAD_OVERWRITE_MEMORY 0x00000010 | If this value is specified, the DNS server MUST attempt to find and load the     |
	//	|                                           | zone scope database from persistent storage instead of creating a new empty      |
	//	|                                           | zone scope. If a pre-existing zone scope database is not found, or if there is a |
	//	|                                           | failure in loading the existing database, the DNS server MUST fail the operation |
	//	|                                           | and return an error. If a cache scope is being created, this operation fails on  |
	//	|                                           | the DNS server and an ERROR_INVALID_PARAMETER error is returned.                 |
	//	+-------------------------------------------+----------------------------------------------------------------------------------+
	Flags uint32 `idl:"name:dwFlags" json:"flags"`
	// pwszScopeName: The name of the zone scope or cache scope.
	ScopeName string `idl:"name:pwszScopeName" json:"scope_name"`
}

ZoneScopeCreateInfoV1 structure represents DNS_RPC_ZONE_SCOPE_CREATE_INFO_V1 RPC structure.

The DNS_RPC_ZONE_SCOPE_CREATE_INFO_V1 structure<87> contains the name of the zone scope or cache scope.

func (*ZoneScopeCreateInfoV1) MarshalNDR 

func (o *ZoneScopeCreateInfoV1) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*ZoneScopeCreateInfoV1) UnmarshalNDR 

func (o *ZoneScopeCreateInfoV1) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type ZoneScopeInfo 

type ZoneScopeInfo ZoneScopeInfoV1

ZoneScopeInfo structure represents DNS_RPC_ZONE_SCOPE_INFO RPC structure.

func (*ZoneScopeInfo) MarshalNDR 

func (o *ZoneScopeInfo) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*ZoneScopeInfo) UnmarshalNDR 

func (o *ZoneScopeInfo) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

func (*ZoneScopeInfo) ZoneScopeInfoV1 

func (o *ZoneScopeInfo) ZoneScopeInfoV1() *ZoneScopeInfoV1

type ZoneScopeInfoV1 

type ZoneScopeInfoV1 struct {
	// dwRpcStructureVersion: The DNS management structure version number. This value MUST
	// be set to 0x00000001.
	RPCStructureVersion uint32 `idl:"name:dwRpcStructureVersion" json:"rpc_structure_version"`
	// pwszScopeName: The name of the zone scope or cache scope.
	ScopeName string `idl:"name:pwszScopeName" json:"scope_name"`
	// pwszDataFile: The name of the zone scope or cache scope data file.
	DataFile string `idl:"name:pwszDataFile" json:"data_file"`
}

ZoneScopeInfoV1 structure represents DNS_RPC_ZONE_SCOPE_INFO_V1 RPC structure.

The DNS_RPC_ZONE_SCOPE_INFO_V1 structure<88> contains the details of the zone scope or cache scope.

func (*ZoneScopeInfoV1) MarshalNDR 

func (o *ZoneScopeInfoV1) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*ZoneScopeInfoV1) UnmarshalNDR 

func (o *ZoneScopeInfoV1) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type ZoneSecondaries 

type ZoneSecondaries struct {
	RPCStructureVersion uint32 `idl:"name:dwRpcStructureVersion" json:"rpc_structure_version"`

	SecureSecondaries uint32     `idl:"name:fSecureSecondaries" json:"secure_secondaries"`
	NotifyLevel       uint32     `idl:"name:fNotifyLevel" json:"notify_level"`
	Secondaries       *AddrArray `idl:"name:aipSecondaries" json:"secondaries"`
	Notify            *AddrArray `idl:"name:aipNotify" json:"notify"`
	// contains filtered or unexported fields
}

ZoneSecondaries structure represents DNS_RPC_ZONE_SECONDARIES RPC structure.

The DNS_RPC_ZONE_SECONDARIES structure contains the information about the secondary DNS servers for a zone. There are different versions of the DNS_RPC_ZONE_SECONDARIES structure. The DNS server MUST use the structure corresponding to the value of the dwClientVersion in DNS Server Management Protocol method calls (section 3.1.4) as in the following table, or if the method call does not specify the value of dwClientVersion, the DNS_RPC_ZONE_SECONDARIES_W2K version of the structure MUST be used. 

+------------+----------------------------------------------------------+
|            |                                                          |
|   VALUE    |                        STRUCTURE                         |
|            |                                                          |
+------------+----------------------------------------------------------+
+------------+----------------------------------------------------------+
| 0x00000000 | DNS_RPC_ZONE_SECONDARIES_W2K (section 2.2.5.2.5.1)       |
+------------+----------------------------------------------------------+
| 0x00060000 | DNS_RPC_ ZONE_SECONDARIES_DOTNET (section 2.2.5.2.5.2)   |
+------------+----------------------------------------------------------+
| 0x00070000 | DNS_RPC_ ZONE_SECONDARIES_LONGHORN (section 2.2.5.2.5.3) |
+------------+----------------------------------------------------------+

func (*ZoneSecondaries) MarshalNDR 

func (o *ZoneSecondaries) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*ZoneSecondaries) UnmarshalNDR 

func (o *ZoneSecondaries) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type ZoneSecondariesLonghorn 

type ZoneSecondariesLonghorn struct {
	// dwRpcStructureVersion: The DNS server management structure version number. It MUST
	// be set to 0x00000002.
	RPCStructureVersion uint32 `idl:"name:dwRpcStructureVersion" json:"rpc_structure_version"`

	SecureSecondaries uint32 `idl:"name:fSecureSecondaries" json:"secure_secondaries"`
	NotifyLevel       uint32 `idl:"name:fNotifyLevel" json:"notify_level"`
	// aipSecondaries: A pointer to a structure of type DNS_ADDR_ARRAY (section 2.2.3.2.3)
	// that specifies a list of IP addresses of remote DNS servers that are permitted to
	// perform zone transfers for this zone. The DNS server will honor zone transfer requests
	// from these secondary servers, as directed by the value of fSecureSecondaries above.
	Secondaries *AddrArray `idl:"name:aipSecondaries" json:"secondaries"`
	// aipNotify: A pointer to a structure of type DNS_ADDR_ARRAY (section 2.2.3.2.3) that
	// specifies a list of IP addresses of the remote DNS servers that be sent notification
	// messages when records in this zone change, as directed by fNotifyLevel above.
	Notify *AddrArray `idl:"name:aipNotify" json:"notify"`
	// contains filtered or unexported fields
}

ZoneSecondariesLonghorn structure represents DNS_RPC_ZONE_SECONDARIES_LONGHORN RPC structure.

In the DNS_RPC_ZONE_SECONDARIES_LONGHORN structure all fields have same definition as specified in section DNS_RPC_ZONE_SECONDARIES_DOTNET (section 2.2.5.2.5.2), with the following exceptions:

func (*ZoneSecondariesLonghorn) MarshalNDR 

func (o *ZoneSecondariesLonghorn) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*ZoneSecondariesLonghorn) UnmarshalNDR 

func (o *ZoneSecondariesLonghorn) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type ZoneSecondariesW2K 

type ZoneSecondariesW2K struct {
	// fSecureSecondaries: The secondary security settings configured for this zone. The
	// DNS server MUST respond to zone transfer requests from a secondary server according
	// to the behavior corresponding to the value of the flag, as described in DNS_ZONE_SECONDARY_SECURITY
	// (section 2.2.5.1.2). This value MUST be set to one of the allowed values as specified
	// in DNS_ZONE_SECONDARY_SECURITY (section 2.2.5.1.2).
	SecureSecondaries uint32 `idl:"name:fSecureSecondaries" json:"secure_secondaries"`
	// fNotifyLevel: The settings for sending zone notifications for this zone. The DNS
	// server MUST send notify messages to secondary servers as specified by the entry corresponding
	// to the value of this flag, as shown in the table in section 2.2.5.1.3. This flag's
	// value MUST be set to one of the allowed values as specified in DNS_ZONE_ NOTIFY_LEVEL
	// (section 2.2.5.1.3).
	NotifyLevel uint32 `idl:"name:fNotifyLevel" json:"notify_level"`
	// aipSecondaries: The list of IPv4 addresses of remote DNS servers that are permitted
	// to perform zone transfers for this zone. The DNS server will honor zone transfer
	// requests from these secondary servers, as specified by fSecureSecondaries above.
	Secondaries *IPv4Array `idl:"name:aipSecondaries" json:"secondaries"`
	// aipNotify: The list of IPv4 addresses of the remote DNS servers that will be sent
	// notification messages when records in this zone change, as directed by fNotifyLevel
	// above.
	Notify *IPv4Array `idl:"name:aipNotify" json:"notify"`
}

ZoneSecondariesW2K structure represents DNS_RPC_ZONE_SECONDARIES_W2K RPC structure.

The DNS_RPC_ZONE_SECONDARIES_W2K structure is used to specify information about the secondary servers for a primary DNS zone.

func (*ZoneSecondariesW2K) MarshalNDR 

func (o *ZoneSecondariesW2K) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*ZoneSecondariesW2K) UnmarshalNDR 

func (o *ZoneSecondariesW2K) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type ZoneSecondaries_NET 

type ZoneSecondaries_NET struct {
	// dwRpcStructureVersion: The DNS server management structure version number. It MUST
	// be set to 0x00000001
	RPCStructureVersion uint32 `idl:"name:dwRpcStructureVersion" json:"rpc_structure_version"`

	SecureSecondaries uint32     `idl:"name:fSecureSecondaries" json:"secure_secondaries"`
	NotifyLevel       uint32     `idl:"name:fNotifyLevel" json:"notify_level"`
	Secondaries       *IPv4Array `idl:"name:aipSecondaries" json:"secondaries"`
	Notify            *IPv4Array `idl:"name:aipNotify" json:"notify"`
	// contains filtered or unexported fields
}

ZoneSecondaries_NET structure represents DNS_RPC_ZONE_SECONDARIES_DOTNET RPC structure.

In the DNS_RPC_ZONE_SECONDARIES_DOTNET structure all fields have same definition as specified in section DNS_RPC_ZONE_SECONDARIES_W2K (section 2.2.5.2.5.1), with the following exceptions:

func (*ZoneSecondaries_NET) MarshalNDR 

func (o *ZoneSecondaries_NET) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*ZoneSecondaries_NET) UnmarshalNDR 

func (o *ZoneSecondaries_NET) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type ZoneStats 

type ZoneStats ZoneStatsV1

ZoneStats structure represents DNS_RPC_ZONE_STATS RPC structure.

func (*ZoneStats) MarshalNDR 

func (o *ZoneStats) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*ZoneStats) UnmarshalNDR 

func (o *ZoneStats) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

func (*ZoneStats) ZoneStatsV1 

func (o *ZoneStats) ZoneStatsV1() *ZoneStatsV1

type ZoneStatsType 

type ZoneStatsType uint16

ZoneStatsType type represents DNS_ZONE_STATS_TYPE RPC enumeration.

The DNS_ZONE_STATS_TYPE enumeration is the enumerator for all zone statistics types.<79> 

var (
	// ZONE_STATS_TYPE_RECORD_A: A record type.
	ZoneStatsTypeRecordA ZoneStatsType = 0
	// ZONE_STATS_TYPE_RECORD_AAAA: AAAA record type.
	ZoneStatsTypeRecordAAAA ZoneStatsType = 1
	// ZONE_STATS_TYPE_RECORD_PTR: PTR record type.
	ZoneStatsTypeRecordPTR ZoneStatsType = 2
	// ZONE_STATS_TYPE_RECORD_CNAME: CNAME record type.
	ZoneStatsTypeRecordCNAME ZoneStatsType = 3
	// ZONE_STATS_TYPE_RECORD_MX: MX record type.
	ZoneStatsTypeRecordMX ZoneStatsType = 4
	// ZONE_STATS_TYPE_RECORD_AFSDB: AFDSB record type.
	ZoneStatsTypeRecordAFSDB ZoneStatsType = 5
	// ZONE_STATS_TYPE_RECORD_ATMA: ATMA record type.
	ZoneStatsTypeRecordATMA ZoneStatsType = 6
	// ZONE_STATS_TYPE_RECORD_DHCID: DHCID record type.
	ZoneStatsTypeRecordDHCID ZoneStatsType = 7
	// ZONE_STATS_TYPE_RECORD_DNAME: DNAME record type.
	ZoneStatsTypeRecordDNAME ZoneStatsType = 8
	// ZONE_STATS_TYPE_RECORD_HINFO: HINFO record type.
	ZoneStatsTypeRecordHINFO ZoneStatsType = 9
	// ZONE_STATS_TYPE_RECORD_ISDN: ISDN record type.
	ZoneStatsTypeRecordISDN ZoneStatsType = 10
	// ZONE_STATS_TYPE_RECORD_MG: MG record type.
	ZoneStatsTypeRecordMG ZoneStatsType = 11
	// ZONE_STATS_TYPE_RECORD_MB: MB record type.
	ZoneStatsTypeRecordMB ZoneStatsType = 12
	// ZONE_STATS_TYPE_RECORD_MINFO: MINFO record type.
	ZoneStatsTypeRecordMINFO ZoneStatsType = 13
	// ZONE_STATS_TYPE_RECORD_NAPTR: NAPTR record type.
	ZoneStatsTypeRecordNAPTR ZoneStatsType = 14
	// ZONE_STATS_TYPE_RECORD_NXT: NXT record type.
	ZoneStatsTypeRecordNXT ZoneStatsType = 15
	// ZONE_STATS_TYPE_RECORD_KEY: KEY record type.
	ZoneStatsTypeRecordKEY ZoneStatsType = 16
	// ZONE_STATS_TYPE_RECORD_MR: MR record type.
	ZoneStatsTypeRecordMR ZoneStatsType = 17
	// ZONE_STATS_TYPE_RECORD_RP: RP record type.
	ZoneStatsTypeRecordRP ZoneStatsType = 18
	// ZONE_STATS_TYPE_RECORD_RT: RT record type.
	ZoneStatsTypeRecordRT ZoneStatsType = 19
	// ZONE_STATS_TYPE_RECORD_SRV: SRV record type.
	ZoneStatsTypeRecordSRV ZoneStatsType = 20
	// ZONE_STATS_TYPE_RECORD_SIG: SIG record type.
	ZoneStatsTypeRecordSIG ZoneStatsType = 21
	// ZONE_STATS_TYPE_RECORD_TEXT: TXT record type.
	ZoneStatsTypeRecordTXT ZoneStatsType = 22
	// ZONE_STATS_TYPE_RECORD_WKS: WKS record type.
	ZoneStatsTypeRecordWKS ZoneStatsType = 23
	// ZONE_STATS_TYPE_RECORD_X25: X25 record type.
	ZoneStatsTypeRecordX25 ZoneStatsType = 24
	// ZONE_STATS_TYPE_RECORD_DNSKEY: DNSKEY record type.
	ZoneStatsTypeRecordDNSKEY ZoneStatsType = 25
	// ZONE_STATS_TYPE_RECORD_DS: DS record type.
	ZoneStatsTypeRecordDS ZoneStatsType = 26
	// ZONE_STATS_TYPE_RECORD_NS: NS record type.
	ZoneStatsTypeRecordNS ZoneStatsType = 27
	// ZONE_STATS_TYPE_RECORD_SOA: SOA record type.
	ZoneStatsTypeRecordSOA ZoneStatsType = 28
	// ZONE_STATS_TYPE_RECORD_TLSA: TLSA record type.
	ZoneStatsTypeRecordTLSA ZoneStatsType = 29
	// ZONE_STATS_TYPE_RECORD_ALL: All record types.
	ZoneStatsTypeRecordAll ZoneStatsType = 30
	// ZONE_STATS_TYPE_RECORD_OTHERS: Resource records not specified in this list.
	ZoneStatsTypeRecordOthers ZoneStatsType = 31
	// ZONE_STATS_TYPE_TRANSFER_AXFR: Axft transfer type.
	ZoneStatsTypeTransferAXFR ZoneStatsType = 32
	// ZONE_STATS_TYPE_TRANSFER_IXFR: Ixfr transfer type.
	ZoneStatsTypeTransferIXFR ZoneStatsType = 33
	// ZONE_STATS_TYPE_UPDATE: Zone Update.
	ZoneStatsTypeUpdate ZoneStatsType = 34
	// ZONE_STATS_TYPE_RRL: Response Rate Limiting.
	ZoneStatsTypeRRL ZoneStatsType = 35
	// MAX_ZONE_STATS_TYPES: Specifies the maximum zone statistics types supported.
	ZoneStatsTypeMaxZoneStatsTypes ZoneStatsType = 36
)

func (ZoneStatsType) String 

func (o ZoneStatsType) String() string

type ZoneStatsV1 

type ZoneStatsV1 struct {
	// dwRpcStructureVersion: The DNS management structure version number. This value MUST
	// be set to 0x00000001.
	RPCStructureVersion uint32 `idl:"name:dwRpcStructureVersion" json:"rpc_structure_version"`
	// ZoneTimeStats: Information about the zone time statistics in the DNSSRV_ZONE_TIME_STATS
	// structure (section 2.2.12.2.1).
	ZoneTimeStats *ZoneTimeStats `idl:"name:ZoneTimeStats" json:"zone_time_stats"`
	// ZoneQueryStats: An array of DNSSRV_ZONE_QUERY_STATS structures (section 2.2.12.2.2).
	ZoneQueryStats []*ZoneQueryStats `idl:"name:ZoneQueryStats" json:"zone_query_stats"`
	// ZoneTransferStats: An array of DNSSRV_ZONE_TRANSFER_STATS structures (section 2.2.12.2.3).
	ZoneTransferStats []*ZoneTransferStats `idl:"name:ZoneTransferStats" json:"zone_transfer_stats"`
	// ZoneUpdateStats: Information about the zone dynamic update statistics in the DNSSRV_ZONE_UPDATE_STATS
	// structure (section 2.2.12.2.4).
	ZoneUpdateStats *ZoneUpdateStats `idl:"name:ZoneUpdateStats" json:"zone_update_stats"`
	// ZoneRRLStats: Information about the zone RRL statistics in the DNSSRV_ZONE_RRL_STATS
	// structure (section 2.2.12.2.6).
	ZoneRRLStats *ZoneRRLStats `idl:"name:ZoneRRLStats" json:"zone_rrl_stats"`
}

ZoneStatsV1 structure represents DNS_RPC_ZONE_STATS_V1 RPC structure.

The DNS_RPC_ZONE_STATS_V1 structure SHOULD<84> contain all the statistics about a zone.

func (*ZoneStatsV1) MarshalNDR 

func (o *ZoneStatsV1) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*ZoneStatsV1) UnmarshalNDR 

func (o *ZoneStatsV1) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type ZoneTimeStats 

type ZoneTimeStats struct {
	// StatsCollectionStartTime: The time when zone statistics collection started.
	StatsCollectionStartTime *SystemTime `idl:"name:StatsCollectionStartTime" json:"stats_collection_start_time"`
}

ZoneTimeStats structure represents DNSSRV_ZONE_TIME_STATS RPC structure.

The DNSSRV_ZONE_TIME_STATS structure<80> contains zone time statistics information.

func (*ZoneTimeStats) MarshalNDR 

func (o *ZoneTimeStats) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*ZoneTimeStats) UnmarshalNDR 

func (o *ZoneTimeStats) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type ZoneTransferStats 

type ZoneTransferStats struct {
	// TransferType: The type of zone transfer request for which the query was received.
	// The value is of type DNS_ZONE_STATS_TYPE (section 2.2.12.1.1).
	TransferType ZoneStatsType `idl:"name:TransferType" json:"transfer_type"`
	// RequestReceived: The total number of zone transfer requests received by the server
	// for a specific zone.
	RequestReceived uint64 `idl:"name:RequestReceived" json:"request_received"`
	// RequestSent: The total number of zone transfer requests sent by the server for a
	// specific zone.
	RequestSent uint64 `idl:"name:RequestSent" json:"request_sent"`
	// ResponseReceived: The total number of zone transfer responses received by the server
	// for a specific zone.
	ResponseReceived uint64 `idl:"name:ResponseReceived" json:"response_received"`
	// SuccessReceived: The total number of zone transfer requests received successfully
	// by the receiver for a specific zone.
	SuccessReceived uint64 `idl:"name:SuccessReceived" json:"success_received"`
	// SuccessSent: The total number of zone transfer responses sent by the server for a
	// specific zone.
	SuccessSent uint64 `idl:"name:SuccessSent" json:"success_sent"`
}

ZoneTransferStats structure represents DNSSRV_ZONE_TRANSFER_STATS RPC structure.

The DNSSRV_ZONE_TRANSFER_STATS structure<82> contains zone transfer statistics per zone.

func (*ZoneTransferStats) MarshalNDR 

func (o *ZoneTransferStats) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*ZoneTransferStats) UnmarshalNDR 

func (o *ZoneTransferStats) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type ZoneUpdateStats 

type ZoneUpdateStats struct {
	// Type: The type of zone update request for which statistics are required. The value
	// is of type DNS_ZONE_STATS_TYPE (section 2.2.12.1.1).
	Type ZoneStatsType `idl:"name:Type" json:"type"`
	// DynamicUpdateReceived: The total number of dynamic updates accepted on a specified
	// zone.
	DynamicUpdateReceived uint64 `idl:"name:DynamicUpdateReceived" json:"dynamic_update_received"`
	// DynamicUpdateRejected: The total number of dynamic updates rejected on a specified
	// zone.
	DynamicUpdateRejected uint64 `idl:"name:DynamicUpdateRejected" json:"dynamic_update_rejected"`
}

ZoneUpdateStats structure represents DNSSRV_ZONE_UPDATE_STATS RPC structure.

The DNSSRV_ZONE_UPDATE_STATS structure<83> contains statistics about the dynamic updates per zone.

func (*ZoneUpdateStats) MarshalNDR 

func (o *ZoneUpdateStats) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*ZoneUpdateStats) UnmarshalNDR 

func (o *ZoneUpdateStats) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type ZoneW2K 

type ZoneW2K struct {
	// pszZoneName: A pointer to a null-terminated Unicode string that contains zone-name.
	ZoneName string `idl:"name:pszZoneName;string" json:"zone_name"`
	// Flags: Zone flags as specified in section 2.2.5.2.2.
	Flags uint32 `idl:"name:Flags" json:"flags"`
	// ZoneType: The zone type. This MUST be set to one of the allowed DNS_ZONE_TYPE section
	// 2.2.5.1.1.
	ZoneType uint8 `idl:"name:ZoneType" json:"zone_type"`
	// Version: The RPC protocol version. It MUST be set to 0x32.
	Version uint8 `idl:"name:Version" json:"version"`
}

ZoneW2K structure represents DNS_RPC_ZONE_W2K RPC structure.

The DNS_RPC_ZONE_W2K structure is used to specify basic information about a DNS zone.

func (*ZoneW2K) MarshalNDR 

func (o *ZoneW2K) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*ZoneW2K) UnmarshalNDR 

func (o *ZoneW2K) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type Zone_NET 

type Zone_NET struct {
	// dwRpcStructureVersion: The DNS management structure version number. This value MUST
	// be set to 0x00000001.
	RPCStructureVersion uint32 `idl:"name:dwRpcStructureVersion" json:"rpc_structure_version"`

	ZoneName string `idl:"name:pszZoneName;string" json:"zone_name"`
	Flags    uint32 `idl:"name:Flags" json:"flags"`
	ZoneType uint8  `idl:"name:ZoneType" json:"zone_type"`
	Version  uint8  `idl:"name:Version" json:"version"`
	// dwDpFlags: Application directory partition flags for this zone. This MUST be set
	// to one of the combination of the DNS_RPC_DP_FLAGS (section 2.2.7.1.1). If this zone
	// is not stored in the directory server this value MUST be 0x00000000.
	DPFlags uint32 `idl:"name:dwDpFlags" json:"dp_flags"`
	// pszDpFqdn: A pointer to a null-terminated UTF-8 string that specifies the FQDN of
	// the application directory partition in which this zone is stored in the directory
	// server. If this zone is not stored in the directory server this value MUST be NULL.
	//
	// If the DNS RPC client sends an older version of DNS_RPC_ZONE structure, that is,
	// DNS_RPC_ZONE_W2K (section 2.2.5.2.1.1), then the DNS RPC server MUST construct a
	// current version of DNS_RPC_ZONE structure, that is, DNS_RPC_ZONE_DOTNET, using the
	// following steps:
	//
	// *
	//
	// Copy the same value for fields that are common to input and the current version of
	// the DNS_RPC_ZONE structures.
	//
	// *
	//
	// The dwRpcStructureVersion field MUST be set to "1".
	//
	// *
	//
	// All other fields that are defined only in DNS_RPC_ZONE_DOTNET and are not defined
	// in DNS_RPC_ZONE (section 2.2.5.2.1 ( f22773ca-bfbf-46a5-8042-fbda1f3c4ad2 ) ), MUST
	// be set to "0".
	DPFQDN string `idl:"name:pszDpFqdn;string" json:"dp_fqdn"`
	// contains filtered or unexported fields
}

Zone_NET structure represents DNS_RPC_ZONE_DOTNET RPC structure.

In the DNS_RPC_ZONE_DOTNET structure all fields have same definition as specified in section DNS_RPC_ZONE_W2K (section 2.2.5.2.1.1), with the following exceptions:

func (*Zone_NET) MarshalNDR 

func (o *Zone_NET) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*Zone_NET) UnmarshalNDR 

func (o *Zone_NET) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

Source Files

View all Source files

Directories

Path Synopsis
dnsserver
v5
The record package implements the RECORD client protocol.
 The record package implements the RECORD client protocol.
dns

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.