record

package
v1.0.0 Latest Latest
Warning

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

 Go to latest Published: Apr 30, 2024 License: MIT Imports: 16 Imported by: 0

Documentation

Overview

The record package implements the RECORD 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 (
	// import guard
	GoPackage = "dnsp/record"
)

Functions

This section is empty.

Types

type Node 

type Node struct {
	// wLength (2 bytes): The length of this structure, in bytes, including the fixed size
	// elements plus the length of the dnsNodeName element. The length of this structure
	// is always 4-byte aligned, so it is possible to have 0-3 bytes of padding at the end
	// of the structure. The pad bytes are included in the wLength count.
	Length uint16 `idl:"name:wLength" json:"length"`
	// wRecordCount (2 bytes): The number of DNS_RPC_RECORD structures that follow this
	// node structure.
	RecordCount uint16 `idl:"name:wRecordCount" json:"record_count"`
	// dwFlags (4 bytes): The properties of the DNS_RPC_NODE structure.
	Flags uint32 `idl:"name:dwFlags" json:"flags"`
	// dwChildCount (4 bytes): The total number of children nodes below this node in the
	// DNS record database.
	ChildCount uint32 `idl:"name:dwChildCount" json:"child_count"`
	// dnsNodeName (variable): The name of this node in DNS_RPC_NAME (section 2.2.2.2.1)
	// format.
	DNSNodeName *NodeName `idl:"name:dnsNodeName" json:"dns_node_name"`
	DNSRecords  []*Record `idl:"name:dnsRecords;size_is:(wRecordCount)" json:"dns_records"`
}

Node structure represents DNS_RPC_NODE RPC structure.

The DNS_RPC_NODE defines a structure that is used as a header for a list of DNS_RPC_RECORD structures (section 2.2.2.2.5) returned by the DNS server inside a DNS_RPC_BUFFER (section 2.2.1.2.2) while processing the R_DnssrvEnumRecords2 (section 3.1.4.9). 

+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| 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 |   |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| wLength                                                       | wRecordCount                                                  |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| dwFlags                                                                                                                       |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| dwChildCount                                                                                                                  |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| dnsNodeName (variable)                                                                                                        |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| ...                                                                                                                           |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+

func (*Node) MarshalNDR 

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

func (*Node) RRs 

func (r *Node) RRs() []dns.RR

func (*Node) UnmarshalNDR 

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

type NodeList 

type NodeList struct {
	DNSNodes []*Node `idl:"name:dnsNodes" json:"dns_nodes"`
}

NodeList structure represents DNS_RPC_NODE_LIST RPC structure.

func (*NodeList) MarshalNDR 

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

func (*NodeList) UnmarshalNDR 

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

type NodeName 

type NodeName struct {
	NameLength uint8  `idl:"name:cchNameLength" json:"name_length"`
	DNSName    []byte `idl:"name:dnsName;size_is:(cchNameLength)" json:"dns_name"`
}

NodeName structure represents DNS_NODE_NAME RPC structure.

func (*NodeName) MarshalJSON 

func (o *NodeName) MarshalJSON() ([]byte, error)

func (*NodeName) MarshalNDR 

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

func (*NodeName) String 

func (o *NodeName) String() string

func (*NodeName) UnmarshalNDR 

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

type NodeText 

type NodeText struct {
	TextLength uint8  `idl:"name:cchTextLength" json:"text_length"`
	Text       []byte `idl:"name:text;size_is:(cchTextLength)" json:"text"`
}

NodeText structure represents DNS_NODE_TEXT RPC structure.

func (*NodeText) MarshalJSON 

func (o *NodeText) MarshalJSON() ([]byte, error)

func (*NodeText) MarshalNDR 

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

func (*NodeText) String 

func (o *NodeText) String() string

func (*NodeText) UnmarshalNDR 

func (o *NodeText) 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 TypeRecord `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"`
	Record *Record_Record `idl:"name:Record;switch_is:wType" json:"record"`
	// 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) RR 

func (r *Record) RR() dns.RR

func (*Record) UnmarshalNDR 

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

type RecordA 

type RecordA RecordIPAddress

RecordA structure represents DNS_RPC_RECORD_A RPC structure.

The DNS_RPC_RECORD_A structure contains an IPv4 address. This record 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 |   |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| IPv4 Address                                                                                                                  |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+

func (*RecordA) MarshalNDR 

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

func (*RecordA) RecordIPAddress 

func (o *RecordA) RecordIPAddress() *RecordIPAddress

func (*RecordA) UnmarshalNDR 

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

type RecordAAAA 

type RecordAAAA RecordIPAddress

RecordAAAA structure represents DNS_RPC_RECORD_AAAA RPC structure.

The DNS_RPC_RECORD_AAAA structure contains IPv6 address information. This record 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 |   |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| ipv6Address (16 bytes)                                                                                                        |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| ...                                                                                                                           |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| ...                                                                                                                           |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+

func (*RecordAAAA) MarshalNDR 

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

func (*RecordAAAA) RecordIPAddress 

func (o *RecordAAAA) RecordIPAddress() *RecordIPAddress

func (*RecordAAAA) UnmarshalNDR 

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

type RecordAFSDB 

type RecordAFSDB RecordPreference

RecordAFSDB structure represents DNS_RPC_RECORD_AFSDB RPC structure.

func (*RecordAFSDB) MarshalNDR 

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

func (*RecordAFSDB) RecordPreference 

func (o *RecordAFSDB) RecordPreference() *RecordPreference

func (*RecordAFSDB) UnmarshalNDR 

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

type RecordATMA 

type RecordATMA struct {
	// chFormat (1 byte): The format of the address as specified in section 5.2 of [ATMA].
	Format uint8 `idl:"name:chFormat" json:"format"`
	// bAddress (variable): The ATM address of the node to which this resource record pertains
	// (see section 5.2 of [ATMA]).
	Address []byte `idl:"name:bAddress" json:"address"`
}

RecordATMA structure represents DNS_RPC_RECORD_ATMA RPC structure.

The DNS_RPC_RECORD_ATMA specifies a resource record that contains ATM address information as specified in [ATMA]. This record 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 |   |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| chFormat                      | bAddress (variable)                                                                           |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| ...                                                                                                                           |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+

func (*RecordATMA) MarshalNDR 

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

func (*RecordATMA) UnmarshalNDR 

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

type RecordCNAME 

type RecordCNAME RecordNodeName

RecordCNAME structure represents DNS_RPC_RECORD_CNAME RPC structure.

func (*RecordCNAME) MarshalNDR 

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

func (*RecordCNAME) RecordNodeName 

func (o *RecordCNAME) RecordNodeName() *RecordNodeName

func (*RecordCNAME) UnmarshalNDR 

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

type RecordDHCID 

type RecordDHCID struct {
	// bDHCID (variable): An opaque DHCID record as specified in section 3 in [RFC4701].
	DHCID []byte `idl:"name:bDHCID" json:"dhcid"`
}

RecordDHCID structure represents DNS_RPC_RECORD_DHCID RPC structure.

The DNS_RPC_RECORD_DHCID structure contains a public key associated with an FQDN as specified in section 3 of [RFC2535].<17> This record 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 |   |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| bDHCID (variable)                                                                                                             |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| ...                                                                                                                           |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+

func (*RecordDHCID) MarshalNDR 

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

func (*RecordDHCID) UnmarshalNDR 

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

type RecordDNAME 

type RecordDNAME RecordNodeName

RecordDNAME structure represents DNS_RPC_RECORD_DNAME RPC structure.

func (*RecordDNAME) MarshalNDR 

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

func (*RecordDNAME) RecordNodeName 

func (o *RecordDNAME) RecordNodeName() *RecordNodeName

func (*RecordDNAME) UnmarshalNDR 

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

type RecordDNSKEY 

