2699 lines
65 KiB
C
2699 lines
65 KiB
C
/*++
|
||
|
||
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_
|
||
|