windns.pas

详细Windows API大全有关知识以及相关问题

//
//  DNS Query API
//

//
//  Options for DnsQuery
//

const
  DNS_QUERY_STANDARD                  = $00000000;
  {$EXTERNALSYM DNS_QUERY_STANDARD}
  DNS_QUERY_ACCEPT_TRUNCATED_RESPONSE = $00000001;
  {$EXTERNALSYM DNS_QUERY_ACCEPT_TRUNCATED_RESPONSE}
  DNS_QUERY_USE_TCP_ONLY              = $00000002;
  {$EXTERNALSYM DNS_QUERY_USE_TCP_ONLY}
  DNS_QUERY_NO_RECURSION              = $00000004;
  {$EXTERNALSYM DNS_QUERY_NO_RECURSION}
  DNS_QUERY_BYPASS_CACHE              = $00000008;
  {$EXTERNALSYM DNS_QUERY_BYPASS_CACHE}
  DNS_QUERY_CACHE_ONLY                = $00000010;
  {$EXTERNALSYM DNS_QUERY_CACHE_ONLY}
  DNS_QUERY_SOCKET_KEEPALIVE          = $00000100;
  {$EXTERNALSYM DNS_QUERY_SOCKET_KEEPALIVE}
  DNS_QUERY_TREAT_AS_FQDN             = $00001000;
  {$EXTERNALSYM DNS_QUERY_TREAT_AS_FQDN}
  DNS_QUERY_ALLOW_EMPTY_AUTH_RESP     = $00010000;
  {$EXTERNALSYM DNS_QUERY_ALLOW_EMPTY_AUTH_RESP}
  DNS_QUERY_DONT_RESET_TTL_VALUES     = $00100000;
  {$EXTERNALSYM DNS_QUERY_DONT_RESET_TTL_VALUES}
  DNS_QUERY_RESERVED                  = DWORD($ff000000);
  {$EXTERNALSYM DNS_QUERY_RESERVED}

function DnsQuery_A(pszName: LPSTR; wType: WORD; Options: DWORD; aipServers: PIP4_ARRAY;
  ppQueryResults: PPDNS_RECORD; pReserved: PPVOID): DNS_STATUS; stdcall;
{$EXTERNALSYM DnsQuery_A}

function DnsQuery_UTF8(pszName: LPSTR; wType: WORD; Options: DWORD; aipServers: PIP4_ARRAY;
  ppQueryResults: PPDNS_RECORD; pReserved: PPVOID): DNS_STATUS; stdcall;
{$EXTERNALSYM DnsQuery_UTF8}

function DnsQuery_W(pszName: LPWSTR; wType: WORD; Options: DWORD; aipServers: PIP4_ARRAY;
  ppQueryResults: PPDNS_RECORD; pReserved: PPVOID): DNS_STATUS; stdcall;
{$EXTERNALSYM DnsQuery_W}

{$IFDEF UNICODE}
function DnsQuery(pszName: LPWSTR; wType: WORD; Options: DWORD; aipServers: PIP4_ARRAY;
  ppQueryResults: PPDNS_RECORD; pReserved: PPVOID): DNS_STATUS; stdcall;
{$EXTERNALSYM DnsQuery}
{$ELSE}
function DnsQuery(pszName: LPSTR; wType: WORD; Options: DWORD; aipServers: PIP4_ARRAY;
  ppQueryResults: PPDNS_RECORD; pReserved: PPVOID): DNS_STATUS; stdcall;
{$EXTERNALSYM DnsQuery}
{$ENDIF}

//
//  DNS Update API
//
//      DnsAcquireContextHandle
//      DnsReleaseContextHandle
//      DnsModifyRecordsInSet
//      DnsReplaceRecordSet
//

//
//  Update flags
//