type RecordDNSKEY struct {
	// wFlags (2 bytes): Flags value for the key RR as specified in section 2.1 of [RFC4034].
	Flags uint16 `idl:"name:wFlags" json:"flags"`
	// chProtocol (1 byte): Protocol value for the key RR as specified in section 2.1 of
	// [RFC4034].
	Protocol uint8 `idl:"name:chProtocol" json:"protocol"`
	// chAlgorithm (1 byte): Algorithm value for the key RR as specified in section 2.1
	// of [RFC4034].
	Algorithm uint8 `idl:"name:chAlgorithm" json:"algorithm"`
	// bKey (variable): An array of bytes containing the key value as specified of section
	// 2.1 in [RFC4034].
	Key []byte `idl:"name:bKey" json:"key"`
}

RecordDNSKEY structure represents DNS_RPC_RECORD_DNSKEY RPC structure.

The DNS_RPC_RECORD_DNSKEY structure contains a public key associated with an FQDN as specified in section 2 of [RFC4034].<18> This record 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 |   |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| wFlags                                                        | chProtocol                    | chAlgorithm                   |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| bKey (variable)                                                                                                               |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| ...                                                                                                                           |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+

func (*RecordDNSKEY) MarshalNDR 

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

func (*RecordDNSKEY) UnmarshalNDR 

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

type RecordDS 

type RecordDS struct {
	// wKeyTag (2 bytes): The key tag of the DNSKEY record referred to by this DS record,
	// as specified in section 5 of [RFC4034].
	KeyTag uint16 `idl:"name:wKeyTag" json:"key_tag"`
	// chAlgorithm (1 byte): Algorithm value of the DNSKEY record referred to by this DS
	// record, as specified in section 5 of [RFC4034].
	Algorithm uint8 `idl:"name:chAlgorithm" json:"algorithm"`
	// chDigestType (1 byte): The digest algorithm that was used to construct this DS record,
	// as specified in section 5 of [RFC4034].
	DigestType uint8 `idl:"name:chDigestType" json:"digest_type"`
	// bDigest (variable): An array of bytes containing the digest value as specified of
	// section 5 in [RFC4034].
	Digest []byte `idl:"name:bDigest" json:"digest"`
}

RecordDS structure represents DNS_RPC_RECORD_DS RPC structure.

The DNS_RPC_RECORD_DS structure contains a public key associated with an FQDN as specified in section 5 of [RFC4034].<15> This record 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 |   |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| wKeyTag                                                       | chAlgorithm                   | chDigestType                  |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| bDigest (variable)                                                                                                            |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| ...                                                                                                                           |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+

func (*RecordDS) MarshalNDR 

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

func (*RecordDS) UnmarshalNDR 

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

type RecordHINFO 

type RecordHINFO RecordString

RecordHINFO structure represents DNS_RPC_RECORD_HINFO RPC structure.

func (*RecordHINFO) MarshalNDR 

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

func (*RecordHINFO) RecordString 

func (o *RecordHINFO) RecordString() *RecordString

func (*RecordHINFO) UnmarshalNDR 

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

type RecordIPAddress 

type RecordIPAddress struct {
	IPAddress []byte `idl:"name:pIpAddress" json:"ip_address"`
}

RecordIPAddress structure represents DNS_RPC_RECORD_IP_ADDRESS RPC structure.

func (*RecordIPAddress) MarshalJSON 

func (o *RecordIPAddress) MarshalJSON() ([]byte, error)

func (*RecordIPAddress) MarshalNDR 

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

func (*RecordIPAddress) String 

func (o *RecordIPAddress) String() string

func (*RecordIPAddress) UnmarshalNDR 

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

type RecordISDN 

type RecordISDN RecordString

RecordISDN structure represents DNS_RPC_RECORD_ISDN RPC structure.

func (*RecordISDN) MarshalNDR 

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

func (*RecordISDN) RecordString 

func (o *RecordISDN) RecordString() *RecordString

func (*RecordISDN) UnmarshalNDR 

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

type RecordKEY 

type RecordKEY struct {
	// wFlags (2 bytes): Flags value for the key RR as specified in section 3.1 of [RFC2535].
	Flags uint16 `idl:"name:wFlags" json:"flags"`
	// chProtocol (1 byte): Protocol value for the key RR as specified in section 3.1 of
	// [RFC2535].
	Protocol uint8 `idl:"name:chProtocol" json:"protocol"`
	// chAlgorithm (1 byte): Algorithm value for the key RR as specified in section 3.1
	// of [RFC2535].
	Algorithm uint8 `idl:"name:chAlgorithm" json:"algorithm"`
	// bKey (variable): An array of bytes containing the key value as specified of section
	// 3.1 in [RFC2535].
	Key []byte `idl:"name:bKey" json:"key"`
}

RecordKEY structure represents DNS_RPC_RECORD_KEY RPC structure.

The DNS_RPC_RECORD_KEY structure contains a public key associated with an FQDN as specified in section 3 of [RFC2535].<16> This record 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 |   |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| wFlags                                                        | chProtocol                    | chAlgorithm                   |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| bKey (variable)                                                                                                               |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| ...                                                                                                                           |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+

func (*RecordKEY) MarshalNDR 

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

func (*RecordKEY) UnmarshalNDR 

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

type RecordLoc 

type RecordLoc RecordString

RecordLoc structure represents DNS_RPC_RECORD_LOC RPC structure.

func (*RecordLoc) MarshalNDR 

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

func (*RecordLoc) RecordString 

func (o *RecordLoc) RecordString() *RecordString

func (*RecordLoc) UnmarshalNDR 

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

type RecordMB 

type RecordMB RecordNodeName

RecordMB structure represents DNS_RPC_RECORD_MB RPC structure.

func (*RecordMB) MarshalNDR 

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

func (*RecordMB) RecordNodeName 

func (o *RecordMB) RecordNodeName() *RecordNodeName

func (*RecordMB) UnmarshalNDR 

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

type RecordMD 

type RecordMD RecordNodeName

RecordMD structure represents DNS_RPC_RECORD_MD RPC structure.

func (*RecordMD) MarshalNDR 

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

func (*RecordMD) RecordNodeName 

func (o *RecordMD) RecordNodeName() *RecordNodeName

func (*RecordMD) UnmarshalNDR 

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

type RecordMF 

type RecordMF RecordNodeName

RecordMF structure represents DNS_RPC_RECORD_MF RPC structure.

func (*RecordMF) MarshalNDR 

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

func (*RecordMF) RecordNodeName 

func (o *RecordMF) RecordNodeName() *RecordNodeName

func (*RecordMF) UnmarshalNDR 

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

type RecordMG 

type RecordMG RecordNodeName

RecordMG structure represents DNS_RPC_RECORD_MG RPC structure.

func (*RecordMG) MarshalNDR 

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

func (*RecordMG) RecordNodeName 

func (o *RecordMG) RecordNodeName() *RecordNodeName

func (*RecordMG) UnmarshalNDR 

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

type RecordMINFO 

type RecordMINFO RecordMailError

RecordMINFO structure represents DNS_RPC_RECORD_MINFO RPC structure.

func (*RecordMINFO) MarshalNDR 

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

func (*RecordMINFO) RecordMailError 

func (o *RecordMINFO) RecordMailError() *RecordMailError

func (*RecordMINFO) UnmarshalNDR 

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

type RecordMR 

type RecordMR RecordNodeName

RecordMR structure represents DNS_RPC_RECORD_MR RPC structure.

func (*RecordMR) MarshalNDR 

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

func (*RecordMR) RecordNodeName 

func (o *RecordMR) RecordNodeName() *RecordNodeName

func (*RecordMR) UnmarshalNDR 

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

type RecordMX 

type RecordMX RecordPreference

RecordMX structure represents DNS_RPC_RECORD_MX RPC structure.

func (*RecordMX) MarshalNDR 

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

func (*RecordMX) RecordPreference 

func (o *RecordMX) RecordPreference() *RecordPreference

func (*RecordMX) UnmarshalNDR 

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

type RecordMailError 

type RecordMailError struct {
	// nameMailBox (variable): A structure of type DNS_RPC_NAME (section 2.2.2.2.1) containing
	// the RMAILBX value specified in section 3.3.7 of [RFC1035] for an MINFO record, or
	// the mbox-dname value specified in section 2.2 of [RFC1183] for an RP record.
	MailBox *NodeName `idl:"name:nameMailBox" json:"mail_box"`
	// ErrorMailBox (variable): A structure of type DNS_RPC_NAME (section 2.2.2.2.1) containing
	// the EMAILBX value specified in section 3.3.7 of [RFC1035] for an MINFO record, or
	// the txt-dname value specified in section 2.2 of [RFC1183] for an RP record.
	ErrorMailBox *NodeName `idl:"name:ErrorMailBox" json:"error_mail_box"`
}

