You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2698 lines
67 KiB
2698 lines
67 KiB
/*++
|
|
|
|
Copyright (c) 1997 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
dnsapi.h
|
|
|
|
Abstract:
|
|
|
|
Domain Name System (DNS)
|
|
|
|
DNS Client API Library
|
|
|
|
Author:
|
|
|
|
Jim Gilroy (jamesg) December 7, 1996
|
|
|
|
Revision History:
|
|
|
|
Glenn Curtis (glennc) January 22, 1997
|
|
Added Dynamic Update Client API for DNSAPI.DLL
|
|
|
|
--*/
|
|
|
|
|
|
#ifndef _DNSAPI_INCLUDED_
|
|
#define _DNSAPI_INCLUDED_
|
|
|
|
#ifndef _WINSOCK2API_
|
|
#ifndef _WINSOCKAPI_
|
|
#include <winsock2.h>
|
|
#endif
|
|
#endif
|
|
|
|
#ifndef _DNS_INCLUDED_
|
|
#include <dns.h>
|
|
#endif
|
|
|
|
|
|
#ifdef __cplusplus
|
|
extern "C"
|
|
{
|
|
#endif // __cplusplus
|
|
|
|
|
|
//
|
|
// Non-wrapping seconds timer (timer.c)
|
|
//
|
|
|
|
DWORD
|
|
GetCurrentTimeInSeconds(
|
|
VOID
|
|
);
|
|
|
|
|
|
//
|
|
// General DNS utilities (dnsutil.c)
|
|
//
|
|
|
|
LPSTR
|
|
_fastcall
|
|
DnsGetDomainName(
|
|
IN LPSTR pszName
|
|
);
|
|
|
|
LPSTR
|
|
_fastcall
|
|
DnsStatusString(
|
|
IN DNS_STATUS Status
|
|
);
|
|
|
|
#define DnsStatusToErrorString_A(status) DnsStatusString(status)
|
|
|
|
DNS_STATUS
|
|
_fastcall
|
|
DnsMapRcodeToStatus(
|
|
IN BYTE ResponseCode
|
|
);
|
|
|
|
BYTE
|
|
_fastcall
|
|
DnsIsStatusRcode(
|
|
IN DNS_STATUS Status
|
|
);
|
|
|
|
//
|
|
// Machines IP address list (iplist.c)
|
|
//
|
|
// Routine to get the current IP addresses from all adapters
|
|
// configured for the machine.
|
|
//
|
|
|
|
DWORD
|
|
DnsGetIpAddressList(
|
|
OUT PIP_ARRAY * ppIpAddresses
|
|
);
|
|
|
|
//
|
|
// Routine to get the current IP addresses and subnet masks
|
|
// from all adapters configured for the machine.
|
|
//
|
|
|
|
typedef struct _DNS_ADDRESS_INFO_
|
|
{
|
|
IP_ADDRESS ipAddress;
|
|
IP_ADDRESS subnetMask;
|
|
}
|
|
DNS_ADDRESS_INFO, *PDNS_ADDRESS_INFO;
|
|
|
|
DWORD
|
|
DnsGetIpAddressInfoList(
|
|
OUT PDNS_ADDRESS_INFO * ppAddrInfo
|
|
);
|
|
|
|
DWORD
|
|
DnsGetDnsServerList(
|
|
OUT PIP_ARRAY * ppDnsAddresses
|
|
);
|
|
|
|
|
|
//
|
|
// Routines and structures for getting network configuration information
|
|
// for TCPIP interfaces
|
|
//
|
|
|
|
#define NETINFO_FLAG_IS_WAN_ADAPTER (0x00000002)
|
|
#define NETINFO_FLAG_IS_AUTONET_ADAPTER (0x00000004)
|
|
#define NETINFO_FLAG_IS_DHCP_CFG_ADAPTER (0x00000008)
|
|
|
|
|
|
typedef struct _NAME_SERVER_INFORMATION_
|
|
{
|
|
IP_ADDRESS ipAddress;
|
|
DWORD Priority;
|
|
}
|
|
NAME_SERVER_INFORMATION, *PNAME_SERVER_INFORMATION;
|
|
|
|
typedef struct _ADAPTER_INFORMATION_
|
|
{
|
|
LPSTR pszAdapterGuidName;
|
|
LPSTR pszDomain;
|
|
PIP_ARRAY pIPAddresses;
|
|
PIP_ARRAY pIPSubnetMasks;
|
|
DWORD InfoFlags;
|
|
DWORD cServerCount;
|
|
NAME_SERVER_INFORMATION aipServers[1];
|
|
}
|
|
ADAPTER_INFORMATION, *PADAPTER_INFORMATION;
|
|
|
|
typedef struct _SEARCH_INFORMATION_
|
|
{
|
|
LPSTR pszPrimaryDomainName;
|
|
DWORD cNameCount;
|
|
LPSTR aSearchListNames[1];
|
|
}
|
|
SEARCH_INFORMATION, *PSEARCH_INFORMATION;
|
|
|
|
typedef struct _NETWORK_INFORMATION_
|
|
{
|
|
PSEARCH_INFORMATION pSearchInformation;
|
|
DWORD cAdapterCount;
|
|
PADAPTER_INFORMATION aAdapterInfoList[1];
|
|
}
|
|
NETWORK_INFORMATION, *PNETWORK_INFORMATION;
|
|
|
|
|
|
PNETWORK_INFORMATION
|
|
WINAPI
|
|
DnsGetNetworkInformation(
|
|
void
|
|
);
|
|
|
|
PSEARCH_INFORMATION
|
|
WINAPI
|
|
DnsGetSearchInformation(
|
|
void
|
|
);
|
|
|
|
VOID
|
|
WINAPI
|
|
DnsFreeAdapterInformation(
|
|
IN PADAPTER_INFORMATION pAdapterInformation
|
|
);
|
|
|
|
VOID
|
|
WINAPI
|
|
DnsFreeSearchInformation(
|
|
IN PSEARCH_INFORMATION pSearchInformation
|
|
);
|
|
|
|
VOID
|
|
WINAPI
|
|
DnsFreeNetworkInformation(
|
|
IN PNETWORK_INFORMATION pNetworkInformation
|
|
);
|
|
|
|
|
|
|
|
//
|
|
// Resource record type utilities (record.c)
|
|
//
|
|
|
|
BOOL
|
|
_fastcall
|
|
DnsIsAMailboxType(
|
|
IN WORD wType
|
|
);
|
|
|
|
WORD
|
|
DnsRecordTypeForName(
|
|
IN PCHAR pszName,
|
|
IN INT cchNameLength
|
|
);
|
|
|
|
PCHAR
|
|
DnsRecordStringForType(
|
|
IN WORD wType
|
|
);
|
|
|
|
PCHAR
|
|
DnsRecordStringForWritableType(
|
|
IN WORD wType
|
|
);
|
|
|
|
BOOL
|
|
DnsIsStringCountValidForTextType(
|
|
IN WORD wType,
|
|
IN WORD StringCount
|
|
);
|
|
|
|
BOOL
|
|
DnsIpv6StringToAddress(
|
|
OUT PIPV6_ADDRESS pAddress,
|
|
IN PCHAR pchString,
|
|
IN DWORD dwStringLength
|
|
);
|
|
|
|
VOID
|
|
DnsIpv6AddressToString(
|
|
OUT PCHAR pchString,
|
|
IN PIPV6_ADDRESS pAddress
|
|
);
|
|
|
|
|
|
|
|
//
|
|
// Resource record structure for send\recv records.
|
|
//
|
|
|
|
//
|
|
// Record data for specific types
|
|
//
|
|
|
|
#ifdef SDK_DNS_RECORD
|
|
|
|
typedef struct
|
|
{
|
|
IP_ADDRESS ipAddress;
|
|
}
|
|
DNS_A_DATA, *PDNS_A_DATA;
|
|
|
|
typedef struct
|
|
{
|
|
LPTSTR pNameHost;
|
|
}
|
|
DNS_PTR_DATA, *PDNS_PTR_DATA;
|
|
|
|
typedef struct
|
|
{
|
|
LPTSTR pNamePrimaryServer;
|
|
LPTSTR pNameAdministrator;
|
|
DWORD dwSerialNo;
|
|
DWORD dwRefresh;
|
|
DWORD dwRetry;
|
|
DWORD dwExpire;
|
|
DWORD dwDefaultTtl;
|
|
}
|
|
DNS_SOA_DATA, *PDNS_SOA_DATA;
|
|
|
|
typedef struct
|
|
{
|
|
LPTSTR pNameMailbox;
|
|
LPTSTR pNameErrorsMailbox;
|
|
}
|
|
DNS_MINFO_DATA, *PDNS_MINFO_DATA;
|
|
|
|
typedef struct
|
|
{
|
|
LPTSTR pNameExchange;
|
|
WORD wPreference;
|
|
WORD Pad; // keep ptrs DWORD aligned
|
|
}
|
|
DNS_MX_DATA, *PDNS_MX_DATA;
|
|
|
|
typedef struct
|
|
{
|
|
DWORD dwStringCount;
|
|
#ifdef MIDL_PASS
|
|
[size_is(dwStringCount)] LPTSTR * pStringArray;
|
|
#else // MIDL_PASS
|
|
LPTSTR pStringArray[1];
|
|
#endif // MIDL_PASS
|
|
}
|
|
DNS_TXT_DATA, *PDNS_TXT_DATA;
|
|
|
|
typedef struct
|
|
{
|
|
DWORD dwByteCount;
|
|
#ifdef MIDL_PASS
|
|
[size_is(dwByteCount)] PBYTE bData;
|
|
#else // MIDL_PASS
|
|
BYTE bData[1];
|
|
#endif // MIDL_PASS
|
|
}
|
|
DNS_NULL_DATA, *PDNS_NULL_DATA;
|
|
|
|
typedef struct
|
|
{
|
|
IP_ADDRESS ipAddress;
|
|
UCHAR chProtocol;
|
|
BYTE bBitMask[1];
|
|
}
|
|
DNS_WKS_DATA, *PDNS_WKS_DATA;
|
|
|
|
typedef struct
|
|
{
|
|
IPV6_ADDRESS ipv6Address;
|
|
}
|
|
DNS_AAAA_DATA, *PDNS_AAAA_DATA;
|
|
|
|
typedef struct
|
|
{
|
|
LPTSTR pNameSigner;
|
|
WORD wTypeCovered;
|
|
BYTE chAlgorithm;
|
|
BYTE chLabelCount;
|
|
DWORD dwOriginalTtl;
|
|
DWORD dwExpiration;
|
|
DWORD dwTimeSigned;
|
|
WORD wKeyTag;
|
|
WORD Pad; // keep byte field aligned
|
|
BYTE Signature[1];
|
|
}
|
|
DNS_SIG_DATA, *PDNS_SIG_DATA;
|
|
|
|
typedef struct
|
|
{
|
|
WORD wFlags;
|
|
BYTE chProtocol;
|
|
BYTE chAlgorithm;
|
|
BYTE Key[1];
|
|
}
|
|
DNS_KEY_DATA, *PDNS_KEY_DATA;
|
|
|
|
typedef struct
|
|
{
|
|
WORD wVersion;
|
|
WORD wSize;
|
|
WORD wHorPrec;
|
|
WORD wVerPrec;
|
|
DWORD dwLatitude;
|
|
DWORD dwLongitude;
|
|
DWORD dwAltitude;
|
|
}
|
|
DNS_LOC_DATA, *PDNS_LOC_DATA;
|
|
|
|
typedef struct
|
|
{
|
|
LPTSTR pNameNext;
|
|
BYTE bTypeBitMap[1];
|
|
}
|
|
DNS_NXT_DATA, *PDNS_NXT_DATA;
|
|
|
|
typedef struct
|
|
{
|
|
LPTSTR pNameTarget;
|
|
WORD wPriority;
|
|
WORD wWeight;
|
|
WORD wPort;
|
|
WORD Pad; // keep ptrs DWORD aligned
|
|
}
|
|
DNS_SRV_DATA, *PDNS_SRV_DATA;
|
|
|
|
typedef struct
|
|
{
|
|
LPTSTR pNameAlgorithm;
|
|
PBYTE pAlgorithmPacket;
|
|
PBYTE pKey;
|
|
PBYTE pOtherData;
|
|
DWORD dwCreateTime;
|
|
DWORD dwExpireTime;
|
|
WORD wMode;
|
|
WORD wError;
|
|
WORD wKeyLength;
|
|
WORD wOtherLength;
|
|
UCHAR cAlgNameLength;
|
|
BOOL fPacketPointers;
|
|
}
|
|
DNS_TKEY_DATA, *PDNS_TKEY_DATA;
|
|
|
|
typedef struct
|
|
{
|
|
LPTSTR pNameAlgorithm;
|
|
PBYTE pAlgorithmPacket;
|
|
PBYTE pSignature;
|
|
PBYTE pOtherData;
|
|
LONGLONG i64CreateTime;
|
|
WORD wFudgeTime;
|
|
WORD wOriginalID;
|
|
WORD wError;
|
|
WORD wSigLength;
|
|
WORD wOtherLength;
|
|
UCHAR cAlgNameLength;
|
|
BOOL fPacketPointers;
|
|
}
|
|
DNS_TSIG_DATA, *PDNS_TSIG_DATA;
|
|
|
|
|
|
#define DNS_ATM_TYPE_E164 0x01 // E.164 addressing scheme
|
|
#define DNS_ATM_TYPE_NSAP 0x02 // NSAP-style addressing scheme
|
|
#define DNS_ATM_TYPE_AESA DNS_ATM_TYPE_NSAP
|
|
|
|
#define DNS_ATM_MAX_ADDR_SIZE 20
|
|
|
|
typedef struct
|
|
{
|
|
BYTE AddressType;
|
|
BYTE Address[ DNS_ATM_MAX_ADDR_SIZE ];
|
|
|
|
// Endsystem Address IA5 digits
|
|
// for E164, BCD encoding for NSAP
|
|
// Array size is DNS_ATM_MAX_ADDR_SIZE for NSAP
|
|
// address type, and a null terminated string
|
|
// less than DNS_ATM_MAX_ADDR_SIZE characters
|
|
// for E164 address type.
|
|
}
|
|
DNS_ATMA_DATA, *PDNS_ATMA_DATA;
|
|
|
|
|
|
//
|
|
// MS only types -- only hit the wire in MS-MS zone transfer
|
|
//
|
|
|
|
typedef struct
|
|
{
|
|
DWORD dwMappingFlag;
|
|
DWORD dwLookupTimeout;
|
|
DWORD dwCacheTimeout;
|
|
DWORD cWinsServerCount;
|
|
IP_ADDRESS aipWinsServers[1];
|
|
}
|
|
DNS_WINS_DATA, *PDNS_WINS_DATA;
|
|
|
|
typedef struct
|
|
{
|
|
DWORD dwMappingFlag;
|
|
DWORD dwLookupTimeout;
|
|
DWORD dwCacheTimeout;
|
|
LPTSTR pNameResultDomain;
|
|
}
|
|
DNS_WINSR_DATA, *PDNS_WINSR_DATA;
|
|
|
|
|
|
//
|
|
// Length of non-fixed-length data types
|
|
//
|
|
|
|
#define DNS_TEXT_RECORD_LENGTH(StringCount) \
|
|
(sizeof(DWORD) + ((StringCount) * sizeof(PCHAR)))
|
|
|
|
#define DNS_NULL_RECORD_LENGTH(ByteCount) \
|
|
(sizeof(DWORD) + (ByteCount))
|
|
|
|
#define DNS_WKS_RECORD_LENGTH(ByteCount) \
|
|
(sizeof(DNS_WKS_DATA) + (ByteCount-1))
|
|
|
|
#define DNS_WINS_RECORD_LENGTH(IpCount) \
|
|
(sizeof(DNS_WINS_DATA) + ((IpCount-1) * sizeof(IP_ADDRESS)))
|
|
|
|
|
|
//
|
|
// Record flags
|
|
//
|
|
|
|
#if 0
|
|
typedef struct _DnsRecordFlags
|
|
{
|
|
BYTE Section : 2;
|
|
BYTE Delete : 1;
|
|
BYTE Unused : 5;
|
|
|
|
BYTE Unused2 : 4;
|
|
BYTE FreeData : 1;
|
|
BYTE FreeOwner : 1;
|
|
BYTE Unicode : 1;
|
|
BYTE Multiple : 1;
|
|
|
|
WORD Reserved;
|
|
}
|
|
DNSREC_FLAGS;
|
|
#endif
|
|
|
|
|
|
|
|
typedef struct _DnsRecordFlags
|
|
{
|
|
DWORD Section : 2;
|
|
DWORD Delete : 1;
|
|
DWORD CharSet : 2;
|
|
DWORD Unused : 3;
|
|
|
|
DWORD Reserved : 24;
|
|
}
|
|
DNSREC_FLAGS;
|
|
|
|
|
|
//
|
|
// Record flags as bit flags
|
|
// These may be or'd together to set the fields
|
|
//
|
|
|
|
// RR Section in packet
|
|
|
|
#define DNSREC_SECTION (0x00000003)
|
|
|
|
#define DNSREC_QUESTION (0x00000000)
|
|
#define DNSREC_ANSWER (0x00000001)
|
|
#define DNSREC_AUTHORITY (0x00000002)
|
|
#define DNSREC_ADDITIONAL (0x00000003)
|
|
|
|
// RR Section in packet (update)
|
|
|
|
#define DNSREC_ZONE (0x00000000)
|
|
#define DNSREC_PREREQ (0x00000001)
|
|
#define DNSREC_UPDATE (0x00000002)
|
|
|
|
// Delete RR (update) or No-exist (prerequisite)
|
|
|
|
#define DNSREC_DELETE (0x00000004)
|
|
#define DNSREC_NOEXIST (0x00000004)
|
|
|
|
|
|
#ifdef MIDL_PASS
|
|
typedef [switch_type(WORD)] union _DNS_RECORD_DATA_TYPES
|
|
{
|
|
[case(DNS_TYPE_A)] DNS_A_DATA A;
|
|
|
|
[case(DNS_TYPE_SOA)] DNS_SOA_DATA SOA;
|
|
|
|
[case(DNS_TYPE_PTR,
|
|
DNS_TYPE_NS,
|
|
DNS_TYPE_CNAME,
|
|
DNS_TYPE_MB,
|
|
DNS_TYPE_MD,
|
|
DNS_TYPE_MF,
|
|
DNS_TYPE_MG,
|
|
DNS_TYPE_MR)] DNS_PTR_DATA PTR;
|
|
|
|
[case(DNS_TYPE_MINFO,
|
|
DNS_TYPE_RP)] DNS_MINFO_DATA MINFO;
|
|
|
|
[case(DNS_TYPE_MX,
|
|
DNS_TYPE_AFSDB,
|
|
DNS_TYPE_RT)] DNS_MX_DATA MX;
|
|
|
|
#if 0
|
|
// RPC is not able to handle a proper TXT record definition
|
|
// note: that if other types are needed they are fixed
|
|
// (or semi-fixed) size and may be accomodated easily
|
|
[case(DNS_TYPE_HINFO,
|
|
DNS_TYPE_ISDN,
|
|
DNS_TYPE_TEXT,
|
|
DNS_TYPE_X25)] DNS_TXT_DATA TXT;
|
|
|
|
[case(DNS_TYPE_NULL)] DNS_NULL_DATA Null;
|
|
[case(DNS_TYPE_WKS)] DNS_WKS_DATA WKS;
|
|
[case(DNS_TYPE_TKEY)] DNS_TKEY_DATA TKEY;
|
|
[case(DNS_TYPE_TSIG)] DNS_TSIG_DATA TSIG;
|
|
[case(DNS_TYPE_WINS)] DNS_WINS_DATA WINS;
|
|
[case(DNS_TYPE_NBSTAT)] DNS_WINSR_DATA WINSR;
|
|
#endif
|
|
|
|
[case(DNS_TYPE_AAAA)] DNS_AAAA_DATA AAAA;
|
|
[case(DNS_TYPE_SRV)] DNS_SRV_DATA SRV;
|
|
[case(DNS_TYPE_ATMA)] DNS_ATMA_DATA ATMA;
|
|
//
|
|
// BUGBUG - Commented out since this may not be needed - Check with MarioG
|
|
//
|
|
//[default] ;
|
|
}
|
|
DNS_RECORD_DATA_TYPES;
|
|
#endif // MIDL_PASS
|
|
|
|
|
|
//
|
|
// Record \ RR set structure
|
|
//
|
|
// Note: The dwReserved flag serves to insure that the substructures
|
|
// start on 64-bit boundaries. Since adding the LONGLONG to
|
|
// TSIG structure the compiler wants to start them there anyway
|
|
// (to 64-align). This insures that no matter what data fields
|
|
// are present we are properly 64-aligned.
|
|
//
|
|
// Do NOT pack this structure, as the substructures to be 64-aligned
|
|
// for Win64.
|
|
//
|
|
|
|
typedef struct _DnsRecord
|
|
{
|
|
struct _DnsRecord * pNext;
|
|
LPTSTR pName;
|
|
WORD wType;
|
|
WORD wDataLength; // Not referenced for DNS record types
|
|
// defined above.
|
|
#ifdef MIDL_PASS
|
|
DWORD Flags;
|
|
#else // MIDL_PASS
|
|
union
|
|
{
|
|
DWORD DW; // flags as dword
|
|
DNSREC_FLAGS S; // flags as structure
|
|
|
|
} Flags;
|
|
#endif // MIDL_PASS
|
|
|
|
DWORD dwTtl;
|
|
DWORD dwReserved;
|
|
#ifdef MIDL_PASS
|
|
[switch_is(wType)] DNS_RECORD_DATA_TYPES Data;
|
|
#else // MIDL_PASS
|
|
union
|
|
{
|
|
DNS_A_DATA A;
|
|
DNS_SOA_DATA SOA, Soa;
|
|
DNS_PTR_DATA PTR, Ptr,
|
|
NS, Ns,
|
|
CNAME, Cname,
|
|
MB, Mb,
|
|
MD, Md,
|
|
MF, Mf,
|
|
MG, Mg,
|
|
MR, Mr;
|
|
DNS_MINFO_DATA MINFO, Minfo,
|
|
RP, Rp;
|
|
DNS_MX_DATA MX, Mx,
|
|
AFSDB, Afsdb,
|
|
RT, Rt;
|
|
DNS_TXT_DATA HINFO, Hinfo,
|
|
ISDN, Isdn,
|
|
TXT, Txt,
|
|
X25;
|
|
DNS_NULL_DATA Null;
|
|
DNS_WKS_DATA WKS, Wks;
|
|
DNS_AAAA_DATA AAAA;
|
|
DNS_SRV_DATA SRV, Srv;
|
|
DNS_TKEY_DATA TKEY, Tkey;
|
|
DNS_TSIG_DATA TSIG, Tsig;
|
|
DNS_ATMA_DATA ATMA, Atma;
|
|
DNS_WINS_DATA WINS, Wins;
|
|
DNS_WINSR_DATA WINSR, WinsR, NBSTAT, Nbstat;
|
|
|
|
} Data;
|
|
#endif // MIDL_PASS
|
|
}
|
|
DNS_RECORD, *PDNS_RECORD;
|
|
|
|
|
|
|
|
#else // not SDK_DNS_RECORD
|
|
|
|
//
|
|
// Old DNS_RECORD definitions
|
|
// JBUGBUG: save only until Cliff (and any other NT file)
|
|
// can be converted, then dump
|
|
//
|
|
|
|
//
|
|
// Record data for specific types
|
|
//
|
|
|
|
typedef struct
|
|
{
|
|
IP_ADDRESS ipAddress;
|
|
}
|
|
DNS_A_DATA, *PDNS_A_DATA;
|
|
|
|
typedef struct
|
|
{
|
|
DNS_NAME nameHost;
|
|
}
|
|
DNS_PTR_DATA, *PDNS_PTR_DATA;
|
|
|
|
typedef struct
|
|
{
|
|
DNS_NAME namePrimaryServer;
|
|
DNS_NAME nameAdministrator;
|
|
DWORD dwSerialNo;
|
|
DWORD dwRefresh;
|
|
DWORD dwRetry;
|
|
DWORD dwExpire;
|
|
DWORD dwDefaultTtl;
|
|
}
|
|
DNS_SOA_DATA, *PDNS_SOA_DATA;
|
|
|
|
typedef struct
|
|
{
|
|
DNS_NAME nameMailbox;
|
|
DNS_NAME nameErrorsMailbox;
|
|
}
|
|
DNS_MINFO_DATA, *PDNS_MINFO_DATA;
|
|
|
|
typedef struct
|
|
{
|
|
DNS_NAME nameExchange;
|
|
WORD wPreference;
|
|
WORD Pad; // keep ptrs DWORD aligned
|
|
}
|
|
DNS_MX_DATA, *PDNS_MX_DATA;
|
|
|
|
typedef struct
|
|
{
|
|
DWORD dwStringCount;
|
|
DNS_TEXT pStringArray[1];
|
|
}
|
|
DNS_TXT_DATA, *PDNS_TXT_DATA;
|
|
|
|
typedef struct
|
|
{
|
|
// DWORD dwByteCount;
|
|
BYTE bData[1];
|
|
}
|
|
DNS_NULL_DATA, *PDNS_NULL_DATA;
|
|
|
|
typedef struct
|
|
{
|
|
IP_ADDRESS ipAddress;
|
|
UCHAR chProtocol;
|
|
BYTE bBitMask[1];
|
|
}
|
|
DNS_WKS_DATA, *PDNS_WKS_DATA;
|
|
|
|
typedef struct
|
|
{
|
|
IPV6_ADDRESS ipv6Address;
|
|
}
|
|
DNS_AAAA_DATA, *PDNS_AAAA_DATA;
|
|
|
|
typedef struct
|
|
{
|
|
DNS_NAME nameSigner;
|
|
WORD wTypeCovered;
|
|
BYTE chAlgorithm;
|
|
BYTE chLabelCount;
|
|
DWORD dwOriginalTtl;
|
|
DWORD dwExpiration;
|
|
DWORD dwTimeSigned;
|
|
WORD wKeyTag;
|
|
WORD Pad; // keep byte field aligned
|
|
BYTE Signature[1];
|
|
}
|
|
DNS_SIG_DATA, *PDNS_SIG_DATA;
|
|
|
|
typedef struct
|
|
{
|
|
WORD wFlags;
|
|
BYTE chProtocol;
|
|
BYTE chAlgorithm;
|
|
BYTE Key[1];
|
|
}
|
|
DNS_KEY_DATA, *PDNS_KEY_DATA;
|
|
|
|
typedef struct
|
|
{
|
|
WORD wVersion;
|
|
WORD wSize;
|
|
WORD wHorPrec;
|
|
WORD wVerPrec;
|
|
DWORD dwLatitude;
|
|
DWORD dwLongitude;
|
|
DWORD dwAltitude;
|
|
}
|
|
DNS_LOC_DATA, *PDNS_LOC_DATA;
|
|
|
|
typedef struct
|
|
{
|
|
DNS_NAME nameNext;
|
|
BYTE bTypeBitMap[1];
|
|
}
|
|
DNS_NXT_DATA, *PDNS_NXT_DATA;
|
|
|
|
typedef struct
|
|
{
|
|
DNS_NAME nameTarget;
|
|
WORD wPriority;
|
|
WORD wWeight;
|
|
WORD wPort;
|
|
WORD Pad; // keep ptrs DWORD aligned
|
|
}
|
|
DNS_SRV_DATA, *PDNS_SRV_DATA;
|
|
|
|
typedef struct
|
|
{
|
|
DNS_NAME nameAlgorithm;
|
|
PBYTE pAlgorithmPacket;
|
|
PBYTE pKey;
|
|
PBYTE pOtherData;
|
|
DWORD dwCreateTime;
|
|
DWORD dwExpireTime;
|
|
WORD wMode;
|
|
WORD wError;
|
|
WORD wKeyLength;
|
|
WORD wOtherLength;
|
|
UCHAR cAlgNameLength;
|
|
BOOLEAN fPacketPointers;
|
|
}
|
|
DNS_TKEY_DATA, *PDNS_TKEY_DATA;
|
|
|
|
typedef struct
|
|
{
|
|
DNS_NAME nameAlgorithm;
|
|
PBYTE pAlgorithmPacket;
|
|
PBYTE pSignature;
|
|
PBYTE pOtherData;
|
|
LONGLONG i64CreateTime;
|
|
WORD wFudgeTime;
|
|
WORD wOriginalID;
|
|
WORD wError;
|
|
WORD wSigLength;
|
|
WORD wOtherLength;
|
|
UCHAR cAlgNameLength;
|
|
BOOLEAN fPacketPointers;
|
|
}
|
|
DNS_TSIG_DATA, *PDNS_TSIG_DATA;
|
|
|
|
#define DNS_ATM_TYPE_E164 0x01 // E.164 addressing scheme
|
|
#define DNS_ATM_TYPE_NSAP 0x02 // NSAP-style addressing scheme
|
|
#define DNS_ATM_TYPE_AESA DNS_ATM_TYPE_NSAP
|
|
|
|
#define DNS_ATM_MAX_ADDR_SIZE 20
|
|
|
|
typedef struct
|
|
{
|
|
BYTE AddressType; // E.164 or NSAP-style ATM Endsystem Address
|
|
BYTE Address[1]; // IA5 digits for E164, BCD encoding for NSAP
|
|
// Array size is DNS_ATM_MAX_ADDR_SIZE for NSAP
|
|
// address type, and a null terminated string
|
|
// less than DNS_ATM_MAX_ADDR_SIZE characters
|
|
// for E164 address type.
|
|
}
|
|
DNS_ATMA_DATA, *PDNS_ATMA_DATA;
|
|
|
|
|
|
//
|
|
// MS only types -- only hit the wire in MS-MS zone transfer
|
|
//
|
|
|
|
typedef struct
|
|
{
|
|
DWORD dwMappingFlag;
|
|
DWORD dwLookupTimeout;
|
|
DWORD dwCacheTimeout;
|
|
DWORD cWinsServerCount;
|
|
IP_ADDRESS aipWinsServers[1];
|
|
}
|
|
DNS_WINS_DATA, *PDNS_WINS_DATA;
|
|
|
|
typedef struct
|
|
{
|
|
DWORD dwMappingFlag;
|
|
DWORD dwLookupTimeout;
|
|
DWORD dwCacheTimeout;
|
|
DNS_NAME nameResultDomain;
|
|
}
|
|
DNS_WINSR_DATA, *PDNS_WINSR_DATA;
|
|
|
|
|
|
//
|
|
// Length of non-fixed-length data types
|
|
//
|
|
|
|
#define DNS_TEXT_RECORD_LENGTH(StringCount) \
|
|
(sizeof(DWORD) + ((StringCount) * sizeof(PCHAR)))
|
|
|
|
#define DNS_NULL_RECORD_LENGTH(ByteCount) \
|
|
(sizeof(DWORD) + (ByteCount))
|
|
|
|
#define DNS_WKS_RECORD_LENGTH(ByteCount) \
|
|
(sizeof(DNS_WKS_DATA) + (ByteCount-1))
|
|
|
|
#define DNS_WINS_RECORD_LENGTH(IpCount) \
|
|
(sizeof(DNS_WINS_DATA) + ((IpCount-1) * sizeof(IP_ADDRESS)))
|
|
|
|
|
|
//
|
|
// Record flags
|
|
//
|
|
|
|
typedef struct _DnsRecordFlags
|
|
{
|
|
DWORD Section : 2;
|
|
DWORD Delete : 1;
|
|
DWORD Unused : 5;
|
|
|
|
DWORD Unused2 : 4;
|
|
DWORD FreeData : 1;
|
|
DWORD FreeOwner : 1;
|
|
DWORD Unicode : 1;
|
|
DWORD Multiple : 1;
|
|
|
|
DWORD Reserved : 16;
|
|
}
|
|
DNSREC_FLAGS;
|
|
|
|
|
|
//
|
|
// Record flags as bit flags
|
|
// These may be or'd together to set the fields
|
|
//
|
|
|
|
// RR Section in packet
|
|
|
|
#define DNSREC_SECTION (0x00000003)
|
|
|
|
#define DNSREC_QUESTION (0x00000000)
|
|
#define DNSREC_ANSWER (0x00000001)
|
|
#define DNSREC_AUTHORITY (0x00000002)
|
|
#define DNSREC_ADDITIONAL (0x00000003)
|
|
|
|
// RR Section in packet (update)
|
|
|
|
#define DNSREC_ZONE (0x00000000)
|
|
#define DNSREC_PREREQ (0x00000001)
|
|
#define DNSREC_UPDATE (0x00000002)
|
|
|
|
// Delete RR (update) or No-exist (prerequisite)
|
|
|
|
#define DNSREC_DELETE (0x00000004)
|
|
#define DNSREC_NOEXIST (0x00000004)
|
|
|
|
// Owner name is allocated and can be freed with record cleanup
|
|
|
|
#define DNSREC_FREEOWNER (0x00002000)
|
|
|
|
// UNICODE names in record
|
|
|
|
#define DNSREC_UNICODE (0x00004000)
|
|
|
|
// Multiple RR in this record buffer
|
|
// This optimization may be used with fixed types only
|
|
|
|
#define DNSREC_MULTIPLE (0x00008000)
|
|
|
|
|
|
//
|
|
// Record \ RR set structure
|
|
//
|
|
// Note: The dwReserved flag serves to insure that the substructures
|
|
// start on 64-bit boundaries. Since adding the LONGLONG to
|
|
// TSIG structure the compiler wants to start them there anyway
|
|
// (to 64-align). This insures that no matter what data fields
|
|
// are present we are properly 64-aligned.
|
|
//
|
|
// Do NOT pack this structure, as the substructures to be 64-aligned
|
|
// for Win64.
|
|
//
|
|
|
|
typedef struct _DnsRecord
|
|
{
|
|
struct _DnsRecord * pNext;
|
|
DNS_NAME nameOwner;
|
|
WORD wType;
|
|
WORD wDataLength;
|
|
union
|
|
{
|
|
DWORD W; // flags as dword
|
|
DNSREC_FLAGS S; // flags as structure
|
|
|
|
} Flags;
|
|
|
|
DWORD dwTtl;
|
|
DWORD dwReserved;
|
|
union
|
|
{
|
|
DNS_A_DATA A;
|
|
DNS_SOA_DATA SOA, Soa;
|
|
DNS_PTR_DATA PTR, Ptr,
|
|
NS, Ns,
|
|
CNAME, Cname,
|
|
MB, Mb,
|
|
MD, Md,
|
|
MF, Mf,
|
|
MG, Mg,
|
|
MR, Mr;
|
|
DNS_MINFO_DATA MINFO, Minfo,
|
|
RP, Rp;
|
|
DNS_MX_DATA MX, Mx,
|
|
AFSDB, Afsdb,
|
|
RT, Rt;
|
|
DNS_TXT_DATA HINFO, Hinfo,
|
|
ISDN, Isdn,
|
|
TXT, Txt,
|
|
X25;
|
|
DNS_NULL_DATA Null;
|
|
DNS_WKS_DATA WKS, Wks;
|
|
DNS_AAAA_DATA AAAA;
|
|
DNS_SRV_DATA SRV, Srv;
|
|
DNS_TKEY_DATA TKEY, Tkey;
|
|
DNS_TSIG_DATA TSIG, Tsig;
|
|
DNS_ATMA_DATA ATMA, Atma;
|
|
DNS_WINS_DATA WINS, Wins;
|
|
DNS_WINSR_DATA WINSR, WinsR, NBSTAT, Nbstat;
|
|
|
|
} Data;
|
|
}
|
|
DNS_RECORD, *PDNS_RECORD;
|
|
|
|
#endif // End of old DNS_RECORD definitions
|
|
|
|
|
|
#define DNS_RECORD_FIXED_SIZE FIELD_OFFSET( DNS_RECORD, Data )
|
|
#define SIZEOF_DNS_RECORD_HEADER DNS_RECORD_FIXED_SIZE
|
|
|
|
|
|
|
|
//
|
|
// Resource record set building
|
|
//
|
|
// pFirst points to first record in list.
|
|
// pLast points to last record in list.
|
|
//
|
|
|
|
typedef struct _DnsRRSet
|
|
{
|
|
PDNS_RECORD pFirstRR;
|
|
PDNS_RECORD pLastRR;
|
|
}
|
|
DNS_RRSET, *PDNS_RRSET;
|
|
|
|
|
|
//
|
|
// To init pFirst is NULL.
|
|
// But pLast points at the location of the pFirst pointer -- essentially
|
|
// treating the pFirst ptr as a DNS_RECORD. (It is a DNS_RECORD with
|
|
// only a pNext field, but that's the only part we use.)
|
|
//
|
|
// Then when the first record is added to the list, the pNext field of
|
|
// this dummy record (which corresponds to pFirst's value) is set to
|
|
// point at the first record. So pFirst then properly points at the
|
|
// first record.
|
|
//
|
|
// (This works only because pNext is the first field in a
|
|
// DNS_RECORD structure and hence casting a PDNS_RECORD ptr to
|
|
// PDNS_RECORD* and dereferencing yields its pNext field)
|
|
//
|
|
|
|
#define DNS_RRSET_INIT( rrset ) \
|
|
{ \
|
|
PDNS_RRSET _prrset = &(rrset); \
|
|
_prrset->pFirstRR = NULL; \
|
|
_prrset->pLastRR = (PDNS_RECORD) &_prrset->pFirstRR; \
|
|
}
|
|
|
|
#define DNS_RRSET_ADD( rrset, pnewRR ) \
|
|
{ \
|
|
PDNS_RRSET _prrset = &(rrset); \
|
|
PDNS_RECORD _prrnew = (pnewRR); \
|
|
_prrset->pLastRR->pNext = _prrnew; \
|
|
_prrset->pLastRR = _prrnew; \
|
|
}
|
|
|
|
|
|
//
|
|
// Record building (rralloc.c)
|
|
//
|
|
|
|
PDNS_RECORD
|
|
WINAPI
|
|
DnsAllocateRecord(
|
|
IN WORD wBufferLength
|
|
);
|
|
|
|
VOID
|
|
WINAPI
|
|
DnsRecordListFree(
|
|
IN OUT PDNS_RECORD pRecord,
|
|
IN BOOL fFreeOwner
|
|
);
|
|
|
|
#define DnsFreeRRSet( pRRSet, fFreeOwner ) \
|
|
DnsRecordListFree( (pRRSet), (fFreeOwner) )
|
|
|
|
|
|
PDNS_RECORD
|
|
DnsRecordSetDetach(
|
|
IN OUT PDNS_RECORD pRR
|
|
);
|
|
|
|
PDNS_RECORD
|
|
DnsCreatePtrRecord(
|
|
IN IP_ADDRESS ipAddress,
|
|
IN DNS_NAME pszHostName,
|
|
IN BOOL fUnicodeName
|
|
);
|
|
|
|
|
|
//
|
|
// Record build from data strings (rrbuild.c)
|
|
//
|
|
|
|
PDNS_RECORD
|
|
DnsRecordBuild(
|
|
IN OUT PDNS_RRSET pRRSet,
|
|
IN LPSTR pszOwner,
|
|
IN WORD wType,
|
|
IN BOOL fAdd,
|
|
IN UCHAR Section,
|
|
IN INT Argc,
|
|
IN PCHAR * Argv
|
|
);
|
|
|
|
PDNS_RECORD
|
|
DnsRecordBuild_UTF8(
|
|
IN OUT PDNS_RRSET pRRSet,
|
|
IN LPSTR pszOwner,
|
|
IN WORD wType,
|
|
IN BOOL fAdd,
|
|
IN UCHAR Section,
|
|
IN INT Argc,
|
|
IN PCHAR * Argv
|
|
);
|
|
|
|
PDNS_RECORD
|
|
DnsRecordBuild_W(
|
|
IN OUT PDNS_RRSET pRRSet,
|
|
IN LPWSTR pszOwner,
|
|
IN WORD wType,
|
|
IN BOOL fAdd,
|
|
IN UCHAR Section,
|
|
IN INT Argc,
|
|
IN PWCHAR * Argv
|
|
);
|
|
|
|
|
|
//
|
|
// Record set manipulation
|
|
//
|
|
|
|
//
|
|
// Record Compare
|
|
//
|
|
// Note: these routines will NOT do proper unicode compare, unless
|
|
// records have the fUnicode flag set. Both input record lists
|
|
// must be either ANSI or UNICODE, but not one of each.
|
|
//
|
|
|
|
BOOL
|
|
WINAPI
|
|
DnsRecordCompare(
|
|
IN PDNS_RECORD pRecord1,
|
|
IN PDNS_RECORD pRecord2
|
|
);
|
|
|
|
BOOL
|
|
WINAPI
|
|
DnsRecordSetCompare(
|
|
IN OUT PDNS_RECORD pRR1,
|
|
IN OUT PDNS_RECORD pRR2,
|
|
OUT PDNS_RECORD * ppDiff1,
|
|
OUT PDNS_RECORD * ppDiff2
|
|
);
|
|
|
|
|
|
//
|
|
// DNS Name compare
|
|
//
|
|
|
|
BOOL
|
|
WINAPI
|
|
DnsNameCompare_A(
|
|
IN LPSTR pName1,
|
|
IN LPSTR pName2
|
|
);
|
|
|
|
BOOL
|
|
WINAPI
|
|
DnsNameCompare_W(
|
|
IN LPWSTR pName1,
|
|
IN LPWSTR pName2
|
|
);
|
|
|
|
//
|
|
// Record Copy
|
|
// Record copy functions also do conversion between character sets.
|
|
//
|
|
// Note, it might be advisable to directly expose non-Ex copy
|
|
// functions _W, _A for record and set, to avoid exposing the
|
|
// conversion enum.
|
|
//
|
|
|
|
typedef enum _DNS_CHARSET
|
|
{
|
|
DnsCharSetUnknown,
|
|
DnsCharSetUnicode,
|
|
DnsCharSetUtf8,
|
|
DnsCharSetAnsi,
|
|
}
|
|
DNS_CHARSET;
|
|
|
|
|
|
PDNS_RECORD
|
|
WINAPI
|
|
DnsRecordCopyEx(
|
|
IN PDNS_RECORD pRecord,
|
|
IN DNS_CHARSET CharSetIn,
|
|
IN DNS_CHARSET CharSetOut
|
|
);
|
|
|
|
PDNS_RECORD
|
|
WINAPI
|
|
DnsRecordSetCopyEx(
|
|
IN PDNS_RECORD pRecordSet,
|
|
IN DNS_CHARSET CharSetIn,
|
|
IN DNS_CHARSET CharSetOut
|
|
);
|
|
|
|
#ifdef UNICODE
|
|
#define DnsRecordCopy(pRR) \
|
|
DnsRecordCopyEx( (pRR), DnsCharSetUnicode, DnsCharSetUnicode )
|
|
#define DnsRecordSetCopy(pRR) \
|
|
DnsRecordSetCopyEx( (pRR), DnsCharSetUnicode, DnsCharSetUnicode )
|
|
#else
|
|
#define DnsRecordCopy(pRR) \
|
|
DnsRecordCopyEx( (pRR), DnsCharSetAnsi, DnsCharSetAnsi )
|
|
#define DnsRecordSetCopy(pRR) \
|
|
DnsRecordSetCopyEx( (pRR), DnsCharSetAnsi, DnsCharSetAnsi )
|
|
#endif
|
|
|
|
|
|
#if 0
|
|
PDNS_RECORD
|
|
WINAPI
|
|
DnsRecordCopy(
|
|
IN PDNS_RECORD pRecord,
|
|
IN BOOL fUnicodeIn
|
|
);
|
|
|
|
PDNS_RECORD
|
|
DnsRecordSetCopy(
|
|
IN PDNS_RECORD pRR,
|
|
IN BOOL fUnicodeIn
|
|
);
|
|
|
|
PDNS_RECORD
|
|
WINAPI
|
|
DnsRecordCopy_W(
|
|
IN PDNS_RECORD pRecord
|
|
);
|
|
|
|
PDNS_RECORD
|
|
WINAPI
|
|
DnsRecordSetCopy_W(
|
|
IN PDNS_RECORD pRRSet
|
|
);
|
|
|
|
#endif
|
|
|
|
|
|
//
|
|
// Routines to copy and convert UNICODE records to other string type records
|
|
//
|
|
|
|
PDNS_RECORD
|
|
WINAPI
|
|
DnsCopyUnicodeRecordToUnicodeRecord(
|
|
IN PDNS_RECORD pRecord
|
|
);
|
|
|
|
PDNS_RECORD
|
|
WINAPI
|
|
DnsCopyUnicodeRecordToUtf8Record(
|
|
IN PDNS_RECORD pRecord
|
|
);
|
|
|
|
PDNS_RECORD
|
|
WINAPI
|
|
DnsCopyUnicodeRecordToAnsiRecord(
|
|
IN PDNS_RECORD pRecord
|
|
);
|
|
|
|
PDNS_RECORD
|
|
DnsCopyUnicodeRRSetToUnicodeRRSet(
|
|
IN PDNS_RECORD pRR
|
|
);
|
|
|
|
PDNS_RECORD
|
|
DnsCopyUnicodeRRSetToUtf8RRSet(
|
|
IN PDNS_RECORD pRR
|
|
);
|
|
|
|
PDNS_RECORD
|
|
DnsCopyUnicodeRRSetToAnsiRRSet(
|
|
IN PDNS_RECORD pRR
|
|
);
|
|
|
|
|
|
//
|
|
// DNS Update API
|
|
//
|
|
// NOTE:
|
|
//
|
|
// The DNS update API functions have new names to clearify their use.
|
|
// The new functions for various DNS update operations are:
|
|
//
|
|
// DnsAcquireContextHandle
|
|
// DnsReleaseContextHandle
|
|
// DnsAddRecords
|
|
// DnsAddRecordSet
|
|
// DnsModifyRecords
|
|
// DnsModifyRecordSet
|
|
// DnsRemoveRecords
|
|
// DnsReplaceRecordSet
|
|
// DnsUpdateTest
|
|
// DnsGetLastServerUpdateIP
|
|
//
|
|
// The old functions have been changed to macros so
|
|
// as not to break the build.
|
|
//
|
|
|
|
//
|
|
// Old DNS update function definitions
|
|
//
|
|
// Options for DnsModifyRRSet & DnsRegisterRRSet
|
|
//
|
|
|
|
//
|
|
// Update flags
|
|
//
|
|
|
|
//
|
|
// Old flags used for DnsModifyRRSet & DnsRegisterRRSet
|
|
//
|
|
#define DNS_UPDATE_UNIQUE 0x00000000
|
|
#define DNS_UPDATE_SHARED 0x00000001
|
|
|
|
//
|
|
// New flags used for:
|
|
// DnsModifyRecords
|
|
// DnsModifyRecordSet
|
|
// DnsAddRecords
|
|
// DnsAddRecordSet
|
|
// DnsRemoveRecords
|
|
// DnsReplaceRecordSet
|
|
//
|
|
|
|
#define DNS_UPDATE_SECURITY_USE_DEFAULT 0x00000000
|
|
#define DNS_UPDATE_SECURITY_OFF 0x00000010
|
|
#define DNS_UPDATE_SECURITY_ON 0x00000020
|
|
#define DNS_UPDATE_SECURITY_ONLY 0x00000100
|
|
#define DNS_UPDATE_CACHE_SECURITY_CONTEXT 0x00000200
|
|
#define DNS_UPDATE_TEST_USE_LOCAL_SYS_ACCT 0x00000400
|
|
#define DNS_UPDATE_FORCE_SECURITY_NEGO 0x00000800
|
|
#define DNS_UPDATE_RESERVED 0xfffff000
|
|
|
|
DNS_STATUS
|
|
WINAPI
|
|
DnsAcquireContextHandle_W(
|
|
IN DWORD CredentialFlags,
|
|
IN PVOID Credentials OPTIONAL, // Actually this will be a
|
|
// PSEC_WINNT_AUTH_IDENTITY_W,
|
|
// calling this a PVOID to avoid
|
|
// having to include rpcdce.h
|
|
OUT HANDLE * ContextHandle
|
|
);
|
|
|
|
DNS_STATUS
|
|
WINAPI
|
|
DnsAcquireContextHandle_A(
|
|
IN DWORD CredentialFlags,
|
|
IN PVOID Credentials OPTIONAL, // Actually this will be a
|
|
// PSEC_WINNT_AUTH_IDENTITY_A,
|
|
// calling this a PVOID to avoid
|
|
// having to include rpcdce.h
|
|
OUT HANDLE * ContextHandle
|
|
);
|
|
|
|
#ifdef UNICODE
|
|
#define DnsAcquireContextHandle DnsAcquireContextHandle_W
|
|
#else
|
|
#define DnsAcquireContextHandle DnsAcquireContextHandle_A
|
|
#endif
|
|
|
|
|
|
VOID
|
|
WINAPI
|
|
DnsReleaseContextHandle(
|
|
IN HANDLE ContextHandle
|
|
);
|
|
|
|
|
|
DNS_STATUS
|
|
WINAPI
|
|
DnsModifyRecords_A(
|
|
IN HANDLE hContextHandle OPTIONAL,
|
|
IN PDNS_RECORD pCurrentSet,
|
|
IN PDNS_RECORD pNewSet,
|
|
IN DWORD fOptions,
|
|
IN PIP_ARRAY aipServers OPTIONAL
|
|
);
|
|
|
|
DNS_STATUS
|
|
WINAPI
|
|
DnsModifyRecords_UTF8(
|
|
IN HANDLE hContextHandle OPTIONAL,
|
|
IN PDNS_RECORD pCurrentSet,
|
|
IN PDNS_RECORD pNewSet,
|
|
IN DWORD fOptions,
|
|
IN PIP_ARRAY aipServers OPTIONAL
|
|
);
|
|
|
|
DNS_STATUS
|
|
WINAPI
|
|
DnsModifyRecords_W(
|
|
IN HANDLE hContextHandle OPTIONAL,
|
|
IN PDNS_RECORD pCurrentSet,
|
|
IN PDNS_RECORD pNewSet,
|
|
IN DWORD fOptions,
|
|
IN PIP_ARRAY aipServers OPTIONAL
|
|
);
|
|
|
|
#ifdef UNICODE
|
|
#define DnsModifyRecords DnsModifyRecords_W
|
|
#else
|
|
#define DnsModifyRecords DnsModifyRecords_A
|
|
#endif
|
|
|
|
|
|
DNS_STATUS
|
|
WINAPI
|
|
DnsModifyRecordSet_A(
|
|
IN HANDLE hContextHandle OPTIONAL,
|
|
IN PDNS_RECORD pCurrentSet,
|
|
IN PDNS_RECORD pNewSet,
|
|
IN DWORD fOptions,
|
|
IN PIP_ARRAY aipServers OPTIONAL
|
|
);
|
|
|
|
DNS_STATUS
|
|
WINAPI
|
|
DnsModifyRecordSet_UTF8(
|
|
IN HANDLE hContextHandle OPTIONAL,
|
|
IN PDNS_RECORD pCurrentSet,
|
|
IN PDNS_RECORD pNewSet,
|
|
IN DWORD fOptions,
|
|
IN PIP_ARRAY aipServers OPTIONAL
|
|
);
|
|
|
|
DNS_STATUS
|
|
WINAPI
|
|
DnsModifyRecordSet_W(
|
|
IN HANDLE hContextHandle OPTIONAL,
|
|
IN PDNS_RECORD pCurrentSet,
|
|
IN PDNS_RECORD pNewSet,
|
|
IN DWORD fOptions,
|
|
IN PIP_ARRAY aipServers OPTIONAL
|
|
);
|
|
|
|
#ifdef UNICODE
|
|
#define DnsModifyRecordSet DnsModifyRecordSet_W
|
|
#else
|
|
#define DnsModifyRecordSet DnsModifyRecordSet_A
|
|
#endif
|
|
|
|
|
|
#define DnsModifyRRSet_A( _pCSet, \
|
|
_pNSet, \
|
|
_Options, \
|
|
_Servers ) \
|
|
( _Options & DNS_UPDATE_SHARED ) ? \
|
|
DnsModifyRecords_A( NULL, \
|
|
( _pCSet ), \
|
|
( _pNSet ), \
|
|
DNS_UPDATE_SECURITY_USE_DEFAULT, \
|
|
( _Servers ) ) \
|
|
: \
|
|
DnsModifyRecordSet_A( NULL, \
|
|
( _pCSet ), \
|
|
( _pNSet ), \
|
|
DNS_UPDATE_SECURITY_USE_DEFAULT, \
|
|
( _Servers ) )
|
|
|
|
#define DnsModifyRRSet_W( _pCSet, \
|
|
_pNSet, \
|
|
_Options, \
|
|
_Servers ) \
|
|
( _Options & DNS_UPDATE_SHARED ) ? \
|
|
DnsModifyRecords_W( NULL, \
|
|
( _pCSet ), \
|
|
( _pNSet ), \
|
|
DNS_UPDATE_SECURITY_USE_DEFAULT, \
|
|
( _Servers ) ) \
|
|
: \
|
|
DnsModifyRecordSet_W( NULL, \
|
|
( _pCSet ), \
|
|
( _pNSet ), \
|
|
DNS_UPDATE_SECURITY_USE_DEFAULT, \
|
|
( _Servers ) )
|
|
|
|
#ifdef UNICODE
|
|
#define DnsModifyRRSet( _pCSet, \
|
|
_pNSet, \
|
|
_Options, \
|
|
_Servers ) \
|
|
( _Options & DNS_UPDATE_SHARED ) ? \
|
|
DnsModifyRecords_W( NULL, \
|
|
( _pCSet ), \
|
|
( _pNSet ), \
|
|
DNS_UPDATE_SECURITY_USE_DEFAULT, \
|
|
( _Servers ) ) \
|
|
: \
|
|
DnsModifyRecordSet_W( NULL, \
|
|
( _pCSet ), \
|
|
( _pNSet ), \
|
|
DNS_UPDATE_SECURITY_USE_DEFAULT, \
|
|
( _Servers ) )
|
|
#else
|
|
#define DnsModifyRRSet( _pCSet, \
|
|
_pNSet, \
|
|
_Options, \
|
|
_Servers ) \
|
|
( _Options & DNS_UPDATE_SHARED ) ? \
|
|
DnsModifyRecords_A( NULL, \
|
|
( _pCSet ), \
|
|
( _pNSet ), \
|
|
DNS_UPDATE_SECURITY_USE_DEFAULT, \
|
|
( _Servers ) ) \
|
|
: \
|
|
DnsModifyRecordSet_A( NULL, \
|
|
( _pCSet ), \
|
|
( _pNSet ), \
|
|
DNS_UPDATE_SECURITY_USE_DEFAULT, \
|
|
( _Servers ) )
|
|
#endif
|
|
|
|
|
|
DNS_STATUS
|
|
WINAPI
|
|
DnsAddRecords_A(
|
|
IN HANDLE hContextHandle OPTIONAL,
|
|
IN PDNS_RECORD pRRSet,
|
|
IN DWORD fOptions,
|
|
IN PIP_ARRAY aipServers OPTIONAL
|
|
);
|
|
|
|
DNS_STATUS
|
|
WINAPI
|
|
DnsAddRecords_UTF8(
|
|
IN HANDLE hContextHandle OPTIONAL,
|
|
IN PDNS_RECORD pRRSet,
|
|
IN DWORD fOptions,
|
|
IN PIP_ARRAY aipServers OPTIONAL
|
|
);
|
|
|
|
DNS_STATUS
|
|
WINAPI
|
|
DnsAddRecords_W(
|
|
IN HANDLE hContextHandle OPTIONAL,
|
|
IN PDNS_RECORD pRRSet,
|
|
IN DWORD fOptions,
|
|
IN PIP_ARRAY aipServers OPTIONAL
|
|
);
|
|
|
|
#ifdef UNICODE
|
|
#define DnsAddRecords DnsAddRecords_W
|
|
#else
|
|
#define DnsAddRecords DnsAddRecords_A
|
|
#endif
|
|
|
|
|
|
DNS_STATUS
|
|
WINAPI
|
|
DnsAddRecordSet_A(
|
|
IN HANDLE hContextHandle OPTIONAL,
|
|
IN PDNS_RECORD pRRSet,
|
|
IN DWORD fOptions,
|
|
IN PIP_ARRAY aipServers OPTIONAL
|
|
);
|
|
|
|
DNS_STATUS
|
|
WINAPI
|
|
DnsAddRecordSet_UTF8(
|
|
IN HANDLE hContextHandle OPTIONAL,
|
|
IN PDNS_RECORD pRRSet,
|
|
IN DWORD fOptions,
|
|
IN PIP_ARRAY aipServers OPTIONAL
|
|
);
|
|
|
|
DNS_STATUS
|
|
WINAPI
|
|
DnsAddRecordSet_W(
|
|
IN HANDLE hContextHandle OPTIONAL,
|
|
IN PDNS_RECORD pRRSet,
|
|
IN DWORD fOptions,
|
|
IN PIP_ARRAY aipServers OPTIONAL
|
|
);
|
|
|
|
#ifdef UNICODE
|
|
#define DnsAddRecordSet DnsAddRecordSet_W
|
|
#else
|
|
#define DnsAddRecordSet DnsAddRecordSet_A
|
|
#endif
|
|
|
|
|
|
#define DnsRegisterRRSet_A( _pRSet, \
|
|
_Options, \
|
|
_Servers ) \
|
|
( _Options & DNS_UPDATE_SHARED ) ? \
|
|
DnsAddRecords_A( NULL, \
|
|
( _pRSet ), \
|
|
DNS_UPDATE_SECURITY_USE_DEFAULT, \
|
|
( _Servers ) ) \
|
|
: \
|
|
DnsAddRecordSet_A( NULL, \
|
|
( _pRSet ), \
|
|
DNS_UPDATE_SECURITY_USE_DEFAULT, \
|
|
( _Servers ) )
|
|
|
|
#define DnsRegisterRRSet_W( _pRSet, \
|
|
_Options, \
|
|
_Servers ) \
|
|
( _Options & DNS_UPDATE_SHARED ) ? \
|
|
DnsAddRecords_W( NULL, \
|
|
( _pRSet ), \
|
|
DNS_UPDATE_SECURITY_USE_DEFAULT, \
|
|
( _Servers ) ) \
|
|
: \
|
|
DnsAddRecordSet_W( NULL, \
|
|
( _pRSet ), \
|
|
DNS_UPDATE_SECURITY_USE_DEFAULT, \
|
|
( _Servers ) )
|
|
|
|
#ifdef UNICODE
|
|
#define DnsRegisterRRSet( _pRSet, \
|
|
_Options, \
|
|
_Servers ) \
|
|
( _Options & DNS_UPDATE_SHARED ) ? \
|
|
DnsAddRecords_W( NULL, \
|
|
( _pRSet ), \
|
|
DNS_UPDATE_SECURITY_USE_DEFAULT, \
|
|
( _Servers ) ) \
|
|
: \
|
|
DnsAddRecordSet_W( NULL, \
|
|
( _pRSet ), \
|
|
DNS_UPDATE_SECURITY_USE_DEFAULT, \
|
|
( _Servers ) )
|
|
#else
|
|
#define DnsRegisterRRSet( _pRSet, \
|
|
_Options, \
|
|
_Servers ) \
|
|
( _Options & DNS_UPDATE_SHARED ) ? \
|
|
DnsAddRecords_A( NULL, \
|
|
( _pRSet ), \
|
|
DNS_UPDATE_SECURITY_USE_DEFAULT, \
|
|
( _Servers ) ) \
|
|
: \
|
|
DnsAddRecordSet_A( NULL, \
|
|
( _pRSet ), \
|
|
DNS_UPDATE_SECURITY_USE_DEFAULT, \
|
|
( _Servers ) )
|
|
#endif
|
|
|
|
|
|
DNS_STATUS
|
|
WINAPI
|
|
DnsRemoveRecords_A(
|
|
IN HANDLE hContextHandle OPTIONAL,
|
|
IN PDNS_RECORD pRRSet,
|
|
IN DWORD fOptions,
|
|
IN PIP_ARRAY aipServers OPTIONAL
|
|
);
|
|
|
|
DNS_STATUS
|
|
WINAPI
|
|
DnsRemoveRecords_UTF8(
|
|
IN HANDLE hContextHandle OPTIONAL,
|
|
IN PDNS_RECORD pRRSet,
|
|
IN DWORD fOptions,
|
|
IN PIP_ARRAY aipServers OPTIONAL
|
|
);
|
|
|
|
DNS_STATUS
|
|
WINAPI
|
|
DnsRemoveRecords_W(
|
|
IN HANDLE hContextHandle OPTIONAL,
|
|
IN PDNS_RECORD pRRSet,
|
|
IN DWORD fOptions,
|
|
IN PIP_ARRAY aipServers OPTIONAL
|
|
);
|
|
|
|
#ifdef UNICODE
|
|
#define DnsRemoveRecords DnsRemoveRecords_W
|
|
#else
|
|
#define DnsRemoveRecords DnsRemoveRecords_A
|
|
#endif
|
|
|
|
|
|
#define DnsRemoveRRSet_A( _pRSet, \
|
|
_Servers ) \
|
|
DnsRemoveRecords_A( NULL, \
|
|
( _pRSet ), \
|
|
DNS_UPDATE_SECURITY_USE_DEFAULT, \
|
|
( _Servers ) )
|
|
|
|
#define DnsRemoveRRSet_W( _pRSet, \
|
|
_Servers ) \
|
|
DnsRemoveRecords_W( NULL, \
|
|
( _pRSet ), \
|
|
DNS_UPDATE_SECURITY_USE_DEFAULT, \
|
|
( _Servers ) )
|
|
|
|
#ifdef UNICODE
|
|
#define DnsRemoveRRSet( _pRSet, \
|
|
_Servers ) \
|
|
DnsRemoveRecords_W( NULL, \
|
|
( _pRSet ), \
|
|
DNS_UPDATE_SECURITY_USE_DEFAULT, \
|
|
( _Servers ) )
|
|
#else
|
|
#define DnsRemoveRRSet( _pRSet, \
|
|
_Servers ) \
|
|
DnsRemoveRecords_A( NULL, \
|
|
( _pRSet ), \
|
|
DNS_UPDATE_SECURITY_USE_DEFAULT, \
|
|
( _Servers ) )
|
|
#endif
|
|
|
|
|
|
DNS_STATUS
|
|
WINAPI
|
|
DnsReplaceRecordSet_A(
|
|
IN HANDLE hContextHandle OPTIONAL,
|
|
IN PDNS_RECORD pRRSet,
|
|
IN DWORD fOptions,
|
|
IN PIP_ARRAY aipServers OPTIONAL
|
|
);
|
|
|
|
DNS_STATUS
|
|
WINAPI
|
|
DnsReplaceRecordSet_UTF8(
|
|
IN HANDLE hContextHandle OPTIONAL,
|
|
IN PDNS_RECORD pRRSet,
|
|
IN DWORD fOptions,
|
|
IN PIP_ARRAY aipServers OPTIONAL
|
|
);
|
|
|
|
DNS_STATUS
|
|
WINAPI
|
|
DnsReplaceRecordSet_W(
|
|
IN HANDLE hContextHandle OPTIONAL,
|
|
IN PDNS_RECORD pRRSet,
|
|
IN DWORD fOptions,
|
|
IN PIP_ARRAY aipServers OPTIONAL
|
|
);
|
|
|
|
#ifdef UNICODE
|
|
#define DnsReplaceRecordSet DnsReplaceRecordSet_W
|
|
#else
|
|
#define DnsReplaceRecordSet DnsReplaceRecordSet_A
|
|
#endif
|
|
|
|
|
|
#define DnsReplaceRRSet_A( _pRSet, \
|
|
_Servers ) \
|
|
DnsReplaceRecordSet_A( NULL, \
|
|
( _pRSet ), \
|
|
DNS_UPDATE_SECURITY_USE_DEFAULT, \
|
|
( _Servers ) )
|
|
|
|
#define DnsReplaceRRSet_W( _pRSet, \
|
|
_Servers ) \
|
|
DnsReplaceRecordSet_W( NULL, \
|
|
( _pRSet ), \
|
|
DNS_UPDATE_SECURITY_USE_DEFAULT, \
|
|
( _Servers ) )
|
|
|
|
#ifdef UNICODE
|
|
#define DnsReplaceRRSet( _pRSet, \
|
|
_Servers ) \
|
|
DnsReplaceRecordSet_W( NULL, \
|
|
( _pRSet ), \
|
|
DNS_UPDATE_SECURITY_USE_DEFAULT, \
|
|
( _Servers ) )
|
|
#else
|
|
#define DnsReplaceRRSet( _pRSet, \
|
|
_Servers ) \
|
|
DnsReplaceRecordSet_A( NULL, \
|
|
( _pRSet ), \
|
|
DNS_UPDATE_SECURITY_USE_DEFAULT, \
|
|
( _Servers ) )
|
|
#endif
|
|
|
|
|
|
DNS_STATUS
|
|
WINAPI
|
|
DnsUpdateTest_A(
|
|
IN HANDLE hContextHandle OPTIONAL,
|
|
IN LPSTR pszName,
|
|
IN DWORD fOptions,
|
|
IN PIP_ARRAY aipServers OPTIONAL
|
|
);
|
|
|
|
DNS_STATUS
|
|
WINAPI
|
|
DnsUpdateTest_UTF8(
|
|
IN HANDLE hContextHandle OPTIONAL,
|
|
IN LPSTR pszName,
|
|
IN DWORD fOptions,
|
|
IN PIP_ARRAY aipServers OPTIONAL
|
|
);
|
|
|
|
DNS_STATUS
|
|
WINAPI
|
|
DnsUpdateTest_W(
|
|
IN HANDLE hContextHandle OPTIONAL,
|
|
IN LPWSTR pszName,
|
|
IN DWORD fOptions,
|
|
IN PIP_ARRAY aipServers OPTIONAL
|
|
);
|
|
|
|
#ifdef UNICODE
|
|
#define DnsUpdateTest DnsUpdateTest_W
|
|
#else
|
|
#define DnsUpdateTest DnsUpdateTest_A
|
|
#endif
|
|
|
|
|
|
IP_ADDRESS
|
|
WINAPI
|
|
DnsGetLastServerUpdateIP (
|
|
VOID
|
|
);
|
|
|
|
|
|
|
|
//
|
|
// DNS Query API
|
|
//
|
|
|
|
//
|
|
// Options for DnsQuery
|
|
//
|
|
|
|
#define DNS_QUERY_STANDARD 0x00000000
|
|
#define DNS_QUERY_ACCEPT_PARTIAL_UDP 0x00000001
|
|
#define DNS_QUERY_USE_TCP_ONLY 0x00000002
|
|
#define DNS_QUERY_NO_RECURSION 0x00000004
|
|
#define DNS_QUERY_BYPASS_CACHE 0x00000008
|
|
#define DNS_QUERY_CACHE_ONLY 0x00000010
|
|
#define DNS_QUERY_SOCKET_KEEPALIVE 0x00000100
|
|
#define DNS_QUERY_TREAT_AS_FQDN 0x00001000
|
|
#define DNS_QUERY_ALLOW_EMPTY_AUTH_RESP 0x00010000
|
|
#define DNS_QUERY_RESERVED 0xfff00000
|
|
|
|
#define DNS_QUERY_ACCEPT_TRUNCATED_RESPONSE DNS_QUERY_ACCEPT_PARTIAL_UDP
|
|
|
|
|
|
DNS_STATUS WINAPI
|
|
DnsQuery_A(
|
|
IN LPSTR lpstrName,
|
|
IN WORD wType,
|
|
IN DWORD fOptions,
|
|
IN PIP_ARRAY aipServers OPTIONAL,
|
|
IN OUT PDNS_RECORD * ppQueryResultsSet OPTIONAL,
|
|
IN OUT PVOID * pReserved OPTIONAL
|
|
);
|
|
|
|
DNS_STATUS WINAPI
|
|
DnsQuery_UTF8(
|
|
IN LPSTR lpstrName,
|
|
IN WORD wType,
|
|
IN DWORD fOptions,
|
|
IN PIP_ARRAY aipServers OPTIONAL,
|
|
IN OUT PDNS_RECORD * ppQueryResultsSet OPTIONAL,
|
|
IN OUT PVOID * pReserved OPTIONAL
|
|
);
|
|
|
|
DNS_STATUS WINAPI
|
|
DnsQuery_W(
|
|
IN LPWSTR lpstrName,
|
|
IN WORD wType,
|
|
IN DWORD fOptions,
|
|
IN PIP_ARRAY aipServers OPTIONAL,
|
|
IN OUT PDNS_RECORD * ppQueryResultsSet OPTIONAL,
|
|
IN OUT PVOID * pReserved OPTIONAL
|
|
);
|
|
|
|
#ifdef UNICODE
|
|
#define DnsQuery DnsQuery_W
|
|
#else
|
|
#define DnsQuery DnsQuery_A
|
|
#endif
|
|
|
|
|
|
//
|
|
// Options for DnsCheckNameCollision
|
|
//
|
|
|
|
#define DNS_CHECK_AGAINST_HOST_ANY 0x00000000
|
|
#define DNS_CHECK_AGAINST_HOST_ADDRESS 0x00000001
|
|
#define DNS_CHECK_AGAINST_HOST_DOMAIN_NAME 0x00000002
|
|
|
|
|
|
DNS_STATUS WINAPI
|
|
DnsCheckNameCollision_A (
|
|
IN LPSTR pszName,
|
|
IN DWORD fOptions
|
|
);
|
|
|
|
DNS_STATUS WINAPI
|
|
DnsCheckNameCollision_UTF8 (
|
|
IN LPSTR pszName,
|
|
IN DWORD fOptions
|
|
);
|
|
|
|
DNS_STATUS WINAPI
|
|
DnsCheckNameCollision_W (
|
|
IN LPWSTR pszName,
|
|
IN DWORD fOptions
|
|
);
|
|
|
|
#ifdef UNICODE
|
|
#define DnsDnsCheckNameCollision DnsCheckNameCollision_W
|
|
#else
|
|
#define DnsDnsCheckNameCollision DnsCheckNameCollision_A
|
|
#endif
|
|
|
|
|
|
LPSTR WINAPI
|
|
DnsGetHostName_A(
|
|
VOID
|
|
);
|
|
|
|
LPSTR WINAPI
|
|
DnsGetHostName_UTF8(
|
|
VOID
|
|
);
|
|
|
|
LPWSTR WINAPI
|
|
DnsGetHostName_W(
|
|
VOID
|
|
);
|
|
|
|
#ifdef UNICODE
|
|
#define DnsGetHostName DnsGetHostName_W
|
|
#else
|
|
#define DnsGetHostName DnsGetHostName_A
|
|
#endif
|
|
|
|
|
|
LPSTR WINAPI
|
|
DnsGetPrimaryDomainName_A(
|
|
VOID
|
|
);
|
|
|
|
LPSTR WINAPI
|
|
DnsGetPrimaryDomainName_UTF8(
|
|
VOID
|
|
);
|
|
|
|
LPWSTR WINAPI
|
|
DnsGetPrimaryDomainName_W(
|
|
VOID
|
|
);
|
|
|
|
#ifdef UNICODE
|
|
#define DnsGetPrimaryDomainName DnsGetPrimaryDomainName_W
|
|
#else
|
|
#define DnsGetPrimaryDomainName DnsGetPrimaryDomainName_A
|
|
#endif
|
|
|
|
|
|
|
|
//
|
|
// DNS Update API for DHCP client
|
|
//
|
|
|
|
typedef struct _REGISTER_HOST_ENTRY
|
|
{
|
|
union
|
|
{
|
|
IP_ADDRESS ipAddr;
|
|
IPV6_ADDRESS ipV6Addr;
|
|
} Addr;
|
|
DWORD dwOptions;
|
|
}
|
|
REGISTER_HOST_ENTRY, *PREGISTER_HOST_ENTRY;
|
|
|
|
//
|
|
// Options for above
|
|
//
|
|
|
|
#define REGISTER_HOST_A 0x00000001
|
|
#define REGISTER_HOST_PTR 0x00000002 // Used by DHCP server
|
|
#define REGISTER_HOST_TRANSIENT 0x00000004 // Don't use, use DYNDNS_REG_RAS
|
|
#define REGISTER_HOST_AAAA 0x00000008
|
|
#define REGISTER_HOST_RESERVED 0x80000000 // Not used
|
|
|
|
#define DYNDNS_REG_FWD 0x0
|
|
#define DYNDNS_REG_PTR 0x8
|
|
#define DYNDNS_REG_RAS 0x10
|
|
#define DYNDNS_DEL_ENTRY 0x20
|
|
|
|
|
|
typedef struct _REGISTER_HOST_STATUS
|
|
{
|
|
HANDLE hDoneEvent;
|
|
DWORD dwStatus;
|
|
}
|
|
REGISTER_HOST_STATUS, *PREGISTER_HOST_STATUS;
|
|
|
|
DNS_STATUS
|
|
WINAPI
|
|
DnsAsyncRegisterInit(
|
|
LPSTR lpstrRootRegKey
|
|
);
|
|
|
|
DNS_STATUS
|
|
WINAPI
|
|
DnsAsyncRegisterTerm(
|
|
VOID
|
|
);
|
|
|
|
DNS_STATUS WINAPI
|
|
DnsRemoveRegistrations(
|
|
VOID
|
|
);
|
|
|
|
DNS_STATUS
|
|
WINAPI
|
|
DnsAsyncRegisterHostAddrs_W(
|
|
IN LPWSTR lpstrAdapterName,
|
|
IN LPWSTR lpstrHostName,
|
|
IN PREGISTER_HOST_ENTRY pHostAddrs,
|
|
IN DWORD dwHostAddrCount,
|
|
IN PIP_ADDRESS pipDnsServerList,
|
|
IN DWORD dwDnsServerCount,
|
|
IN LPWSTR lpstrDomainName,
|
|
IN PREGISTER_HOST_STATUS pRegisterStatus,
|
|
IN DWORD dwTTL,
|
|
IN DWORD dwFlags
|
|
);
|
|
|
|
DNS_STATUS
|
|
WINAPI
|
|
DnsAsyncRegisterHostAddrs_UTF8(
|
|
IN LPSTR lpstrAdapterName,
|
|
IN LPSTR lpstrHostName,
|
|
IN PREGISTER_HOST_ENTRY pHostAddrs,
|
|
IN DWORD dwHostAddrCount,
|
|
IN PIP_ADDRESS pipDnsServerList,
|
|
IN DWORD dwDnsServerCount,
|
|
IN LPSTR lpstrDomainName,
|
|
IN PREGISTER_HOST_STATUS pRegisterStatus,
|
|
IN DWORD dwTTL,
|
|
IN DWORD dwFlags
|
|
);
|
|
|
|
DNS_STATUS
|
|
WINAPI
|
|
DnsAsyncRegisterHostAddrs_A(
|
|
IN LPSTR lpstrAdapterName,
|
|
IN LPSTR lpstrHostName,
|
|
IN PREGISTER_HOST_ENTRY pHostAddrs,
|
|
IN DWORD dwHostAddrCount,
|
|
IN PIP_ADDRESS pipDnsServerList,
|
|
IN DWORD dwDnsServerCount,
|
|
IN LPSTR lpstrDomainName,
|
|
IN PREGISTER_HOST_STATUS pRegisterStatus,
|
|
IN DWORD dwTTL,
|
|
IN DWORD dwFlags
|
|
);
|
|
|
|
#ifdef UNICODE
|
|
#define DnsAsyncRegisterHostAddrs DnsAsyncRegisterHostAddrs_W
|
|
#else
|
|
#define DnsAsyncRegisterHostAddrs DnsAsyncRegisterHostAddrs_A
|
|
#endif
|
|
|
|
|
|
//
|
|
// DNS Update API for DHCP server.
|
|
//
|
|
|
|
//
|
|
// Call back function. DHCP Server will pass a function to
|
|
// DnsDhcpRegisterHostName and this will be called on successful
|
|
// or unsuccessful completion of the task
|
|
// If we have a condition like server down/try again later etc we
|
|
// won't respond until we have an authoritative answer.
|
|
//
|
|
|
|
typedef VOID(*DHCP_CALLBACK_FN)(DWORD dwStatus, LPVOID pvData);
|
|
|
|
//
|
|
// Callback return codes
|
|
//
|
|
|
|
#define DNSDHCP_SUCCESS 0x0
|
|
#define DNSDHCP_FWD_FAILED 0x1
|
|
#define DNSDHCP_SUPERCEDED 0x2
|
|
|
|
#define DNSDHCP_FAILURE (DWORD)-1 //reverse failed
|
|
|
|
#define DYNDNS_DELETE_ENTRY 0x1
|
|
#define DYNDNS_ADD_ENTRY 0x2
|
|
#define DYNDNS_REG_FORWARD 0x4
|
|
|
|
DNS_STATUS
|
|
WINAPI
|
|
DnsDhcpSrvRegisterInit(
|
|
VOID
|
|
);
|
|
|
|
DNS_STATUS
|
|
WINAPI
|
|
DnsDhcpSrvRegisterTerm(
|
|
VOID
|
|
);
|
|
|
|
DNS_STATUS
|
|
WINAPI
|
|
DnsDhcpSrvRegisterHostName_A(
|
|
IN REGISTER_HOST_ENTRY HostAddr,
|
|
IN LPSTR pszName,
|
|
IN DWORD dwTTL,
|
|
IN DWORD dwFlags,
|
|
IN DHCP_CALLBACK_FN pfnDhcpCallBack,
|
|
IN PVOID pvData,
|
|
IN PIP_ADDRESS pipDnsServerList OPTIONAL,
|
|
IN DWORD dwDnsServerCount
|
|
);
|
|
|
|
DNS_STATUS
|
|
WINAPI
|
|
DnsDhcpSrvRegisterHostName_UTF8(
|
|
IN REGISTER_HOST_ENTRY HostAddr,
|
|
IN LPSTR pszName,
|
|
IN DWORD dwTTL,
|
|
IN DWORD dwFlags,
|
|
IN DHCP_CALLBACK_FN pfnDhcpCallBack,
|
|
IN PVOID pvData,
|
|
IN PIP_ADDRESS pipDnsServerList OPTIONAL,
|
|
IN DWORD dwDnsServerCount
|
|
);
|
|
|
|
DNS_STATUS
|
|
WINAPI
|
|
DnsDhcpSrvRegisterHostName_W(
|
|
IN REGISTER_HOST_ENTRY HostAddr,
|
|
IN LPWSTR pszName,
|
|
IN DWORD dwTTL,
|
|
IN DWORD dwFlags,
|
|
IN DHCP_CALLBACK_FN pfnDhcpCallBack,
|
|
IN PVOID pvData,
|
|
IN PIP_ADDRESS pipDnsServerList OPTIONAL,
|
|
IN DWORD dwDnsServerCount
|
|
);
|
|
|
|
#define DnsDhcpSrvRegisterHostName DnsDhcpSrvRegisterHostName_A
|
|
|
|
#define RETRY_TIME_SERVER_FAILURE 5*60 // 5 minutes
|
|
#define RETRY_TIME_TRY_AGAIN_LATER 5*60 // 5 minutes
|
|
#define RETRY_TIME_TIMEOUT 5*60 // 5 minutes
|
|
|
|
#define RETRY_TIME_MAX 10*60 // back off to 10 mins if
|
|
// repeated failures occur
|
|
|
|
|
|
|
|
|
|
//
|
|
// Memory allocation
|
|
//
|
|
// Many dnsapi.dll routines allocate memory.
|
|
// This memory allocation defaults to routines that use:
|
|
// - LocalAlloc,
|
|
// - LocalReAlloc,
|
|
// - LocalFree.
|
|
// If you desire alternative memory allocation mechanisms, use this
|
|
// function to override the DNS API defaults. All memory returned by dnsapi.dll
|
|
// can then be freed with the specified free function.
|
|
//
|
|
|
|
typedef PVOID (* DNS_ALLOC_FUNCTION)();
|
|
typedef PVOID (* DNS_REALLOC_FUNCTION)();
|
|
typedef VOID (* DNS_FREE_FUNCTION)();
|
|
|
|
VOID
|
|
DnsApiHeapReset(
|
|
IN DNS_ALLOC_FUNCTION pAlloc,
|
|
IN DNS_REALLOC_FUNCTION pRealloc,
|
|
IN DNS_FREE_FUNCTION pFree
|
|
);
|
|
|
|
//
|
|
// Modules using DNSAPI memory should use these routines if
|
|
// they are capable of being called by a process that resets
|
|
// the dnsapi.dll heap. (Example: the DNS server.)
|
|
//
|
|
|
|
PVOID
|
|
DnsApiAlloc(
|
|
IN INT iSize
|
|
);
|
|
|
|
PVOID
|
|
DnsApiRealloc(
|
|
IN OUT PVOID pMem,
|
|
IN INT iSize
|
|
);
|
|
|
|
VOID
|
|
DnsApiFree(
|
|
IN OUT PVOID pMem
|
|
);
|
|
|
|
|
|
//
|
|
// String utilities (string.c)
|
|
//
|
|
// Note some of these require memory allocation, see note
|
|
// on memory allocation below.
|
|
//
|
|
|
|
#define DNS_ALLOW_RFC_NAMES_ONLY (0)
|
|
#define DNS_ALLOW_NONRFC_NAMES (0x00000001)
|
|
#define DNS_ALLOW_MULTIBYTE_NAMES (0x00000002)
|
|
#define DNS_ALLOW_ALL_NAMES (0x00000003)
|
|
|
|
|
|
LPSTR
|
|
DnsCreateStringCopy(
|
|
IN PCHAR pchString,
|
|
IN DWORD cchString
|
|
);
|
|
|
|
DWORD
|
|
DnsGetBufferLengthForStringCopy(
|
|
IN PCHAR pchString,
|
|
IN DWORD cchString,
|
|
IN BOOL fUnicodeIn,
|
|
IN BOOL fUnicodeOut
|
|
);
|
|
|
|
PVOID
|
|
DnsCopyStringEx(
|
|
OUT PBYTE pBuffer,
|
|
IN PCHAR pchString,
|
|
IN DWORD cchString,
|
|
IN BOOL fUnicodeIn,
|
|
IN BOOL fUnicodeOut
|
|
);
|
|
|
|
PVOID
|
|
DnsStringCopyAllocateEx(
|
|
IN PCHAR pchString,
|
|
IN DWORD cchString,
|
|
IN BOOL fUnicodeIn,
|
|
IN BOOL fUnicodeOut
|
|
);
|
|
|
|
PCHAR
|
|
DnsWriteReverseNameStringForIpAddress(
|
|
OUT PCHAR pBuffer,
|
|
IN IP_ADDRESS ipAddress
|
|
);
|
|
|
|
PCHAR
|
|
DnsCreateReverseNameStringForIpAddress(
|
|
IN IP_ADDRESS ipAddress
|
|
);
|
|
|
|
|
|
|
|
//
|
|
// Name validation
|
|
//
|
|
|
|
typedef enum _DNS_NAME_FORMAT
|
|
{
|
|
DnsNameDomain,
|
|
DnsNameDomainLabel,
|
|
DnsNameHostnameFull,
|
|
DnsNameHostnameLabel,
|
|
DnsNameWildcard,
|
|
DnsNameSrvRecord
|
|
}
|
|
DNS_NAME_FORMAT;
|
|
|
|
|
|
DNS_STATUS
|
|
DnsValidateName_UTF8(
|
|
IN LPCSTR pszName,
|
|
IN DNS_NAME_FORMAT Format
|
|
);
|
|
|
|
DNS_STATUS
|
|
DnsValidateName_W(
|
|
IN LPCWSTR pwszName,
|
|
IN DNS_NAME_FORMAT Format
|
|
);
|
|
|
|
DNS_STATUS
|
|
DnsValidateName_A(
|
|
IN LPCSTR pszName,
|
|
IN DNS_NAME_FORMAT Format
|
|
);
|
|
|
|
#ifdef UNICODE
|
|
#define DnsValidateName(p,f) DnsValidateName_W( (p), (f) )
|
|
#else
|
|
#define DnsValidateName(p,f) DnsValidateName_A( (p), (f) )
|
|
#endif
|
|
|
|
|
|
//
|
|
// Macro away old routines
|
|
//
|
|
|
|
#define DnsValidateDnsName_UTF8(pname) \
|
|
DnsValidateName_UTF8( (pname), DnsNameDomain )
|
|
|
|
#define DnsValidateDnsName_W(pname) \
|
|
DnsValidateName_W( (pname), DnsNameDomain )
|
|
|
|
|
|
//
|
|
// Relational name compare result
|
|
//
|
|
typedef enum
|
|
{
|
|
DNS_RELATE_NEQ, // NOT EQUAL: name's in different name space.
|
|
DNS_RELATE_EQL, // EQUAL: name's are identical DNS names
|
|
DNS_RELATE_LGT, // LEFT GREATER THAN: left name is parent (contains) to right name
|
|
DNS_RELATE_RGT, // RIGHT GREATER THAN: right name is parent (contains) to left name
|
|
DNS_RELATE_INVALID // INVALID STATE: accompanied with DNS_STATUS return code
|
|
} DNS_RELATE_STATUS, *PDNS_RELATE_STATUS;
|
|
|
|
DNS_STATUS
|
|
DnsRelationalCompare_UTF8(
|
|
IN LPCSTR pszLeftName,
|
|
IN LPCSTR pszRightName,
|
|
IN DWORD dwReserved,
|
|
IN OUT DNS_RELATE_STATUS *pRelation
|
|
);
|
|
|
|
DNS_STATUS
|
|
DnsRelationalCompare_W(
|
|
IN LPCWSTR pszLeftName,
|
|
IN LPCWSTR pszRightName,
|
|
IN DWORD dwReserved,
|
|
IN OUT DNS_RELATE_STATUS *pRelation
|
|
);
|
|
|
|
DNS_STATUS
|
|
DnsValidateDnsString_UTF8(
|
|
IN LPCSTR pszName
|
|
);
|
|
|
|
DNS_STATUS
|
|
DnsValidateDnsString_W(
|
|
IN LPCWSTR pszName
|
|
);
|
|
|
|
LPSTR
|
|
DnsCreateStandardDnsNameCopy(
|
|
IN PCHAR pchName,
|
|
IN DWORD cchName,
|
|
IN DWORD dwFlag
|
|
);
|
|
|
|
DWORD
|
|
DnsDowncaseDnsNameLabel(
|
|
OUT PCHAR pchResult,
|
|
IN PCHAR pchLabel,
|
|
IN DWORD cchLabel,
|
|
IN DWORD dwFlags
|
|
);
|
|
|
|
DWORD
|
|
_fastcall
|
|
DnsUnicodeToUtf8(
|
|
IN PWCHAR pwUnicode,
|
|
IN DWORD cchUnicode,
|
|
OUT PCHAR pchResult,
|
|
IN DWORD cchResult
|
|
);
|
|
|
|
DWORD
|
|
_fastcall
|
|
DnsUtf8ToUnicode(
|
|
IN PCHAR pchUtf8,
|
|
IN DWORD cchUtf8,
|
|
OUT PWCHAR pwResult,
|
|
IN DWORD cwResult
|
|
);
|
|
|
|
DNS_STATUS
|
|
DnsValidateUtf8Byte(
|
|
IN BYTE chUtf8,
|
|
IN OUT PDWORD pdwTrailCount
|
|
);
|
|
|
|
|
|
//
|
|
// Routines for NT services to call to get a Service Control Manager
|
|
// control message, (i.e. SERVICE_CONTROL_PARAMCHANGE - 0x00000006, etc.), in
|
|
// the event of a PnP change that affects DNS related data.
|
|
//
|
|
|
|
BOOL WINAPI
|
|
DnsServiceNotificationRegister_W (
|
|
IN LPWSTR pszServiceName,
|
|
IN DWORD dwControl
|
|
);
|
|
|
|
BOOL WINAPI
|
|
DnsServiceNotificationRegister_UTF8 (
|
|
IN LPSTR pszServiceName,
|
|
IN DWORD dwControl
|
|
);
|
|
|
|
BOOL WINAPI
|
|
DnsServiceNotificationRegister_A (
|
|
IN LPSTR pszServiceName,
|
|
IN DWORD dwControl
|
|
);
|
|
|
|
#ifdef UNICODE
|
|
#define DnsServiceNotificationRegister DnsServiceNotificationRegister_W
|
|
#else
|
|
#define DnsServiceNotificationRegister DnsServiceNotificationRegister_A
|
|
#endif
|
|
|
|
BOOL WINAPI
|
|
DnsServiceNotificationDeregister_W (
|
|
IN LPWSTR pszServiceName
|
|
);
|
|
|
|
BOOL WINAPI
|
|
DnsServiceNotificationDeregister_UTF8 (
|
|
IN LPSTR pszServiceName
|
|
);
|
|
|
|
BOOL WINAPI
|
|
DnsServiceNotificationDeregister_A (
|
|
IN LPSTR pszServiceName
|
|
);
|
|
|
|
#ifdef UNICODE
|
|
#define DnsServiceNotificationDeregister DnsServiceNotificationDeregister_W
|
|
#else
|
|
#define DnsServiceNotificationDeregister DnsServiceNotificationDeregister_A
|
|
#endif
|
|
|
|
|
|
//
|
|
// Routines to clear all cached entries in the DNS Resolver Cache, this is
|
|
// called by ipconfig /flushdns, and add record sets to the cache.
|
|
//
|
|
|
|
BOOL WINAPI
|
|
DnsFlushResolverCache (
|
|
VOID
|
|
);
|
|
|
|
BOOL WINAPI
|
|
DnsFlushResolverCacheEntry_W (
|
|
IN LPWSTR pszName
|
|
);
|
|
|
|
BOOL WINAPI
|
|
DnsFlushResolverCacheEntry_UTF8 (
|
|
IN LPSTR pszName
|
|
);
|
|
|
|
BOOL WINAPI
|
|
DnsFlushResolverCacheEntry_A (
|
|
IN LPSTR pszName
|
|
);
|
|
|
|
#ifdef UNICODE
|
|
#define DnsFlushResolverCacheEntry DnsFlushResolverCacheEntry_W
|
|
#else
|
|
#define DnsFlushResolverCacheEntry DnsFlushResolverCacheEntry_A
|
|
#endif
|
|
|
|
|
|
DNS_STATUS WINAPI
|
|
DnsCacheRecordSet_W(
|
|
IN LPWSTR lpstrName,
|
|
IN WORD wType,
|
|
IN DWORD fOptions,
|
|
IN OUT PDNS_RECORD pRRSet
|
|
);
|
|
|
|
|
|
//
|
|
// Routines to enable or disable B-Node resolver service listening thread
|
|
//
|
|
|
|
VOID WINAPI
|
|
DnsEnableBNodeResolverThread (
|
|
VOID
|
|
);
|
|
|
|
VOID WINAPI
|
|
DnsDisableBNodeResolverThread (
|
|
VOID
|
|
);
|
|
|
|
|
|
//
|
|
// Routines to enable or disable dynamic DNS registrations on local machine
|
|
//
|
|
|
|
VOID WINAPI
|
|
DnsEnableDynamicRegistration (
|
|
LPWSTR szAdapterName OPTIONAL // If NULL, enables DDNS in general
|
|
);
|
|
|
|
VOID WINAPI
|
|
DnsDisableDynamicRegistration (
|
|
LPWSTR szAdapterName OPTIONAL // If NULL, disables DDNS in general
|
|
);
|
|
|
|
BOOL
|
|
DnsIsDynamicRegistrationEnabled (
|
|
LPWSTR szAdapterName OPTIONAL // If NULL, tells whether system has
|
|
); // DDNS enabled.
|
|
|
|
|
|
//
|
|
// Routines to enable or disable dynamic DNS registration of a given
|
|
// adapter's domain name on the local machine
|
|
//
|
|
|
|
VOID WINAPI
|
|
DnsEnableAdapterDomainNameRegistration (
|
|
LPWSTR szAdapterName
|
|
);
|
|
|
|
VOID WINAPI
|
|
DnsDisableAdapterDomainNameRegistration (
|
|
LPWSTR szAdapterName
|
|
);
|
|
|
|
BOOL
|
|
DnsIsAdapterDomainNameRegistrationEnabled (
|
|
LPWSTR szAdapterName
|
|
);
|
|
|
|
|
|
//
|
|
// Routines to write a DNS Query packet request question in a buffer and
|
|
// convert response packet buffer to DNS_RECORD structure list.
|
|
//
|
|
|
|
typedef struct _DNS_MESSAGE_BUFFER
|
|
{
|
|
DNS_HEADER MessageHead;
|
|
CHAR MessageBody[1];
|
|
}
|
|
DNS_MESSAGE_BUFFER, *PDNS_MESSAGE_BUFFER;
|
|
|
|
BOOL WINAPI
|
|
DnsWriteQuestionToBuffer_W (
|
|
IN OUT PDNS_MESSAGE_BUFFER pDnsBuffer,
|
|
IN OUT LPDWORD pdwBufferSize,
|
|
IN LPWSTR pszName,
|
|
IN WORD wType,
|
|
IN WORD Xid,
|
|
IN BOOL fRecursionDesired
|
|
);
|
|
|
|
BOOL WINAPI
|
|
DnsWriteQuestionToBuffer_UTF8 (
|
|
IN OUT PDNS_MESSAGE_BUFFER pDnsBuffer,
|
|
IN OUT LPDWORD pdwBufferSize,
|
|
IN LPSTR pszName,
|
|
IN WORD wType,
|
|
IN WORD Xid,
|
|
IN BOOL fRecursionDesired
|
|
);
|
|
|
|
|
|
DNS_STATUS WINAPI
|
|
DnsExtractRecordsFromMessage_W (
|
|
IN PDNS_MESSAGE_BUFFER pDnsBuffer,
|
|
IN WORD wMessageLength,
|
|
OUT PDNS_RECORD * ppRecord
|
|
);
|
|
|
|
DNS_STATUS WINAPI
|
|
DnsExtractRecordsFromMessage_UTF8 (
|
|
IN PDNS_MESSAGE_BUFFER pDnsBuffer,
|
|
IN WORD wMessageLength,
|
|
OUT PDNS_RECORD * ppRecord
|
|
);
|
|
|
|
|
|
//
|
|
// Routine to read the contents of the DNS Resolver Cache. The resulting
|
|
// table contains a list of record names and types stored in the cache.
|
|
// Each of these name/type records can be queried with DnsQuery with the
|
|
// option DNS_QUERY_CACHE_ONLY.
|
|
//
|
|
|
|
typedef struct _DNS_CACHE_TABLE_
|
|
{
|
|
struct _DNS_CACHE_TABLE_ * pNext;
|
|
LPWSTR Name;
|
|
WORD Type1;
|
|
WORD Type2;
|
|
WORD Type3;
|
|
}
|
|
DNS_CACHE_TABLE, *PDNS_CACHE_TABLE;
|
|
|
|
BOOL WINAPI
|
|
DnsGetCacheDataTable (
|
|
OUT PDNS_CACHE_TABLE * pTable
|
|
);
|
|
|
|
|
|
//
|
|
// Backward compatibility
|
|
//
|
|
// Previously exposed functions now macroed to new functions.
|
|
// Eventually need to clean this stuff out of build or
|
|
// separate these defs from public headers
|
|
//
|
|
|
|
#define DNSBACKCOMPAT 1
|
|
|
|
#ifdef DNSBACKCOMPAT
|
|
#ifdef UNICODE
|
|
#define DnsCompareName(p1,p2) DnsNameCompare_W( (p1), (p2) )
|
|
#else
|
|
#define DnsCompareName(p1,p2) DnsNameCompare( (p1), (p2) )
|
|
#endif
|
|
|
|
#define DnsCompareName_W(p1,p2) DnsNameCompare_W( (p1), (p2) )
|
|
#define DnsCompareName_A(p1,p2) DnsNameCompare( (p1), (p2) )
|
|
|
|
#ifdef UNICODE
|
|
#define DnsCopyRR(pRR) DnsRecordCopy( pRR, TRUE )
|
|
#else
|
|
#define DnsCopyRR(pRR) DnsRecordCopy( pRR, FALSE )
|
|
#endif
|
|
|
|
#ifdef UNICODE
|
|
#define DnsCopyRRSet(pRRSet) DnsRecordSetCopy( pRRSet, TRUE )
|
|
#else
|
|
#define DnsCopyRRSet(pRRSet) DnsRecordSetCopy( pRRSet, FALSE )
|
|
#endif
|
|
|
|
|
|
// Async registration only from DHCP client.
|
|
// Once it is cleanedup, these can be deleted.
|
|
|
|
#define DnsMHAsyncRegisterInit(a) DnsAsyncRegisterInit(a)
|
|
#define DnsMHAsyncRegisterTerm() DnsAsyncRegisterTerm()
|
|
#define DnsMHRemoveRegistrations() DnsRemoveRegistrations()
|
|
|
|
#define DnsMHAsyncRegisterHostAddrs_A(a,b,c,d,e,f,g,h,i,j) \
|
|
DnsAsyncRegisterHostAddrs_A(a,b,c,d,e,f,g,h,i,j)
|
|
|
|
#define DnsMHAsyncRegisterHostAddrs_W(a,b,c,d,e,f,g,h,i,j) \
|
|
DnsAsyncRegisterHostAddrs_W(a,b,c,d,e,f,g,h,i,j)
|
|
|
|
#define DnsMHAsyncRegisterHostAddrs_UTF8(a,b,c,d,e,f,g,h,i,j) \
|
|
DnsAsyncRegisterHostAddrs_UTF8(a,b,c,d,e,f,g,h,i,j)
|
|
|
|
// cleanup after clean build
|
|
|
|
#define DnsNameCompare(a,b) \
|
|
DnsNameCompare_A((a),(b))
|
|
|
|
#endif DNSBACKCOMPAT
|
|
|
|
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif // __cplusplus
|
|
|
|
#endif // _DNSAPI_INCLUDED_
|
|
|