const
  DNS_UPDATE_SECURITY_USE_DEFAULT    = $00000000;
  {$EXTERNALSYM DNS_UPDATE_SECURITY_USE_DEFAULT}
  DNS_UPDATE_SECURITY_OFF            = $00000010;
  {$EXTERNALSYM DNS_UPDATE_SECURITY_OFF}
  DNS_UPDATE_SECURITY_ON             = $00000020;
  {$EXTERNALSYM DNS_UPDATE_SECURITY_ON}
  DNS_UPDATE_SECURITY_ONLY           = $00000100;
  {$EXTERNALSYM DNS_UPDATE_SECURITY_ONLY}
  DNS_UPDATE_CACHE_SECURITY_CONTEXT  = $00000200;
  {$EXTERNALSYM DNS_UPDATE_CACHE_SECURITY_CONTEXT}
  DNS_UPDATE_TEST_USE_LOCAL_SYS_ACCT = $00000400;
  {$EXTERNALSYM DNS_UPDATE_TEST_USE_LOCAL_SYS_ACCT}
  DNS_UPDATE_FORCE_SECURITY_NEGO     = $00000800;
  {$EXTERNALSYM DNS_UPDATE_FORCE_SECURITY_NEGO}
  DNS_UPDATE_TRY_ALL_MASTER_SERVERS  = $00001000;
  {$EXTERNALSYM DNS_UPDATE_TRY_ALL_MASTER_SERVERS}
  DNS_UPDATE_RESERVED                = DWORD($ffff0000);
  {$EXTERNALSYM DNS_UPDATE_RESERVED}

//
//  Note:  pCredentials paramater is currently respectively
//  PSEC_WINNT_AUTH_IDENTITY_W or PSEC_WINNT_AUTH_IDENTITY_A.
//  Using PVOID to obviate the need for including rpcdce.h
//  in order to include this file and to leave open the
//  possibility of alternative credential specifications in
//  the future.
//

function DnsAcquireContextHandle_W(CredentialFlags: DWORD; pCredentials: PVOID;
  var pContextHandle: HANDLE): DNS_STATUS; stdcall;
{$EXTERNALSYM DnsAcquireContextHandle_W}

function DnsAcquireContextHandle_A(CredentialFlags: DWORD; pCredentials: PVOID;
  var pContextHandle: HANDLE): DNS_STATUS; stdcall;
{$EXTERNALSYM DnsAcquireContextHandle_A}

{$IFDEF UNICODE}
function DnsAcquireContextHandle(CredentialFlags: DWORD; pCredentials: PVOID;
  var pContextHandle: HANDLE): DNS_STATUS; stdcall;
{$EXTERNALSYM DnsAcquireContextHandle}
{$ELSE}
function DnsAcquireContextHandle(CredentialFlags: DWORD; pCredentials: PVOID;
  var pContextHandle: HANDLE): DNS_STATUS; stdcall;
{$EXTERNALSYM DnsAcquireContextHandle}
{$ENDIF}

procedure DnsReleaseContextHandle(hContext: HANDLE); stdcall;
{$EXTERNALSYM DnsReleaseContextHandle}

//
//  Dynamic Update API
//

function DnsModifyRecordsInSet_W(pAddRecords, pDeleteRecords: PDNS_RECORD;
  Options: DWORD; hContext: HANDLE; pServerList: PIP4_ARRAY; pReserved: PVOID): DNS_STATUS; stdcall;
{$EXTERNALSYM DnsModifyRecordsInSet_W}

function DnsModifyRecordsInSet_A(pAddRecords, pDeleteRecords: PDNS_RECORD;
  Options: DWORD; hContext: HANDLE; pServerList: PIP4_ARRAY; pReserved: PVOID): DNS_STATUS; stdcall;
{$EXTERNALSYM DnsModifyRecordsInSet_A}

function DnsModifyRecordsInSet_UTF8(pAddRecords, pDeleteRecords: PDNS_RECORD;
  Options: DWORD; hContext: HANDLE; pServerList: PIP4_ARRAY; pReserved: PVOID): DNS_STATUS; stdcall;
{$EXTERNALSYM DnsModifyRecordsInSet_UTF8}