RecordMailError structure represents DNS_RPC_RECORD_MAIL_ERROR RPC structure.

The DNS_RPC_RECORD_MAIL_ERROR structure contains information about a DNS record of any of the following types:

* DNS_TYPE_MINFO

* DNS_TYPE_RP

This record 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 |   |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| nameMailBox (variable)                                                                                                        |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| ...                                                                                                                           |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| ErrorMailBox (variable)                                                                                                       |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| ...                                                                                                                           |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+

func (*RecordMailError) MarshalNDR 

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

func (*RecordMailError) UnmarshalNDR 

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

type RecordNAPTR 

type RecordNAPTR struct {
	// wOrder (2 bytes): A value that specifies the order in which the NAPTR record is processed,
	// as specified in section 4.1 in [RFC3403].
	Order uint16 `idl:"name:wOrder" json:"order"`
	// wPreference (2 bytes): The preference given to this NAPTR record, as specified in
	// section 4.1 in [RFC3403].
	Preference uint16 `idl:"name:wPreference" json:"preference"`
	// nameFlags (variable): Pointer to a structure of type DNS_RPC_NAME (section 2.2.2.2.1)
	// containing the string flags value as specified in section 4.1 in [RFC3403].
	Flags *NodeText `idl:"name:nameFlags" json:"flags"`
	// nameService (variable): Pointer to a structure of type DNS_RPC_NAME (section 2.2.2.2.1)
	// containing service parameters value for NAPTR to control the rewriting and interpretation
	// of the field in the record, as specified in section 4.1 in [RFC3403].
	Service *NodeText `idl:"name:nameService" json:"service"`
	// nameSubstitution (variable): Pointer to a structure of type DNS_RPC_NAME (section
	// 2.2.2.2.1) containing a substitution expression value for the NAPTR record, as specified
	// in section 4.1 in [RFC3403].
	Substitution *NodeText `idl:"name:nameSubstitution" json:"substitution"`
	// nameReplacement (variable): Pointer to a structure of type DNS_RPC_NAME (section
	// 2.2.2.2.1) containing a replacement expression value for the NAPTR record, as specified
	// in section 4.1 in [RFC3403].
	Replacement *NodeName `idl:"name:nameReplacement" json:"replacement"`
}

RecordNAPTR structure represents DNS_RPC_RECORD_NAPTR RPC structure.

The DNS_RPC_RECORD_NAPTR specifies a NAPTR resource record as specified in section 4 of [RFC3403].<20> This record 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 |   |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| wOrder                                                        | wPreference                                                   |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| nameFlags (variable)                                                                                                          |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| ...                                                                                                                           |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| nameService (variable)                                                                                                        |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| ...                                                                                                                           |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| nameSubstitution (variable)                                                                                                   |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| ...                                                                                                                           |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| nameReplacement (variable)                                                                                                    |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| ...                                                                                                                           |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+

func (*RecordNAPTR) MarshalNDR 

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

func (*RecordNAPTR) UnmarshalNDR 

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

type RecordNS 

type RecordNS RecordNodeName

RecordNS structure represents DNS_RPC_RECORD_NS RPC structure.

func (*RecordNS) MarshalNDR 

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

func (*RecordNS) RecordNodeName 

func (o *RecordNS) RecordNodeName() *RecordNodeName

func (*RecordNS) UnmarshalNDR 

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

type RecordNSEC 

type RecordNSEC struct {
	// nameSigner (variable): A structure of type DNS_RPC_NAME (section 2.2.2.2.1) containing
	// the FQDN of the originating host for this record.
	Signer *NodeName `idl:"name:nameSigner" json:"signer"`
	// NSECBitmap (variable): Bitmap of types present at this node as specified in section
	// 4 of [RFC4034].
	NSECBitmap []uint16 `idl:"name:NSECBitmap" json:"nsec_bitmap"`
}

RecordNSEC structure represents DNS_RPC_RECORD_NSEC RPC structure.

The DNS_RPC_RECORD_NSEC structure contains the next FQDN in the zone as specified in section 4 of [RFC4034].<14> This record 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 |   |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| nameSigner (variable)                                                                                                         |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| ...                                                                                                                           |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| NSECBitmap (variable)                                                                                                         |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| ...                                                                                                                           |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+

func (*RecordNSEC) MarshalNDR 

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

func (*RecordNSEC) UnmarshalNDR 

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

type RecordNSEC3 

type RecordNSEC3 struct {
	// chAlgorithm (1 byte): A value that specifies the cryptographic hash algorithm used
	// to construct the hash value, as specified in [RFC5155] section 3.1.
	Algorithm uint8 `idl:"name:chAlgorithm" json:"algorithm"`
	// bFlags (1 byte): A value that specifies NSEC3 processing flags, as specified in [RFC5155]
	// section 3.1.
	Flags uint8 `idl:"name:bFlags" json:"flags"`
	// wIterations (2 bytes): A value that specifies the number of additional times the
	// hash function has been performed, as specified in [RFC5155] section 3.1.
	Iterations uint16 `idl:"name:wIterations" json:"iterations"`
	// bSaltLength (1 byte): A value that specifies the length of the salt field, in octets.
	SaltLength uint8 `idl:"name:bSaltLength" json:"salt_length"`
	// bHashLength (1 byte): A value that specifies the length of the nextHashedOwnerName
	// field, in octets.
	HashLength uint8 `idl:"name:bHashLength" json:"hash_length"`
	// salt (variable): A value that specifies the salt to be appended to the original owner
	// name before hashing, as specified in [RFC5155] section 3.1.
	Salt []byte `idl:"name:salt;size_is:(bSaltLength)" json:"salt"`
	// nextHashedOwnerName (variable): A value that specifies the next hashed owner name
	// in hash order, as specified in [RFC5155] section 3.1.
	NextHashedOwnerName []byte `idl:"name:nextHashedOwnerName;size_is:(bHashLength)" json:"next_hashed_owner_name"`
	// bitmaps (variable): A value that specifies the DNS types that exist at the original
	// owner name of the NSEC3 record, as specified in [RFC5155] section 3.1.
	Bitmaps []uint16 `idl:"name:bitmaps" json:"bitmaps"`
}

RecordNSEC3 structure represents DNS_RPC_RECORD_NSEC3 RPC structure.

The DNS_RPC_RECORD_NSEC3 structure SHOULD<21> specify an NSEC3 resource record as specified in [RFC5155] section 3. This record 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 |   |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| chAlgorithm                   | bFlags                        | wIterations                                                   |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| bSaltLength                   | bHashLength                   | salt (variable)                                               |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| ...                                                                                                                           |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| nextHashedOwnerName (variable)                                                                                                |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| ...                                                                                                                           |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| bitmaps (variable)                                                                                                            |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| ...                                                                                                                           |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+

func (*RecordNSEC3) MarshalNDR 

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

func (*RecordNSEC3) UnmarshalNDR 

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

type RecordNSEC3PARAM 

type RecordNSEC3PARAM struct {
	// chAlgorithm (1 byte): A value that specifies the cryptographic hash algorithm used
	// to construct the hash value, as specified in [RFC5155] section 4.1.
	Algorithm uint8 `idl:"name:chAlgorithm" json:"algorithm"`
	// bFlags (1 byte): A value that specifies NSEC3 processing flags, as specified in [RFC5155]
	// section 3.1.
	Flags uint8 `idl:"name:bFlags" json:"flags"`
	// wIterations (2 bytes): A value that specifies the number of additional times the
	// hash function has been performed, as specified in [RFC5155] section 4.1.
	Iterations uint16 `idl:"name:wIterations" json:"iterations"`
	// bSaltLength (1 byte): A value that specifies the length of the salt field, in octets.
	SaltLength uint8 `idl:"name:bSaltLength" json:"salt_length"`
	// salt (variable): A value that specifies the salt to be appended to the original owner
	// name before hashing, as specified in [RFC5155].
	Salt []byte `idl:"name:salt;size_is:(bSaltLength)" json:"salt"`
}

