/*++ 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 #endif #endif #ifndef _DNS_INCLUDED_ #include #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_