{$IFDEF UNICODE}
function DnsModifyRecordsInSet(pAddRecords, pDeleteRecords: PDNS_RECORD;
  Options: DWORD; hContext: HANDLE; pServerList: PIP4_ARRAY; pReserved: PVOID): DNS_STATUS; stdcall;
{$EXTERNALSYM DnsModifyRecordsInSet}
{$ELSE}
function DnsModifyRecordsInSet(pAddRecords, pDeleteRecords: PDNS_RECORD;
  Options: DWORD; hContext: HANDLE; pServerList: PIP4_ARRAY; pReserved: PVOID): DNS_STATUS; stdcall;
{$EXTERNALSYM DnsModifyRecordsInSet}
{$ENDIF}

function DnsReplaceRecordSetW(pNewSet: PDNS_RECORD; Options: DWORD; hContext: HANDLE;
  pServerList: PIP4_ARRAY; pReserved: PVOID): DNS_STATUS; stdcall;
{$EXTERNALSYM DnsReplaceRecordSetW}

function DnsReplaceRecordSetA(pNewSet: PDNS_RECORD; Options: DWORD; hContext: HANDLE;
  pServerList: PIP4_ARRAY; pReserved: PVOID): DNS_STATUS; stdcall;
{$EXTERNALSYM DnsReplaceRecordSetA}

function DnsReplaceRecordSetUTF8(pNewSet: PDNS_RECORD; Options: DWORD; hContext: HANDLE;
  pServerList: PIP4_ARRAY; pReserved: PVOID): DNS_STATUS; stdcall;
{$EXTERNALSYM DnsReplaceRecordSetUTF8}

{$IFDEF UNICODE}
function DnsReplaceRecordSet(pNewSet: PDNS_RECORD; Options: DWORD; hContext: HANDLE;
  pServerList: PIP4_ARRAY; pReserved: PVOID): DNS_STATUS; stdcall;
{$EXTERNALSYM DnsReplaceRecordSet}
{$ELSE}
function DnsReplaceRecordSet(pNewSet: PDNS_RECORD; Options: DWORD; hContext: HANDLE;
  pServerList: PIP4_ARRAY; pReserved: PVOID): DNS_STATUS; stdcall;
{$EXTERNALSYM DnsReplaceRecordSet}
{$ENDIF}

//
//  DNS name validation
//

type
  _DNS_NAME_FORMAT = (
    DnsNameDomain,
    DnsNameDomainLabel,
    DnsNameHostnameFull,
    DnsNameHostnameLabel,
    DnsNameWildcard,
    DnsNameSrvRecord);
  {$EXTERNALSYM _DNS_NAME_FORMAT}
  DNS_NAME_FORMAT = _DNS_NAME_FORMAT;
  TDnsNameFormat = DNS_NAME_FORMAT;


function DnsValidateName_UTF8(pszName: LPCSTR; Format: DNS_NAME_FORMAT): DNS_STATUS; stdcall;
{$EXTERNALSYM DnsValidateName_UTF8}

function DnsValidateName_W(pszName: LPCWSTR; Format: DNS_NAME_FORMAT): DNS_STATUS; stdcall;
{$EXTERNALSYM DnsValidateName_W}

function DnsValidateName_A(pszName: LPCSTR; Format: DNS_NAME_FORMAT): DNS_STATUS; stdcall;
{$EXTERNALSYM DnsValidateName_A}

{$IFDEF UNICODE}

function DnsValidateName(pszName: LPCWSTR; Format: DNS_NAME_FORMAT): DNS_STATUS;
{$EXTERNALSYM DnsValidateName}

{$ELSE}

function DnsValidateName(pszName: LPCSTR; Format: DNS_NAME_FORMAT): DNS_STATUS;
{$EXTERNALSYM DnsValidateName}

{$ENDIF}

//
//  DNS name comparison
//

function DnsNameCompare_A(pName1, pName2: LPSTR): BOOL; stdcall;
{$EXTERNALSYM DnsNameCompare_A}
function DnsNameCompare_W(pName1, pName2: LPWSTR): BOOL; stdcall;
{$EXTERNALSYM DnsNameCompare_W}