RecordNSEC3PARAM structure represents DNS_RPC_RECORD_NSEC3PARAM RPC structure.

The DNS_RPC_RECORD_NSEC3PARAM structure SHOULD<22> specify an NSEC3PARAM resource record as specified in [RFC5155] section 3. This record 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 |   |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| chAlgorithm                   | bFlags                        | wIterations                                                   |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| bSaltLength                   | salt (variable)                                                                               |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| ...                                                                                                                           |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+

func (*RecordNSEC3PARAM) MarshalNDR 

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

func (*RecordNSEC3PARAM) UnmarshalNDR 

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

type RecordNULL 

type RecordNULL struct {
	// bData (variable): An array of data. The sender can provide any data in this array.
	Data []byte `idl:"name:bData" json:"data"`
}

RecordNULL structure represents DNS_RPC_RECORD_NULL RPC structure.

The DNS_RPC_RECORD_NULL structure contains information for any record for which there is no more specific DNS_RPC_RECORD structure. This record 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 |   |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| bData (variable)                                                                                                              |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| ...                                                                                                                           |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+

func (*RecordNULL) MarshalNDR 

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

func (*RecordNULL) UnmarshalNDR 

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

type RecordNXT 

type RecordNXT struct {
	// wNumRecordTypes (2 bytes): The number of 16-bit unsigned integers in the variable
	// sized wTypeWords array. This value MUST be greater than 1.
	RecordTypesLength uint16 `idl:"name:wNumRecordTypes" json:"record_types_length"`
	// wTypeWords (variable): An array for of 16-bit unsigned integers in little-endian
	// byte order for that contains a variable sized bit-mask value for types present in
	// this record, as specified in section 5.2 of [RFC2535]. The most significant bit of
	// the first integer corresponds to type zero and MUST be zero. If there is a second
	// 16-bit unsigned integer present in the array, the most significant bit of the second
	// integer corresponds to type 16, and so on.
	TypeWords []uint16 `idl:"name:wTypeWords;size_is:(wNumRecordTypes)" json:"type_words"`
	// nextName (variable): A DNS_RPC_NAME (section 2.2.2.2.1) containing next name information,
	// as specified in section 5.2 of [RFC2535].
	NextName *NodeName `idl:"name:nextName" json:"next_name"`
}

RecordNXT structure represents DNS_RPC_RECORD_NXT RPC structure.

The DNS_RPC_RECORD_NXT specifies a NXT resource record as specified in section 5.1 of [RFC2535].<19> This record 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 |   |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| wNumRecordTypes                                               | wTypeWords (variable)                                         |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| ...                                                                                                                           |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| nextName (variable)                                                                                                           |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| ...                                                                                                                           |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+

func (*RecordNXT) MarshalNDR 

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

func (*RecordNXT) UnmarshalNDR 

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

type RecordNodeName 

type RecordNodeName struct {
	Name *NodeName `idl:"name:Name" json:"name"`
}

RecordNodeName structure represents DNS_RPC_RECORD_NODE_NAME RPC structure.

The DNS_RPC_RECORD_NODE_NAME structure contains information about a DNS record of any of the following types:<11>

* DNS_TYPE_PTR

* DNS_TYPE_NS

* DNS_TYPE_CNAME

* DNS_TYPE_DNAME

* DNS_TYPE_MB

* DNS_TYPE_MR

* DNS_TYPE_MG

* DNS_TYPE_MD

* DNS_TYPE_MF

This record 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 |   |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| nameNode (variable)                                                                                                           |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| ...                                                                                                                           |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+

func (*RecordNodeName) MarshalNDR 

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

func (*RecordNodeName) UnmarshalNDR 

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

type RecordPTR 

type RecordPTR RecordNodeName

RecordPTR structure represents DNS_RPC_RECORD_PTR RPC structure.

func (*RecordPTR) MarshalNDR 

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

func (*RecordPTR) RecordNodeName 

func (o *RecordPTR) RecordNodeName() *RecordNodeName

func (*RecordPTR) UnmarshalNDR 

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

type RecordPreference 

type RecordPreference struct {
	Preference uint16    `idl:"name:wPreference" json:"preference"`
	Exchange   *NodeName `idl:"name:nameExchange" json:"exchange"`
}

RecordPreference structure represents DNS_RPC_RECORD_PREFERENCE RPC structure.

func (*RecordPreference) MarshalNDR 

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

func (*RecordPreference) UnmarshalNDR 

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

type RecordRP 

type RecordRP RecordMailError

RecordRP structure represents DNS_RPC_RECORD_RP RPC structure.

func (*RecordRP) MarshalNDR 

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

func (*RecordRP) RecordMailError 

func (o *RecordRP) RecordMailError() *RecordMailError

func (*RecordRP) UnmarshalNDR 

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

type RecordRRSIG 

type RecordRRSIG struct {
	// wTypeCovered (2 bytes): The type covered value for RRSIG RR as specified in section
	// 3.1 of [RFC4034].
	TypeCovered uint16 `idl:"name:wTypeCovered" json:"type_covered"`
	// chAlgorithm  (1 byte): The algorithm value for RRSIG RR as specified in section
	// 3.1 of [RFC4034].
	Algorithm uint8 `idl:"name:chAlgorithm" json:"algorithm"`
	// chLabelCount (1 byte): The total number of labels present in the name of the record
	// signed by the RRSIG RR as specified in section 3.1 of [RFC4034].
	LabelCount uint8 `idl:"name:chLabelCount" json:"label_count"`
	// dwOriginalTtl (4 bytes): The original TTL value of the record signed by the RRSIG
	// RR as specified in section 3.1 of [RFC4034].
	OriginalTTL uint32 `idl:"name:dwOriginalTtl" json:"original_ttl"`
	// dwSigExpiration  (4 bytes): The signature expiration time as specified in section
	// 3.1 of [RFC4034].
	SigExpiration uint32 `idl:"name:dwSigExpiration" json:"sig_expiration"`
	// dwSigInception  (4 bytes): The signature inception time as specified in section
	// 3.1 of [RFC4034].
	SigInception uint32 `idl:"name:dwSigInception" json:"sig_inception"`
	// wKeyTag  (2 bytes): The tag value for RRSIG RR as specified in section 3.1 of [RFC4034].
	KeyTag uint16 `idl:"name:wKeyTag" json:"key_tag"`
	// nameSigner (variable): A structure of type DNS_RPC_NAME (section 2.2.2.2.1) containing
	// the FQDN of the originating host for this record.
	Signer *NodeName `idl:"name:nameSigner" json:"signer"`
	// SignatureInfo  (variable): Binary signature information as specified in section
	// 3.1 of [RFC4034].
	SignatureInfo []byte `idl:"name:SignatureInfo" json:"signature_info"`
}

RecordRRSIG structure represents DNS_RPC_RECORD_RRSIG RPC structure.

The DNS_RPC_RECORD_RRSIG structure contains information about cryptographic public key signatures as specified in section 3 of [RFC4034].<13> This record 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 |   |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| wTypeCovered                                                  | chAlgorithm                   | chLabelCount                  |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| dwOriginalTtl                                                                                                                 |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| dwSigExpiration                                                                                                               |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| dwSigInception                                                                                                                |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| wKeyTag                                                       | nameSigner (variable)                                         |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| ...                                                                                                                           |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| SignatureInfo (variable)                                                                                                      |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| ...                                                                                                                           |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+

func (*RecordRRSIG) MarshalNDR 

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

func (*RecordRRSIG) UnmarshalNDR 

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

type RecordRT 

type RecordRT RecordPreference

RecordRT structure represents DNS_RPC_RECORD_RT RPC structure.

func (*RecordRT) MarshalNDR 

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

func (*RecordRT) RecordPreference 

func (o *RecordRT) RecordPreference() *RecordPreference

func (*RecordRT) UnmarshalNDR 

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

type RecordSIG 

type RecordSIG struct {
	// wTypeCovered (2 bytes): The type covered value for SIG RR as specified in section
	// 4.1 of [RFC2535].
	TypeCovered uint16 `idl:"name:wTypeCovered" json:"type_covered"`
	// chAlgorithm (1 byte): The algorithm value for SIG RR as specified in section 4.1
	// of [RFC2535].
	Algorithm uint8 `idl:"name:chAlgorithm" json:"algorithm"`
	// chLabelCount (1 byte): The total number of labels present in the name of the record
	// signed by the SIG RR as specified in section 4.1 of [RFC2535].
	LabelCount uint8 `idl:"name:chLabelCount" json:"label_count"`
	// dwOriginalTtl (4 bytes): The original TTL value of the record signed by the SIG RR
	// as specified in section 4.1 of [RFC2535].
	OriginalTTL uint32 `idl:"name:dwOriginalTtl" json:"original_ttl"`
	// dwSigExpiration (4 bytes): The signature expiration time as specified in section
	// 4.1 of [RFC2535].
	SigExpiration uint32 `idl:"name:dwSigExpiration" json:"sig_expiration"`
	// dwSigInception (4 bytes): The signature inception time as specified in section 4.1
	// of [RFC2535].
	SigInception uint32 `idl:"name:dwSigInception" json:"sig_inception"`
	// wKeyTag (2 bytes): The key tag value for SIG RR as specified in section 4.1 of [RFC2535].
	KeyTag uint16 `idl:"name:wKeyTag" json:"key_tag"`
	// nameSigner (variable): Pointer to a structure of type DNS_RPC_NAME (section 2.2.2.2.1)
	// containing the FQDN of the originating host for this record.
	Signer *NodeName `idl:"name:nameSigner" json:"signer"`
	// SignatureInfo (variable): Binary signature information as specified in section 4.1
	// of [RFC2535].
	SignatureInfo []byte `idl:"name:SignatureInfo" json:"signature_info"`
}

RecordSIG structure represents DNS_RPC_RECORD_SIG RPC structure.

The DNS_RPC_RECORD_SIG structure contains information about cryptographic public key signatures as specified in section 4 of [RFC2535].<12> This record 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 |   |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| wTypeCovered                                                  | chAlgorithm                   | chLabelCount                  |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| dwOriginalTtl                                                                                                                 |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| dwSigExpiration                                                                                                               |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| dwSigInception                                                                                                                |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| wKeyTag                                                       | nameSigner (variable)                                         |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| ...                                                                                                                           |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| SignatureInfo (variable)                                                                                                      |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| ...                                                                                                                           |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+

func (*RecordSIG) MarshalNDR 

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

func (*RecordSIG) UnmarshalNDR 

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

type RecordSOA 

type RecordSOA struct {
	// dwSerialNo (4 bytes): The serial number of the SOA record.
	SerialNo uint32 `idl:"name:dwSerialNo" json:"serial_no"`
	// dwRefresh (4 bytes): The interval, in seconds, at which a secondary DNS server attempts
	// to contact the primary DNS server for getting an update.
	Refresh uint32 `idl:"name:dwRefresh" json:"refresh"`
	// dwRetry (4 bytes): The interval, in seconds, at which a secondary DNS server retries
	// to check with the primary DNS server in case of failure.
	Retry uint32 `idl:"name:dwRetry" json:"retry"`
	// dwExpire (4 bytes): The duration, in seconds, that a secondary DNS server continues
	// attempts to get updates from the primary DNS server and if still unsuccessful assumes
	// that the primary DNS server is unreachable.
	Expire uint32 `idl:"name:dwExpire" json:"expire"`
	// dwMinimumTtl (4 bytes): The minimum duration, in seconds, for which record data in
	// the zone is valid.
	MinimumTTL uint32 `idl:"name:dwMinimumTtl" json:"minimum_ttl"`
	// namePrimaryServer (variable): The FQDN of the primary DNS server for this zone in
	// DNS_RPC_NAME (section 2.2.2.2.1) format.
	PrimaryServer          *NodeName `idl:"name:namePrimaryServer" json:"primary_server"`
	ZoneAdministratorEmail *NodeName `idl:"name:nameZoneAdministratorEmail" json:"zone_administrator_email"`
}

RecordSOA structure represents DNS_RPC_RECORD_SOA RPC structure.

The DNS_RPC_RECORD_SOA structure contains information about an SOA record (section 3.3.13 in [RFC1035]). This record 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 |   |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| dwSerialNo                                                                                                                    |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| dwRefresh                                                                                                                     |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| dwRetry                                                                                                                       |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| dwExpire                                                                                                                      |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| dwMinimumTtl                                                                                                                  |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| namePrimaryServer (variable)                                                                                                  |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| ...                                                                                                                           |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| Zone Administrator Email (variable)                                                                                           |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| ...                                                                                                                           |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+

func (*RecordSOA) MarshalNDR 

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

func (*RecordSOA) UnmarshalNDR 

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

type RecordSRV 

type RecordSRV struct {
	// wPriority (2 bytes): The priority of the target host as specified in [RFC2782].
	Priority uint16 `idl:"name:wPriority" json:"priority"`
	// wWeight (2 bytes): The relative weight for the target host as specified in [RFC2782].
	Weight uint16 `idl:"name:wWeight" json:"weight"`
	// wPort (2 bytes): The port number for the service on the target host as specified
	// in [RFC2782].
	Port uint16 `idl:"name:wPort" json:"port"`
	// nameTarget (variable): The FDQN of the server that hosts this service in DNS_RPC_NAME
	// (section 2.2.2.2.1) format, as specified in [RFC2782].
	Target *NodeName `idl:"name:nameTarget" json:"target"`
}

RecordSRV structure represents DNS_RPC_RECORD_SRV RPC structure.

The DNS_RPC_RECORD_SRV specifies an SRV resource record as specified in [RFC2782]. This record 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 |   |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| wPriority                                                     | wWeight                                                       |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| wPort                                                         | nameTarget (variable)                                         |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| ...                                                                                                                           |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+

func (*RecordSRV) MarshalNDR 

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

func (*RecordSRV) UnmarshalNDR 

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

type RecordString 

type RecordString struct {
	Data []*NodeText `idl:"name:Data" json:"data"`
}

RecordString structure represents DNS_RPC_RECORD_STRING RPC structure.

The DNS_RPC_RECORD_STRING structure contains information about a DNS record of any of the following types:

* DNS_TYPE_HINFO

* DNS_TYPE_ISDN

* DNS_TYPE_TXT

* DNS_TYPE_X25

* DNS_TYPE_LOC

This packet contains one or more instances of stringData, depending upon the type listed above. This record 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 |   |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| stringData (variable)                                                                                                         |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| ...                                                                                                                           |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+

func (*RecordString) MarshalNDR 

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

func (*RecordString) StringAt 

func (o *RecordString) StringAt(i int) string

func (*RecordString) Strings 

func (o *RecordString) Strings() []string

func (*RecordString) UnmarshalNDR 

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

type RecordTLSA 

type RecordTLSA struct {
	CertUsage                  uint8  `idl:"name:bCertUsage" json:"cert_usage"`
	Selector                   uint8  `idl:"name:bSelector" json:"selector"`
	MatchingType               uint8  `idl:"name:bMatchingType" json:"matching_type"`
	CertificateAssociationData []byte `idl:"name:bCertificateAssociationData" json:"certificate_association_data"`
}

RecordTLSA structure represents DNS_RPC_RECORD_TLSA RPC structure.

func (*RecordTLSA) MarshalNDR 

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

func (*RecordTLSA) UnmarshalNDR 

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

type RecordTXT 

type RecordTXT RecordString

RecordTXT structure represents DNS_RPC_RECORD_TXT RPC structure.

func (*RecordTXT) MarshalNDR 

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

func (*RecordTXT) RecordString 

func (o *RecordTXT) RecordString() *RecordString

func (*RecordTXT) UnmarshalNDR 

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

type RecordUnknown 

type RecordUnknown struct {
	Data []byte `idl:"name:bData" json:"data"`
}

RecordUnknown structure represents DNS_RPC_RECORD_UNKNOWN RPC structure.

func (*RecordUnknown) MarshalNDR 

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

func (*RecordUnknown) UnmarshalNDR 

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

type RecordWINS 