{$IFDEF UNICODE}
function DnsNameCompare(pName1, pName2: LPWSTR): BOOL; stdcall;
{$EXTERNALSYM DnsNameCompare}
{$ELSE}
function DnsNameCompare(pName1, pName2: LPSTR): BOOL; stdcall;
{$EXTERNALSYM DnsNameCompare}
{$ENDIF}

//
//  DNS message "roll-your-own" routines
//

type
  _DNS_MESSAGE_BUFFER = record
    MessageHead: DNS_HEADER;
    MessageBody: array [0..0] of Char;
  end;
  {$EXTERNALSYM _DNS_MESSAGE_BUFFER}
  DNS_MESSAGE_BUFFER = _DNS_MESSAGE_BUFFER;
  {$EXTERNALSYM DNS_MESSAGE_BUFFER}
  PDNS_MESSAGE_BUFFER = ^DNS_MESSAGE_BUFFER;
  {$EXTERNALSYM PDNS_MESSAGE_BUFFER}
  TDnsMessageBuffer = DNS_MESSAGE_BUFFER;
  PDnsMessageBuffer = PDNS_MESSAGE_BUFFER;  

function DnsWriteQuestionToBuffer_W(pDnsBuffer: PDNS_MESSAGE_BUFFER;
  pdwBufferSize: LPDWORD; pszName: LPWSTR; wType, Xid: WORD;
  fRecursionDesired: BOOL): BOOL; stdcall;
{$EXTERNALSYM DnsWriteQuestionToBuffer_W}

function DnsWriteQuestionToBuffer_UTF8(pDnsBuffer: PDNS_MESSAGE_BUFFER;
  pdwBufferSize: LPDWORD; pszName: LPWSTR; wType, Xid: WORD;
  fRecursionDesired: BOOL): BOOL; stdcall;
{$EXTERNALSYM DnsWriteQuestionToBuffer_UTF8}

function DnsExtractRecordsFromMessage_W(pDnsBuffer: PDNS_MESSAGE_BUFFER;
  wMessageLength: WORD; var ppRecord: PDNS_RECORD): DNS_STATUS; stdcall;
{$EXTERNALSYM DnsExtractRecordsFromMessage_W}

function DnsExtractRecordsFromMessage_UTF8(pDnsBuffer: PDNS_MESSAGE_BUFFER;
  wMessageLength: WORD; var ppRecord: PDNS_RECORD): DNS_STATUS; stdcall;
{$EXTERNALSYM DnsExtractRecordsFromMessage_UTF8}

implementation

const
  dnsapi = 'dnsapi.dll';

procedure INLINE_WORD_FLIP(var Out: WORD; In_: WORD);
begin
  Out := (In_ shl 8) or (In_ shr 8);
end;

procedure INLINE_HTONS(var Out: WORD; In_: WORD);
begin
  INLINE_WORD_FLIP(Out, In_);
end;

procedure INLINE_NTOHS(var Out: WORD; In_: WORD);
begin
  INLINE_WORD_FLIP(Out, In_);
end;

procedure INLINE_DWORD_FLIP(var Out: DWORD; In_: DWORD);
begin
  Out := ((In_ shl 8) and $00ff0000) or (In_ shl 24) or
    ((In_ shr 8) and $0000ff00) or (In_ shr 24);
end;

procedure INLINE_NTOHL(var Out: DWORD; In_: DWORD);
begin
  INLINE_DWORD_FLIP(Out, In_);
end;

procedure INLINE_HTONL(var Out: DWORD; In_: DWORD);
begin
  INLINE_DWORD_FLIP(Out, In_);
end;

procedure INLINE_WRITE_FLIPPED_WORD(pout: PWORD; In_: WORD);
begin
  INLINE_WORD_FLIP(pout^, In_);
end;

procedure INLINE_WRITE_FLIPPED_DWORD(pout: PDWORD; In_: DWORD);
begin
  INLINE_DWORD_FLIP(pout^, In_);
end;

function DNS_HEADER_FLAGS(pHead: PDNS_HEADER): WORD;
begin
  Result := PWORD(Integer(pHead) + SizeOf(WORD))^;