type RecordWINS struct {
	// dwMappingFlag (4 bytes): The scope of the WINS record lookups. This value MUST be
	// set to 0x00000000 or any combination of the following:
	//
	//	+--------------------------------+---------------------------------------------------------+
	//	|                                |                                                         |
	//	|             VALUE              |                         MEANING                         |
	//	|                                |                                                         |
	//	+--------------------------------+---------------------------------------------------------+
	//	+--------------------------------+---------------------------------------------------------+
	//	| DNS_WINS_FLAG_SCOPE 0x80000000 | Server forwards lookup requests to remote WINS servers. |
	//	+--------------------------------+---------------------------------------------------------+
	//	| DNS_WINS_FLAG_LOCAL 0x00010000 | Server performs WINS lookups locally.                   |
	//	+--------------------------------+---------------------------------------------------------+
	MappingFlag uint32 `idl:"name:dwMappingFlag" json:"mapping_flag"`
	// dwLookupTimeout (4 bytes): The duration, in seconds, for which the server waits to
	// receive a response from a remote DNS server.
	LookupTimeout uint32 `idl:"name:dwLookupTimeout" json:"lookup_timeout"`
	// dwCacheTimeout (4 bytes): The duration, in seconds, for which the server keeps this
	// record in its cache before considering it stale.
	CacheTimeout uint32 `idl:"name:dwCacheTimeout" json:"cache_timeout"`
	// cWinsServerCount (4 bytes): The number of WINS server addresses in this record. The
	// value of this field MUST be at least one.
	WINSServerCount uint32 `idl:"name:cWinsServerCount" json:"wins_server_count"`
	// aipWinsServers (variable): An array of IPv4 addresses in network byte order with
	// length given by cWinsServerCount.
	WINSServers [][]byte `idl:"name:aipWinsServers;size_is:(cWinsServerCount, )" json:"wins_servers"`
}

RecordWINS structure represents DNS_RPC_RECORD_WINS RPC structure.

The DNS_RPC_RECORD_WINS specifies a WINS resource record. This record 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 |   |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| dwMappingFlag                                                                                                                 |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| dwLookupTimeout                                                                                                               |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| dwCacheTimeout                                                                                                                |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| cWinsServerCount                                                                                                              |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| aipWinsServers (variable)                                                                                                     |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| ...                                                                                                                           |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+

func (*RecordWINS) MarshalNDR 

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

func (*RecordWINS) UnmarshalNDR 

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

type RecordWINSR 

type RecordWINSR struct {
	// dwMappingFlag (4 bytes): The scope of the WINS-R record lookups. This value MUST
	// be set to zero or any combination of the following:
	//
	//	+--------------------------------+---------------------------------------------------------+
	//	|                                |                                                         |
	//	|             VALUE              |                         MEANING                         |
	//	|                                |                                                         |
	//	+--------------------------------+---------------------------------------------------------+
	//	+--------------------------------+---------------------------------------------------------+
	//	| DNS_WINS_FLAG_SCOPE 0x80000000 | Server forwards lookup requests to remote WINS servers. |
	//	+--------------------------------+---------------------------------------------------------+
	//	| DNS_WINS_FLAG_LOCAL 0x00010000 | Server performs WINS lookups locally.                   |
	//	+--------------------------------+---------------------------------------------------------+
	MappingFlag uint32 `idl:"name:dwMappingFlag" json:"mapping_flag"`
	// dwLookupTimeout (4 bytes): The duration, in seconds, for which server waits to receive
	// a response from a remote DNS server.
	LookupTimeout uint32 `idl:"name:dwLookupTimeout" json:"lookup_timeout"`
	// dwCacheTimeout (4 bytes): The duration, in seconds, for which server keeps this record
	// in its cache before considering it stale.
	CacheTimeout uint32 `idl:"name:dwCacheTimeout" json:"cache_timeout"`
	// nameResultDomain (variable): Pointer to a structure of type DNS_RPC_NAME (section
	// 2.2.2.2.1) containing a domain name suffix that will be appended to a single-label
	// name [RFC1034] obtained from a WINS-R lookup.
	ResultDomain *NodeName `idl:"name:nameResultDomain" json:"result_domain"`
}

RecordWINSR structure represents DNS_RPC_RECORD_WINSR RPC structure.

The DNS_RPC_RECORD_WINSR specifies a Windows Internet Name Service Reverse Lookup (WINS-R) resource record. This record 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 |   |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| dwMappingFlag                                                                                                                 |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| dwLookupTimeout                                                                                                               |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| dwCacheTimeout                                                                                                                |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| nameResultDomain (variable)                                                                                                   |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| ...                                                                                                                           |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+

func (*RecordWINSR) MarshalNDR 

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

func (*RecordWINSR) UnmarshalNDR 

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

type RecordWKS 

type RecordWKS struct {
	// ipAddress (4 bytes): The IPv4 address of the server that provides the service.
	IPAddress []byte `idl:"name:ipAddress" json:"ip_address"`
	// chProtocol (1 byte): The IP protocol number as specified in [IANA-PROTO-NUM].
	Protocol uint8     `idl:"name:chProtocol" json:"protocol"`
	Services *NodeText `idl:"name:nameServices" json:"services"`
}

RecordWKS structure represents DNS_RPC_RECORD_WKS RPC structure.

The DNS_RPC_RECORD_WKS structure contains the information for the well known services supported by a host, as defined in section 3.4.2 [RFC1035]. This record 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 |   |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| ipAddress                                                                                                                     |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| chProtocol                    | bBitMask (variable)                                                                           |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| ...                                                                                                                           |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+

func (*RecordWKS) MarshalNDR 

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

func (*RecordWKS) UnmarshalNDR 

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

type RecordX25 

type RecordX25 RecordString

RecordX25 structure represents DNS_RPC_RECORD_X25 RPC structure.

func (*RecordX25) MarshalNDR 

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

func (*RecordX25) RecordString 

func (o *RecordX25) RecordString() *RecordString

func (*RecordX25) UnmarshalNDR 

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

type RecordZERO 

type RecordZERO struct {
	EntombedTime *dtyp.Filetime `idl:"name:EntombedTime" json:"entombed_time"`
}

RecordZERO structure represents DNS_RPC_RECORD_ZERO RPC structure.

func (*RecordZERO) MarshalNDR 

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

func (*RecordZERO) UnmarshalNDR 

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

type Record_A 

type Record_A struct {
	RecordA *RecordA `idl:"name:recordA" json:"record_a"`
}

Record_A structure represents Record_Record RPC union arm.

It has following labels: 1

func (*Record_A) MarshalNDR 

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

func (*Record_A) UnmarshalNDR 

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

type Record_AAAA 

type Record_AAAA struct {
	RecordAAAA *RecordAAAA `idl:"name:recordAAAA" json:"record_aaaa"`
}

Record_AAAA structure represents Record_Record RPC union arm.

It has following labels: 28

func (*Record_AAAA) MarshalNDR 

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

func (*Record_AAAA) UnmarshalNDR 

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

type Record_AFSDB 

type Record_AFSDB struct {
	RecordAFSDB *RecordAFSDB `idl:"name:recordAFSDB" json:"record_afsdb"`
}

Record_AFSDB structure represents Record_Record RPC union arm.

It has following labels: 18

func (*Record_AFSDB) MarshalNDR 

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

func (*Record_AFSDB) UnmarshalNDR 

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

type Record_ATMA 

type Record_ATMA struct {
	RecordATMA *RecordATMA `idl:"name:recordATMA" json:"record_atma"`
}

Record_ATMA structure represents Record_Record RPC union arm.

It has following labels: 34

func (*Record_ATMA) MarshalNDR 

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

func (*Record_ATMA) UnmarshalNDR 

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

type Record_CNAME 

type Record_CNAME struct {
	RecordCNAME *RecordCNAME `idl:"name:recordCNAME" json:"record_cname"`
}

Record_CNAME structure represents Record_Record RPC union arm.

It has following labels: 5

func (*Record_CNAME) MarshalNDR 

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

func (*Record_CNAME) UnmarshalNDR 

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

type Record_DHCID 

type Record_DHCID struct {
	RecordDHCID *RecordDHCID `idl:"name:recordDHCID" json:"record_dhcid"`
}

Record_DHCID structure represents Record_Record RPC union arm.

It has following labels: 49

func (*Record_DHCID) MarshalNDR 

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

func (*Record_DHCID) UnmarshalNDR 

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

type Record_DNAME 

type Record_DNAME struct {
	RecordDNAME *RecordDNAME `idl:"name:recordDNAME" json:"record_dname"`
}

Record_DNAME structure represents Record_Record RPC union arm.

It has following labels: 39

func (*Record_DNAME) MarshalNDR 

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

func (*Record_DNAME) UnmarshalNDR 

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

type Record_DNSKEY 

type Record_DNSKEY struct {
	RecordDNSKEY *RecordDNSKEY `idl:"name:recordDNSKEY" json:"record_dnskey"`
}

Record_DNSKEY structure represents Record_Record RPC union arm.

It has following labels: 48

func (*Record_DNSKEY) MarshalNDR 

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

func (*Record_DNSKEY) UnmarshalNDR 

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

type Record_DS 

type Record_DS struct {
	RecordDS *RecordDS `idl:"name:recordDS" json:"record_ds"`
}

Record_DS structure represents Record_Record RPC union arm.

It has following labels: 43

func (*Record_DS) MarshalNDR 

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

func (*Record_DS) UnmarshalNDR 

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

type Record_HINFO 

type Record_HINFO struct {
	RecordHINFO *RecordHINFO `idl:"name:recordHINFO" json:"record_hinfo"`
}

Record_HINFO structure represents Record_Record RPC union arm.

It has following labels: 13

func (*Record_HINFO) MarshalNDR 

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

func (*Record_HINFO) UnmarshalNDR 

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

type Record_ISDN 

type Record_ISDN struct {
	RecordISDN *RecordISDN `idl:"name:recordISDN" json:"record_isdn"`
}

Record_ISDN structure represents Record_Record RPC union arm.

It has following labels: 20

func (*Record_ISDN) MarshalNDR 

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

func (*Record_ISDN) UnmarshalNDR 

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

type Record_KEY 

type Record_KEY struct {
	RecordKEY *RecordKEY `idl:"name:recordKEY" json:"record_key"`
}

Record_KEY structure represents Record_Record RPC union arm.

It has following labels: 25

func (*Record_KEY) MarshalNDR 

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

func (*Record_KEY) UnmarshalNDR 

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

type Record_MB 

type Record_MB struct {
	RecordMB *RecordMB `idl:"name:recordMB" json:"record_mb"`
}

Record_MB structure represents Record_Record RPC union arm.

It has following labels: 7

func (*Record_MB) MarshalNDR 

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

func (*Record_MB) UnmarshalNDR 

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

type Record_MD 

type Record_MD struct {
	RecordMD *RecordMD `idl:"name:recordMD" json:"record_md"`
}

Record_MD structure represents Record_Record RPC union arm.

It has following labels: 3

func (*Record_MD) MarshalNDR 

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

func (*Record_MD) UnmarshalNDR 

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

type Record_MF 

type Record_MF struct {
	RecordMF *RecordMF `idl:"name:recordMF" json:"record_mf"`
}

Record_MF structure represents Record_Record RPC union arm.

It has following labels: 4

func (*Record_MF) MarshalNDR 

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

func (*Record_MF) UnmarshalNDR 

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

type Record_MG 

type Record_MG struct {
	RecordMG *RecordMG `idl:"name:recordMG" json:"record_mg"`
}

Record_MG structure represents Record_Record RPC union arm.

It has following labels: 8

func (*Record_MG) MarshalNDR 

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

func (*Record_MG) UnmarshalNDR 

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

type Record_MINFO 

type Record_MINFO struct {
	RecordMINFO *RecordMINFO `idl:"name:recordMINFO" json:"record_minfo"`
}

Record_MINFO structure represents Record_Record RPC union arm.

It has following labels: 14

func (*Record_MINFO) MarshalNDR 

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

func (*Record_MINFO) UnmarshalNDR 

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

type Record_MR 

type Record_MR struct {
	RecordMR *RecordMR `idl:"name:recordMR" json:"record_mr"`
}

Record_MR structure represents Record_Record RPC union arm.

It has following labels: 9

func (*Record_MR) MarshalNDR 

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

func (*Record_MR) UnmarshalNDR 

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

type Record_MX 

type Record_MX struct {
	RecordMX *RecordMX `idl:"name:recordMX" json:"record_mx"`
}

Record_MX structure represents Record_Record RPC union arm.

It has following labels: 15

func (*Record_MX) MarshalNDR 

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

func (*Record_MX) UnmarshalNDR 

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

type Record_NAPTR 

type Record_NAPTR struct {
	RecordNAPTR *RecordNAPTR `idl:"name:recordNAPTR" json:"record_naptr"`
}

Record_NAPTR structure represents Record_Record RPC union arm.

It has following labels: 35

func (*Record_NAPTR) MarshalNDR 

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

func (*Record_NAPTR) UnmarshalNDR 

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

type Record_NS 

type Record_NS struct {
	RecordNS *RecordNS `idl:"name:recordNS" json:"record_ns"`
}

Record_NS structure represents Record_Record RPC union arm.

It has following labels: 2

func (*Record_NS) MarshalNDR 

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

func (*Record_NS) UnmarshalNDR 

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

type Record_NSEC 

type Record_NSEC struct {
	RecordNSEC *RecordNSEC `idl:"name:recordNSEC" json:"record_nsec"`
}

Record_NSEC structure represents Record_Record RPC union arm.

It has following labels: 47

func (*Record_NSEC) MarshalNDR 

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

func (*Record_NSEC) UnmarshalNDR 

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

type Record_NSEC3 

type Record_NSEC3 struct {
	RecordNSEC3 *RecordNSEC3 `idl:"name:recordNSEC3" json:"record_nsec3"`
}

Record_NSEC3 structure represents Record_Record RPC union arm.

It has following labels: 50

func (*Record_NSEC3) MarshalNDR 

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

func (*Record_NSEC3) UnmarshalNDR 

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

type Record_NSEC3PARAM 

type Record_NSEC3PARAM struct {
	RecordNSEC3PARAM *RecordNSEC3PARAM `idl:"name:recordNSEC3PARAM" json:"record_nsec3param"`
}

Record_NSEC3PARAM structure represents Record_Record RPC union arm.

It has following labels: 51

func (*Record_NSEC3PARAM) MarshalNDR 

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

func (*Record_NSEC3PARAM) UnmarshalNDR 

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

type Record_NULL 

type Record_NULL struct {
	RecordNULL *RecordNULL `idl:"name:recordNULL" json:"record_null"`
}

Record_NULL structure represents Record_Record RPC union arm.

It has following labels: 10

func (*Record_NULL) MarshalNDR 

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

func (*Record_NULL) UnmarshalNDR 

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

type Record_NXT 

type Record_NXT struct {
	RecordNXT *RecordNXT `idl:"name:recordNXT" json:"record_nxt"`
}

Record_NXT structure represents Record_Record RPC union arm.

It has following labels: 30

func (*Record_NXT) MarshalNDR 

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

func (*Record_NXT) UnmarshalNDR 

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

type Record_PTR 

type Record_PTR struct {
	RecordPTR *RecordPTR `idl:"name:recordPTR" json:"record_ptr"`
}

Record_PTR structure represents Record_Record RPC union arm.

It has following labels: 12

func (*Record_PTR) MarshalNDR 

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

func (*Record_PTR) UnmarshalNDR 

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

type Record_RP 

type Record_RP struct {
	RecordRP *RecordRP `idl:"name:recordRP" json:"record_rp"`
}

Record_RP structure represents Record_Record RPC union arm.

It has following labels: 17

func (*Record_RP) MarshalNDR 

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

func (*Record_RP) UnmarshalNDR 

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

type Record_RRSIG 

type Record_RRSIG struct {
	RecordRRSIG *RecordRRSIG `idl:"name:recordRRSIG" json:"record_rrsig"`
}

Record_RRSIG structure represents Record_Record RPC union arm.

It has following labels: 46