end;

procedure DNS_BYTE_FLIP_HEADER_COUNTS(var pHeader: PDNS_HEADER);
var
  _head: PDNS_HEADER;
begin
  _head := pHeader;
  INLINE_HTONS(_head^.Xid, _head^.Xid);
  INLINE_HTONS(_head^.QuestionCount, _head^.QuestionCount);
  INLINE_HTONS(_head^.AnswerCount, _head^.AnswerCount);
  INLINE_HTONS(_head^.NameServerCount, _head^.NameServerCount);
  INLINE_HTONS(_head^.AdditionalCount, _head^.AdditionalCount);
end;

{
#define DNS_QUESTION_NAME_FROM_HEADER( _pHeader_ ) \
            ( (PCHAR)( (PDNS_HEADER)(_pHeader_) + 1 ) )

#define DNS_ANSWER_FROM_QUESTION( _pQuestion_ ) \
            ( (PCHAR)( (PDNS_QUESTION)(_pQuestion_) + 1 ) )
}

function IS_DWORD_ALIGNED(P: Pointer): BOOL;
begin
  Result := (Integer(P) and 3) = 0;
end;

function IS_QWORD_ALIGNED(P: Pointer): BOOL;
begin
  Result := (Integer(P) and 7) = 0;
end;

function DnsQueryConfig; external dnsapi name 'DnsQueryConfig';

function DNS_TEXT_RECORD_LENGTH(StringCount: Integer): Integer;
begin
  Result := SizeOf(DWORD) + ((StringCount) * SizeOf(PChar));
end;

function DNS_NULL_RECORD_LENGTH(ByteCount: Integer): Integer;
begin
  Result := SizeOf(DWORD) + (ByteCount);
end;

function DNS_WKS_RECORD_LENGTH(ByteCount: Integer): Integer;
begin
  Result := SizeOf(DNS_WKS_DATA) + (ByteCount - 1);
end;

//function DNS_WINS_RECORD_LENGTH(IpCount: Integer): Integer;
//begin
//  Result := SizeOf(DNS_WINS_DATA) + ((IpCount - 1) * SizeOf(IP_ADDRESS));
//end;

procedure DNS_RRSET_INIT(rrset: PDNS_RRSET);
begin
  rrset^.pFirstRR := nil;
  rrset^.pLastRR := (@rrset^.pFirstRR);
end;

//procedure DNS_RRSET_ADD(rrset, pnewRR: PDNS_RRSET);
//begin
//  rrset^.pLastRR^.pNext := pnewRR;
//  rrset^.pLastRR := pnewRR;
//end;

procedure DNS_RRSET_TERMINATE(rrset: PDNS_RRSET);
begin
  rrset^.pLastRR^.pNext := nil;
end;

function DnsRecordCopyEx; external dnsapi name 'DnsRecordCopyEx';
function DnsRecordSetCopyEx; external dnsapi name 'DnsRecordSetCopyEx';

{$IFDEF UNICODE}

function DnsRecordCopy(pRR: PDNS_RECORD): PDNS_RECORD;
begin
  Result := DnsRecordCopyEx(pRR, DnsCharSetUnicode, DnsCharSetUnicode);
end;

function DnsRecordSetCopy(pRR: PDNS_RECORD): PDNS_RECORD;
begin
  Result := DnsRecordSetCopyEx(pRR, DnsCharSetUnicode, DnsCharSetUnicode);
end;

{$ELSE}

function DnsRecordCopy(pRR: PDNS_RECORD): PDNS_RECORD;
begin
  Result := DnsRecordCopyEx(pRR, DnsCharSetAnsi, DnsCharSetAnsi);
end;

function DnsRecordSetCopy(pRR: PDNS_RECORD): PDNS_RECORD;
begin
  Result := DnsRecordSetCopyEx(pRR, DnsCharSetAnsi, DnsCharSetAnsi);
end;

{$ENDIF}

function DnsRecordCompare; external dnsapi name 'DnsRecordCompare';
function DnsRecordSetCompare; external dnsapi name 'DnsRecordSetCompare';
function DnsRecordSetDetach; external dnsapi name 'DnsRecordSetDetach';
procedure DnsRecordListFree; external dnsapi name 'DnsRecordListFree';

function DnsQuery_A; external dnsapi name 'DnsQuery_A';
function DnsQuery_UTF8; external dnsapi name 'DnsQuery_UTF8';
function DnsQuery_W; external dnsapi name 'DnsQuery_W';
{$IFDEF UNICODE}
function DnsQuery; external dnsapi name 'DnsQuery_W';
{$ELSE}
function DnsQuery; external dnsapi name 'DnsQuery_A';
{$ENDIF}

function DnsAcquireContextHandle_W; external dnsapi name 'DnsAcquireContextHandle_W';
function DnsAcquireContextHandle_A; external dnsapi name 'DnsAcquireContextHandle_A';
{$IFDEF UNICODE}
function DnsAcquireContextHandle; external dnsapi name 'DnsAcquireContextHandle_W';
{$ELSE}
function DnsAcquireContextHandle; external dnsapi name 'DnsAcquireContextHandle_A';
{$ENDIF}

procedure DnsReleaseContextHandle; external dnsapi name 'DnsReleaseContextHandle';

function DnsModifyRecordsInSet_W; external dnsapi name 'DnsModifyRecordsInSet_W';
function DnsModifyRecordsInSet_A; external dnsapi name 'DnsModifyRecordsInSet_A';
function DnsModifyRecordsInSet_UTF8; external dnsapi name 'DnsModifyRecordsInSet_UTF8';
{$IFDEF UNICODE}
function DnsModifyRecordsInSet; external dnsapi name 'DnsModifyRecordsInSet_W';
{$ELSE}
function DnsModifyRecordsInSet; external dnsapi name 'DnsModifyRecordsInSet_A';
{$ENDIF}

function DnsReplaceRecordSetW; external dnsapi name 'DnsReplaceRecordSetW';
function DnsReplaceRecordSetA; external dnsapi name 'DnsReplaceRecordSetA';
function DnsReplaceRecordSetUTF8; external dnsapi name 'DnsReplaceRecordSetUTF8';
{$IFDEF UNICODE}
function DnsReplaceRecordSet; external dnsapi name 'DnsReplaceRecordSetW';
{$ELSE}
function DnsReplaceRecordSet; external dnsapi name 'DnsReplaceRecordSetA';
{$ENDIF}

function DnsValidateName_UTF8; external dnsapi name 'DnsValidateName_UTF8';
function DnsValidateName_W; external dnsapi name 'DnsValidateName_W';
function DnsValidateName_A; external dnsapi name 'DnsValidateName_A';

{$IFDEF UNICODE}

function DnsValidateName(pszName: LPCWSTR; Format: DNS_NAME_FORMAT): DNS_STATUS;
begin
  Result := DnsValidateName_W(pszName, Format);
end;

{$ELSE}

function DnsValidateName(pszName: LPCSTR; Format: DNS_NAME_FORMAT): DNS_STATUS;
begin
  Result := DnsValidateName_A(pszName, Format);
end;

{$ENDIF}

function DnsNameCompare_A; external dnsapi name 'DnsNameCompare_A';
function DnsNameCompare_W; external dnsapi name 'DnsNameCompare_W';
{$IFDEF UNICODE}
function DnsNameCompare; external dnsapi name 'DnsNameCompare_W';
{$ELSE}
function DnsNameCompare; external dnsapi name 'DnsNameCompare_A';
{$ENDIF}

function DnsWriteQuestionToBuffer_W; external dnsapi name 'DnsWriteQuestionToBuffer_W';
function DnsWriteQuestionToBuffer_UTF8; external dnsapi name 'DnsWriteQuestionToBuffer_UTF8';
function DnsExtractRecordsFromMessage_W; external dnsapi name 'DnsExtractRecordsFromMessage_W';
function DnsExtractRecordsFromMessage_UTF8; external dnsapi name 'DnsExtractRecordsFromMessage_UTF8';

end.