func (*Record_RRSIG) MarshalNDR 

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

func (*Record_RRSIG) UnmarshalNDR 

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

type Record_RT 

type Record_RT struct {
	RecordRT *RecordRT `idl:"name:recordRT" json:"record_rt"`
}

Record_RT structure represents Record_Record RPC union arm.

It has following labels: 21

func (*Record_RT) MarshalNDR 

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

func (*Record_RT) UnmarshalNDR 

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

type Record_Record 

type Record_Record struct {
	// Types that are assignable to Value
	//
	// *Record_ZERO
	// *Record_A
	// *Record_NS
	// *Record_MD
	// *Record_MF
	// *Record_CNAME
	// *Record_SOA
	// *Record_MB
	// *Record_MG
	// *Record_MR
	// *Record_NULL
	// *Record_WKS
	// *Record_PTR
	// *Record_HINFO
	// *Record_MINFO
	// *Record_MX
	// *Record_TXT
	// *Record_RP
	// *Record_AFSDB
	// *Record_X25
	// *Record_ISDN
	// *Record_RT
	// *Record_SIG
	// *Record_KEY
	// *Record_AAAA
	// *Record_NXT
	// *Record_SRV
	// *Record_ATMA
	// *Record_NAPTR
	// *Record_DNAME
	// *Record_DS
	// *Record_RRSIG
	// *Record_NSEC
	// *Record_DNSKEY
	// *Record_DHCID
	// *Record_NSEC3
	// *Record_NSEC3PARAM
	// *Record_TLSA
	// *Record_WINS
	// *Record_WINSR
	// *Record_Unknown
	Value is_Record_Record `json:"value"`
}

Record_Record structure represents DNS_RPC_RECORD union anonymous member.

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_Record) GetValue 

func (o *Record_Record) GetValue() any

func (*Record_Record) MarshalUnionNDR 

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

func (*Record_Record) NDRSwitchValue 

func (o *Record_Record) NDRSwitchValue(sw uint16) uint16

func (*Record_Record) UnmarshalUnionNDR 

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

type Record_SIG 

type Record_SIG struct {
	RecordSIG *RecordSIG `idl:"name:recordSIG" json:"record_sig"`
}

Record_SIG structure represents Record_Record RPC union arm.

It has following labels: 24

func (*Record_SIG) MarshalNDR 

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

func (*Record_SIG) UnmarshalNDR 

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

type Record_SOA 

type Record_SOA struct {
	RecordSOA *RecordSOA `idl:"name:recordSOA" json:"record_soa"`
}

Record_SOA structure represents Record_Record RPC union arm.

It has following labels: 6

func (*Record_SOA) MarshalNDR 

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

func (*Record_SOA) UnmarshalNDR 

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

type Record_SRV 

type Record_SRV struct {
	RecordSRV *RecordSRV `idl:"name:recordSRV" json:"record_srv"`
}

Record_SRV structure represents Record_Record RPC union arm.

It has following labels: 33

func (*Record_SRV) MarshalNDR 

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

func (*Record_SRV) UnmarshalNDR 

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

type Record_TLSA 

type Record_TLSA struct {
	RecordTLSA *RecordTLSA `idl:"name:recordTLSA" json:"record_tlsa"`
}

Record_TLSA structure represents Record_Record RPC union arm.

It has following labels: 52

func (*Record_TLSA) MarshalNDR 

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

func (*Record_TLSA) UnmarshalNDR 

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

type Record_TXT 

type Record_TXT struct {
	RecordTXT *RecordTXT `idl:"name:recordTXT" json:"record_txt"`
}

Record_TXT structure represents Record_Record RPC union arm.

It has following labels: 16

func (*Record_TXT) MarshalNDR 

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

func (*Record_TXT) UnmarshalNDR 

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

type Record_Unknown 

type Record_Unknown struct {
	RecordUnknown *RecordUnknown `idl:"name:recordUnknown" json:"record_unknown"`
}

Record_Unknown structure represents Record_Record RPC default union arm.

func (*Record_Unknown) MarshalNDR 

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

func (*Record_Unknown) UnmarshalNDR 

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

type Record_WINS 

type Record_WINS struct {
	RecordWINS *RecordWINS `idl:"name:recordWINS" json:"record_wins"`
}

Record_WINS structure represents Record_Record RPC union arm.

It has following labels: 65281

func (*Record_WINS) MarshalNDR 

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

func (*Record_WINS) UnmarshalNDR 

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

type Record_WINSR 

type Record_WINSR struct {
	RecordWINSR *RecordWINSR `idl:"name:recordWINSR" json:"record_winsr"`
}

Record_WINSR structure represents Record_Record RPC union arm.

It has following labels: 65282

func (*Record_WINSR) MarshalNDR 

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

func (*Record_WINSR) UnmarshalNDR 

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

type Record_WKS 

type Record_WKS struct {
	RecordWKS *RecordWKS `idl:"name:recordWKS" json:"record_wks"`
}

Record_WKS structure represents Record_Record RPC union arm.

It has following labels: 11

func (*Record_WKS) MarshalNDR 

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

func (*Record_WKS) UnmarshalNDR 

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

type Record_X25 

type Record_X25 struct {
	RecordX25 *RecordX25 `idl:"name:recordX25" json:"record_x25"`
}

Record_X25 structure represents Record_Record RPC union arm.

It has following labels: 19

func (*Record_X25) MarshalNDR 

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

func (*Record_X25) UnmarshalNDR 

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

type Record_ZERO 

type Record_ZERO struct {
	RecordZERO *RecordZERO `idl:"name:recordZERO" json:"record_zero"`
}

Record_ZERO structure represents Record_Record RPC union arm.

It has following labels: 0

func (*Record_ZERO) MarshalNDR 

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

func (*Record_ZERO) UnmarshalNDR 

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

type TypeRecord 

type TypeRecord uint16

TypeRecord type represents DNS_RPC_TYPE_RECORD RPC enumeration. 

var (
	TypeRecordZERO       TypeRecord = 0
	TypeRecordA          TypeRecord = 1
	TypeRecordNS         TypeRecord = 2
	TypeRecordMD         TypeRecord = 3
	TypeRecordMF         TypeRecord = 4
	TypeRecordCNAME      TypeRecord = 5
	TypeRecordSOA        TypeRecord = 6
	TypeRecordMB         TypeRecord = 7
	TypeRecordMG         TypeRecord = 8
	TypeRecordMR         TypeRecord = 9
	TypeRecordNULL       TypeRecord = 10
	TypeRecordWKS        TypeRecord = 11
	TypeRecordPTR        TypeRecord = 12
	TypeRecordHINFO      TypeRecord = 13
	TypeRecordMINFO      TypeRecord = 14
	TypeRecordMX         TypeRecord = 15
	TypeRecordTXT        TypeRecord = 16
	TypeRecordRP         TypeRecord = 17
	TypeRecordAFSDB      TypeRecord = 18
	TypeRecordX25        TypeRecord = 19
	TypeRecordISDN       TypeRecord = 20
	TypeRecordRT         TypeRecord = 21
	TypeRecordSIG        TypeRecord = 24
	TypeRecordKEY        TypeRecord = 25
	TypeRecordAAAA       TypeRecord = 28
	TypeRecordNXT        TypeRecord = 30
	TypeRecordSRV        TypeRecord = 33
	TypeRecordATMA       TypeRecord = 34
	TypeRecordNAPTR      TypeRecord = 35
	TypeRecordDNAME      TypeRecord = 39
	TypeRecordDS         TypeRecord = 43
	TypeRecordRRSIG      TypeRecord = 46
	TypeRecordNSEC       TypeRecord = 47
	TypeRecordDNSKEY     TypeRecord = 48
	TypeRecordDHCID      TypeRecord = 49
	TypeRecordNSEC3      TypeRecord = 50
	TypeRecordNSEC3PARAM TypeRecord = 51
	TypeRecordTLSA       TypeRecord = 52
	TypeRecordWINS       TypeRecord = 65281
	TypeRecordWINSR      TypeRecord = 65282
)

func (TypeRecord) String 

func (o TypeRecord) String() string

Source Files

View all Source files

Directories

Path Synopsis

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.