开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 查看源码
JwaWinDNS.pas
资源名称：win32api.zip　[点击查看]
上传用户：davidchvip
上传日期：2009-07-28
资源大小：1749k
文件大小：73k
源码类别：

Windows编程

开发平台：

Delphi

JwaWinDNS.pas：源码内容
  1. {******************************************************************************}
  2. {                                                                       }
  3. { Domain Naming Services API interface Unit for Object Pascal                  }
  4. {                                                                       }
  5. { Portions created by Microsoft are Copyright (C) 1995-2001 Microsoft          }
  6. { Corporation. All Rights Reserved.                                            }
  7. {                 }
  8. { The original file is: windns.h, released June 2000. The original Pascal      }
  9. { code is: WinDNS.pas, released December 2000. The initial developer of the    }
  10. { Pascal code is Marcel van Brakel (brakelm@chello.nl).                        }
  11. {                                                                              }
  12. { Portions created by Marcel van Brakel are Copyright (C) 1999-2001            }
  13. { Marcel van Brakel. All Rights Reserved.                                      }
  14. {                 }
  15. { Obtained through: Joint Endeavour of Delphi Innovators (Project JEDI)        }
  16. {                }
  17. { You may retrieve the latest version of this file at the Project JEDI home    }
  18. { page, located at http://delphi-jedi.org or my personal homepage located at   }
  19. { http://members.chello.nl/m.vanbrakel2                                        }
  20. {                }
  21. { The contents of this file are used with permission, subject to the Mozilla   }
  22. { Public License Version 1.1 (the "License"); you may not use this file except }
  23. { in compliance with the License. You may obtain a copy of the License at      }
  24. { http://www.mozilla.org/MPL/MPL-1.1.html                                      }
  25. {                                                                              }
  26. { Software distributed under the License is distributed on an "AS IS" basis,   }
  27. { WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for }
  28. { the specific language governing rights and limitations under the License.    }
  29. {                                                                              }
  30. { Alternatively, the contents of this file may be used under the terms of the  }
  31. { GNU Lesser General Public License (the  "LGPL License"), in which case the   }
  32. { provisions of the LGPL License are applicable instead of those above.        }
  33. { If you wish to allow use of your version of this file only under the terms   }
  34. { of the LGPL License and not to allow others to use your version of this file }
  35. { under the MPL, indicate your decision by deleting  the provisions above and  }
  36. { replace  them with the notice and other provisions required by the LGPL      }
  37. { License.  If you do not delete the provisions above, a recipient may use     }
  38. { your version of this file under either the MPL or the LGPL License.          }
  39. {                 }
  40. { For more information about the LGPL: http://www.gnu.org/copyleft/lesser.html }
  41. {                 }
  42. {******************************************************************************}
  45. {******************************************************************}
  46. {     }
  47. { Notes (TODO):                                                    }
  48. {   DnsRecordSetDetach() and DnsValidateName_X() didn't have a cc  }
  49. {   IP_ADDRESS_STRING_LENGTH is defined nowhere                    }
  50. {   DNS_WINS_RECORD macro  untranslatable due to IP_ADDRESS        }
  51. {   DNS_RRSET_ADD macro untranslatable                             }
  52. {     }
  53. {******************************************************************}
  55. unit JwaWinDNS;
  57. {$WEAKPACKAGEUNIT}
  59. {$HPPEMIT ''}
  60. {$HPPEMIT '#include "WinDNS.h"'}
  61. {$HPPEMIT ''}
  62. {$HPPEMIT 'typeded PDNS_RECORD *PPDNS_RECORD'}
  63. {$HPPEMIT ''}
  65. {$I WINDEFINES.INC}
  67. interface
  69. uses
  70.   JwaWinsock2, JwaWinType;
  72. {.$DEFINE ATMA_E164}
  74. type
  75.   IN6_ADDR = Pointer; // todo
  77. //
  78. //  Define QWORD -- not yet defined globally 
  79. //
  81. type
  82.   QWORD = Int64;
  83.   {$EXTERNALSYM QWORD}
  85. //
  86. //  DNS public types
  87. //
  89. type
  90.   DNS_STATUS = Longint;
  91.   {$EXTERNALSYM DNS_STATUS}
  92.   PDNS_STATUS = ^DNS_STATUS;
  93.   {$EXTERNALSYM PDNS_STATUS}
  94.   TDnsStatus = DNS_STATUS;
  95.   PDnsStatus = PDNS_STATUS;
  97. //
  98. //  IP Address
  99. //
  101. type
  102.   IP4_ADDRESS = DWORD;
  103.   {$EXTERNALSYM IP4_ADDRESS}
  104.   PIP4_ADDRESS = ^IP4_ADDRESS;
  105.   {$EXTERNALSYM PIP4_ADDRESS}
  106.   TIP4Address = IP4_ADDRESS;
  107.   PIP4Address = PIP4_ADDRESS;
  109. const
  110.   SIZEOF_IP4_ADDRESS         = 4;
  111.   {$EXTERNALSYM SIZEOF_IP4_ADDRESS}
  112.   IP4_ADDRESS_STRING_LENGTH  = 15;
  113.   {$EXTERNALSYM IP4_ADDRESS_STRING_LENGTH}
  114.   IP4_ADDRESS_STRING_BUFFER_LENGTH = 16;
  115.   {$EXTERNALSYM IP4_ADDRESS_STRING_BUFFER_LENGTH}
  117. //
  118. //  IP Address Array type
  119. //
  121. type
  122.   PIP4_ARRAY = ^IP4_ARRAY;
  123.   {$EXTERNALSYM PIP4_ARRAY}
  124.   _IP4_ARRAY = record
  125.     AddrCount: DWORD;
  126.     AddrArray: array [0..0] of IP4_ADDRESS;
  127.   end;
  128.   {$EXTERNALSYM _IP4_ARRAY}
  129.   IP4_ARRAY = _IP4_ARRAY;
  130.   {$EXTERNALSYM IP4_ARRAY}
  131.   TIp4Array = IP4_ARRAY;
  132.   PIp4Array = PIP4_ARRAY;
  134. //
  135. //  IPv6 Address
  136. //
  138.   PIP6_ADDRESS = ^IP6_ADDRESS;
  139.   {$EXTERNALSYM PIP6_ADDRESS}
  140.   IP6_ADDRESS = record
  141.     case Integer of
  142.       0: (IP6Qword: array [0..1] of QWORD);
  143.       1: (IP6Dword: array [0..3] of DWORD);
  144.       2: (IP6Word: array [0..7] of WORD);
  145.       3: (IP6Byte: array [0..15] of BYTE);
  146.       4: (In6: IN6_ADDR);
  147.   end;
  148.   {$EXTERNALSYM IP6_ADDRESS}
  149.   TIp6Address = IP6_ADDRESS;
  150.   PIp6Address = PIP6_ADDRESS;
  152. //  Backward compatibility
  154.   DNS_IP6_ADDRESS = IP6_ADDRESS;
  155.   {$EXTERNALSYM DNS_IP6_ADDRESS}
  156.   PDNS_IP6_ADDRESS = ^IP6_ADDRESS;
  157.   {$EXTERNALSYM PDNS_IP6_ADDRESS}
  158.   TDnsIp6Address = DNS_IP6_ADDRESS;
  159.   PDnsIp6Address = PDNS_IP6_ADDRESS;
  161. //
  162. //  IP6 string max is 45 bytes
  163. //      - 6 WORDs in colon+hex (5 chars)
  164. //      - last DWORD as IP4 (15 chars)
  165. //  
  167. const
  168.   IP6_ADDRESS_STRING_LENGTH        = (47);
  169.   {$EXTERNALSYM IP6_ADDRESS_STRING_LENGTH}
  170.   IP6_ADDRESS_STRING_BUFFER_LENGTH = (48);
  171.   {$EXTERNALSYM IP6_ADDRESS_STRING_BUFFER_LENGTH}
  173. //  backcompat
  175.   IPV6_ADDRESS_STRING_LENGTH = IP6_ADDRESS_STRING_LENGTH;
  176.   {$EXTERNALSYM IPV6_ADDRESS_STRING_LENGTH}
  178. //
  179. //  Inline byte flipping -- can be done in registers
  180. //
  182. procedure INLINE_WORD_FLIP(var Out: WORD; In_: WORD);
  183. {$EXTERNALSYM INLINE_WORD_FLIP}
  185. procedure INLINE_HTONS(var Out: WORD; In_: WORD);
  186. {$EXTERNALSYM INLINE_HTONS}
  188. procedure INLINE_NTOHS(var Out: WORD; In_: WORD);
  189. {$EXTERNALSYM INLINE_NTOHS}
  191. procedure INLINE_DWORD_FLIP(var Out: DWORD; In_: DWORD);
  192. {$EXTERNALSYM INLINE_DWORD_FLIP}
  194. procedure INLINE_NTOHL(var Out: DWORD; In_: DWORD);
  195. {$EXTERNALSYM INLINE_NTOHL}
  197. procedure INLINE_HTONL(var Out: DWORD; In_: DWORD);
  198. {$EXTERNALSYM INLINE_HTONL}
  200. //
  201. //  Inline byte flip and write to packet (unaligned)
  202. //
  204. procedure INLINE_WRITE_FLIPPED_WORD(pout: PWORD; In_: WORD);
  205. {$EXTERNALSYM INLINE_WRITE_FLIPPED_WORD}
  207. procedure INLINE_WRITE_FLIPPED_DWORD(pout: PDWORD; In_: DWORD);
  208. {$EXTERNALSYM INLINE_WRITE_FLIPPED_DWORD}
  210. //
  211. //  Basic DNS definitions
  212. //
  214. //
  215. //  DNS port for both UDP and TCP is 53.
  216. //
  218. const
  219.   DNS_PORT_HOST_ORDER = ($0035); // port 53
  220.   {$EXTERNALSYM DNS_PORT_HOST_ORDER}
  221.   DNS_PORT_NET_ORDER  = ($3500);
  222.   {$EXTERNALSYM DNS_PORT_NET_ORDER}
  224. //
  225. //  DNS UDP packets no more than 512 bytes
  226. //
  228.   DNS_RFC_MAX_UDP_PACKET_LENGTH = (512);
  229.   {$EXTERNALSYM DNS_RFC_MAX_UDP_PACKET_LENGTH}
  231. //
  232. //  DNS Names limited to 255, 63 in any one label
  233. //
  235.   DNS_MAX_NAME_LENGTH  = (255);
  236.   {$EXTERNALSYM DNS_MAX_NAME_LENGTH}
  237.   DNS_MAX_LABEL_LENGTH = (63);
  238.   {$EXTERNALSYM DNS_MAX_LABEL_LENGTH}
  240.   DNS_MAX_NAME_BUFFER_LENGTH  = (256);
  241.   {$EXTERNALSYM DNS_MAX_NAME_BUFFER_LENGTH}
  242.   DNS_MAX_LABEL_BUFFER_LENGTH = (64);
  243.   {$EXTERNALSYM DNS_MAX_LABEL_BUFFER_LENGTH}
  245. //
  246. //  Reverse lookup domain names
  247. //
  249.   DNS_IP4_REVERSE_DOMAIN_STRING = ('in-addr.arpa.');
  250.   {$EXTERNALSYM DNS_IP4_REVERSE_DOMAIN_STRING}
  252.   //DNS_MAX_IP4_REVERSE_NAME_LENGTH = (IP_ADDRESS_STRING_LENGTH + 1 + SizeOf(DNS_IP4_REVERSE_DOMAIN_STRING));
  253.   //{$EXTERNALSYM DNS_MAX_IP4_REVERSE_NAME_LENGTH}
  255.   //DNS_MAX_IP4_REVERSE_NAME_BUFFER_LENGTH = (DNS_MAX_IP4_REVERSE_NAME_LENGTH + 1);
  256.   //{$EXTERNALSYM DNS_MAX_IP4_REVERSE_NAME_BUFFER_LENGTH}
  258.   DNS_IP6_REVERSE_DOMAIN_STRING = ('ip6.int.');
  259.   {$EXTERNALSYM DNS_IP6_REVERSE_DOMAIN_STRING}
  261.   DNS_MAX_IP6_REVERSE_NAME_LENGTH = (64 + SizeOf(DNS_IP6_REVERSE_DOMAIN_STRING));
  262.   {$EXTERNALSYM DNS_MAX_IP6_REVERSE_NAME_LENGTH}
  264.   DNS_MAX_IP6_REVERSE_NAME_BUFFER_LENGTH = (DNS_MAX_IP6_REVERSE_NAME_LENGTH + 1);
  265.   {$EXTERNALSYM DNS_MAX_IP6_REVERSE_NAME_BUFFER_LENGTH}
  267. //  Combined
  269.   DNS_MAX_REVERSE_NAME_LENGTH = DNS_MAX_IP6_REVERSE_NAME_LENGTH;
  270.   {$EXTERNALSYM DNS_MAX_REVERSE_NAME_LENGTH}
  272.   DNS_MAX_REVERSE_NAME_BUFFER_LENGTH = DNS_MAX_IP6_REVERSE_NAME_BUFFER_LENGTH;
  273.   {$EXTERNALSYM DNS_MAX_REVERSE_NAME_BUFFER_LENGTH}
  275. //
  276. //  DNS Text string limited by size representable
  277. //      in a single byte length field
  279.   DNS_MAX_TEXT_STRING_LENGTH = (255);
  280.   {$EXTERNALSYM DNS_MAX_TEXT_STRING_LENGTH}
  282. //
  283. //  DNS On-The-Wire Structures
  284. //
  286. //
  287. //  DNS Message Header
  288. //
  290. type
  291.   _DNS_HEADER = packed record
  292.     Xid: WORD;
  293.     Flags: Byte;
  294.     //BYTE    RecursionDesired : 1;
  295.     //BYTE    Truncation : 1;
  296.     //BYTE    Authoritative : 1;
  297.     //BYTE    Opcode : 4;
  298.     //BYTE    IsResponse : 1;
  299.     Flags2: Byte;
  300.     //BYTE    ResponseCode : 4;
  301.     //BYTE    Reserved : 3;
  302.     //BYTE    RecursionAvailable : 1;
  303.     QuestionCount: WORD;
  304.     AnswerCount: WORD;
  305.     NameServerCount: WORD;
  306.     AdditionalCount: WORD;
  307.   end;
  308.   {$EXTERNALSYM _DNS_HEADER}
  309.   DNS_HEADER = _DNS_HEADER;
  310.   {$EXTERNALSYM DNS_HEADER}
  311.   PDNS_HEADER = ^DNS_HEADER;
  312.   {$EXTERNALSYM PDNS_HEADER}
  313.   TDnsHeader = DNS_HEADER;
  314.   PDnsHeader = PDNS_HEADER;
  316. //
  317. //  Flags as WORD
  318. //
  320. function DNS_HEADER_FLAGS(pHead: PDNS_HEADER): WORD;
  321. {$EXTERNALSYM DNS_HEADER_FLAGS}
  323. //
  324. //  Byte flip DNS header tofrom host order.
  325. //
  326. //  Note that this does NOT flip flags, as definition above defines
  327. //  flags as individual bytes for direct access to net byte order.
  328. //
  330. procedure DNS_BYTE_FLIP_HEADER_COUNTS(var pHeader: PDNS_HEADER);
  331. {$EXTERNALSYM DNS_BYTE_FLIP_HEADER_COUNTS}
  333. //
  334. //  Question name follows header
  335. //
  337. const
  338.   DNS_OFFSET_TO_QUESTION_NAME = SizeOf(DNS_HEADER);
  339.   {$EXTERNALSYM DNS_OFFSET_TO_QUESTION_NAME}
  341. //
  342. //  Question immediately follows header so compressed question name
  343. //      0xC000 | sizeof(DNS_HEADER)
  345.   DNS_COMPRESSED_QUESTION_NAME = ($C00C);
  346.   {$EXTERNALSYM DNS_COMPRESSED_QUESTION_NAME}
  348. //
  349. //  Packet extraction macros
  350. //
  352. {
  353. #define DNS_QUESTION_NAME_FROM_HEADER( _pHeader_ ) 
  354.             ( (PCHAR)( (PDNS_HEADER)(_pHeader_) + 1 ) )
  356. #define DNS_ANSWER_FROM_QUESTION( _pQuestion_ ) 
  357.             ( (PCHAR)( (PDNS_QUESTION)(_pQuestion_) + 1 ) )
  358. }
  360. //
  361. //  DNS Question
  362. //
  364. type
  365.   PDNS_WIRE_QUESTION = ^DNS_WIRE_QUESTION;
  366.   {$EXTERNALSYM PDNS_WIRE_QUESTION}
  367.   _DNS_WIRE_QUESTION = packed record
  368.     //  Preceded by question name
  369.     QuestionType: WORD;
  370.     QuestionClass: WORD;
  371.   end;
  372.   {$EXTERNALSYM _DNS_WIRE_QUESTION}
  373.   DNS_WIRE_QUESTION = _DNS_WIRE_QUESTION;
  374.   {$EXTERNALSYM DNS_WIRE_QUESTION}
  375.   TDnsWireQuestion = DNS_WIRE_QUESTION;
  376.   PDnsWireQuestion = PDNS_WIRE_QUESTION;
  378. //
  379. //  DNS Resource Record
  380. //
  382.   PDNS_WIRE_RECORD = ^DNS_WIRE_RECORD;
  383.   {$EXTERNALSYM PDNS_WIRE_RECORD}
  384.   _DNS_WIRE_RECORD = packed record
  385.     //  Preceded by record owner name
  386.     RecordType: WORD;
  387.     RecordClass: WORD;
  388.     TimeToLive: DWORD;
  389.     DataLength: WORD;
  390.     //  Followed by record data
  391.   end;
  392.   {$EXTERNALSYM _DNS_WIRE_RECORD}
  393.   DNS_WIRE_RECORD = _DNS_WIRE_RECORD;
  394.   {$EXTERNALSYM DNS_WIRE_RECORD}
  395.   TDnsWireRecord = DNS_WIRE_RECORD;
  396.   PDnsWireRecord = PDNS_WIRE_RECORD;
  398. //
  399. //  DNS Query Types
  400. //
  402. const
  403.   DNS_OPCODE_QUERY         = 0; // Query
  404.   {$EXTERNALSYM DNS_OPCODE_QUERY}
  405.   DNS_OPCODE_IQUERY        = 1; // Obsolete: IP to name
  406.   {$EXTERNALSYM DNS_OPCODE_IQUERY}
  407.   DNS_OPCODE_SERVER_STATUS = 2; // Obsolete: DNS ping
  408.   {$EXTERNALSYM DNS_OPCODE_SERVER_STATUS}
  409.   DNS_OPCODE_UNKNOWN       = 3; // Unknown
  410.   {$EXTERNALSYM DNS_OPCODE_UNKNOWN}
  411.   DNS_OPCODE_NOTIFY        = 4; // Notify
  412.   {$EXTERNALSYM DNS_OPCODE_NOTIFY}
  413.   DNS_OPCODE_UPDATE        = 5; // Dynamic Update
  414.   {$EXTERNALSYM DNS_OPCODE_UPDATE}
  416. //
  417. //  DNS response codes.
  418. //
  419. //  Sent in the "ResponseCode" field of a DNS_HEADER.
  420. //
  422.   DNS_RCODE_NOERROR  = 0;
  423.   {$EXTERNALSYM DNS_RCODE_NOERROR}
  424.   DNS_RCODE_FORMERR  = 1; // Format error
  425.   {$EXTERNALSYM DNS_RCODE_FORMERR}
  426.   DNS_RCODE_SERVFAIL = 2; // Server failure
  427.   {$EXTERNALSYM DNS_RCODE_SERVFAIL}
  428.   DNS_RCODE_NXDOMAIN = 3; // Name error
  429.   {$EXTERNALSYM DNS_RCODE_NXDOMAIN}
  430.   DNS_RCODE_NOTIMPL  = 4; // Not implemented
  431.   {$EXTERNALSYM DNS_RCODE_NOTIMPL}
  432.   DNS_RCODE_REFUSED  = 5; // Refused
  433.   {$EXTERNALSYM DNS_RCODE_REFUSED}
  434.   DNS_RCODE_YXDOMAIN = 6; // Domain name should not exist
  435.   {$EXTERNALSYM DNS_RCODE_YXDOMAIN}
  436.   DNS_RCODE_YXRRSET  = 7; // RR set should not exist
  437.   {$EXTERNALSYM DNS_RCODE_YXRRSET}
  438.   DNS_RCODE_NXRRSET  = 8; // RR set does not exist
  439.   {$EXTERNALSYM DNS_RCODE_NXRRSET}
  440.   DNS_RCODE_NOTAUTH  = 9; // Not authoritative for zone
  441.   {$EXTERNALSYM DNS_RCODE_NOTAUTH}
  442.   DNS_RCODE_NOTZONE  = 10; // Name is not zone
  443.   {$EXTERNALSYM DNS_RCODE_NOTZONE}
  444.   DNS_RCODE_MAX      = 15;
  445.   {$EXTERNALSYM DNS_RCODE_MAX}
  447. //
  448. //  Extended RCODEs
  449. //
  451.   DNS_RCODE_BADVERS = 16; // Bad EDNS version
  452.   {$EXTERNALSYM DNS_RCODE_BADVERS}
  453.   DNS_RCODE_BADSIG  = 16; // Bad signature
  454.   {$EXTERNALSYM DNS_RCODE_BADSIG}
  455.   DNS_RCODE_BADKEY  = 17; // Bad key
  456.   {$EXTERNALSYM DNS_RCODE_BADKEY}
  457.   DNS_RCODE_BADTIME = 18; // Bad timestamp
  458.   {$EXTERNALSYM DNS_RCODE_BADTIME}
  460. //
  461. //  Mappings to friendly names
  462. //
  464.   DNS_RCODE_NO_ERROR        = DNS_RCODE_NOERROR;
  465.   {$EXTERNALSYM DNS_RCODE_NO_ERROR}
  466.   DNS_RCODE_FORMAT_ERROR    = DNS_RCODE_FORMERR;
  467.   {$EXTERNALSYM DNS_RCODE_FORMAT_ERROR}
  468.   DNS_RCODE_SERVER_FAILURE  = DNS_RCODE_SERVFAIL;
  469.   {$EXTERNALSYM DNS_RCODE_SERVER_FAILURE}
  470.   DNS_RCODE_NAME_ERROR      = DNS_RCODE_NXDOMAIN;
  471.   {$EXTERNALSYM DNS_RCODE_NAME_ERROR}
  472.   DNS_RCODE_NOT_IMPLEMENTED = DNS_RCODE_NOTIMPL;
  473.   {$EXTERNALSYM DNS_RCODE_NOT_IMPLEMENTED}
  475. //
  476. //  DNS Classes
  477. //
  478. //  Classes are on the wire as WORDs.
  479. //
  480. //  _CLASS_ defines in host order.
  481. //  _RCLASS_ defines in net byte order.
  482. //
  483. //  Generally we'll avoid byte flip and test class in net byte order.
  484. //
  486.   DNS_CLASS_INTERNET = $0001; // 1
  487.   {$EXTERNALSYM DNS_CLASS_INTERNET}
  488.   DNS_CLASS_CSNET    = $0002; // 2
  489.   {$EXTERNALSYM DNS_CLASS_CSNET}
  490.   DNS_CLASS_CHAOS    = $0003; // 3
  491.   {$EXTERNALSYM DNS_CLASS_CHAOS}
  492.   DNS_CLASS_HESIOD   = $0004; // 4
  493.   {$EXTERNALSYM DNS_CLASS_HESIOD}
  494.   DNS_CLASS_NONE     = $00fe; // 254
  495.   {$EXTERNALSYM DNS_CLASS_NONE}
  496.   DNS_CLASS_ALL      = $00ff; // 255
  497.   {$EXTERNALSYM DNS_CLASS_ALL}
  498.   DNS_CLASS_ANY      = $00ff; // 255
  499.   {$EXTERNALSYM DNS_CLASS_ANY}
  501.   DNS_RCLASS_INTERNET = $0100; // 1
  502.   {$EXTERNALSYM DNS_RCLASS_INTERNET}
  503.   DNS_RCLASS_CSNET    = $0200; // 2
  504.   {$EXTERNALSYM DNS_RCLASS_CSNET}
  505.   DNS_RCLASS_CHAOS    = $0300; // 3
  506.   {$EXTERNALSYM DNS_RCLASS_CHAOS}
  507.   DNS_RCLASS_HESIOD   = $0400; // 4
  508.   {$EXTERNALSYM DNS_RCLASS_HESIOD}
  509.   DNS_RCLASS_NONE     = $fe00; // 254
  510.   {$EXTERNALSYM DNS_RCLASS_NONE}
  511.   DNS_RCLASS_ALL      = $ff00; // 255
  512.   {$EXTERNALSYM DNS_RCLASS_ALL}
  513.   DNS_RCLASS_ANY      = $ff00; // 255
  514.   {$EXTERNALSYM DNS_RCLASS_ANY}
  516. //
  517. //  DNS Record Types
  518. //
  519. //  _TYPE_ defines are in host byte order.
  520. //  _RTYPE_ defines are in net byte order.
  521. //
  522. //  Generally always deal with types in host byte order as we index
  523. //  resource record functions by type.
  524. //
  526.   DNS_TYPE_ZERO = $0000;
  527.   {$EXTERNALSYM DNS_TYPE_ZERO}
  529. //  RFC 1034/1035
  530.   DNS_TYPE_A     = $0001; // 1
  531.   {$EXTERNALSYM DNS_TYPE_A}
  532.   DNS_TYPE_NS    = $0002; // 2
  533.   {$EXTERNALSYM DNS_TYPE_NS}
  534.   DNS_TYPE_MD    = $0003; // 3
  535.   {$EXTERNALSYM DNS_TYPE_MD}
  536.   DNS_TYPE_MF    = $0004; // 4
  537.   {$EXTERNALSYM DNS_TYPE_MF}
  538.   DNS_TYPE_CNAME = $0005; // 5
  539.   {$EXTERNALSYM DNS_TYPE_CNAME}
  540.   DNS_TYPE_SOA   = $0006; // 6
  541.   {$EXTERNALSYM DNS_TYPE_SOA}
  542.   DNS_TYPE_MB    = $0007; // 7
  543.   {$EXTERNALSYM DNS_TYPE_MB}
  544.   DNS_TYPE_MG    = $0008; // 8
  545.   {$EXTERNALSYM DNS_TYPE_MG}
  546.   DNS_TYPE_MR    = $0009; // 9
  547.   {$EXTERNALSYM DNS_TYPE_MR}
  548.   DNS_TYPE_NULL  = $000a; // 10
  549.   {$EXTERNALSYM DNS_TYPE_NULL}
  550.   DNS_TYPE_WKS   = $000b; // 11
  551.   {$EXTERNALSYM DNS_TYPE_WKS}
  552.   DNS_TYPE_PTR   = $000c; // 12
  553.   {$EXTERNALSYM DNS_TYPE_PTR}
  554.   DNS_TYPE_HINFO = $000d; // 13
  555.   {$EXTERNALSYM DNS_TYPE_HINFO}
  556.   DNS_TYPE_MINFO = $000e; // 14
  557.   {$EXTERNALSYM DNS_TYPE_MINFO}
  558.   DNS_TYPE_MX    = $000f; // 15
  559.   {$EXTERNALSYM DNS_TYPE_MX}
  560.   DNS_TYPE_TEXT  = $0010; // 16
  561.   {$EXTERNALSYM DNS_TYPE_TEXT}
  563. //  RFC 1183
  564.   DNS_TYPE_RP    = $0011; // 17
  565.   {$EXTERNALSYM DNS_TYPE_RP}
  566.   DNS_TYPE_AFSDB = $0012; // 18
  567.   {$EXTERNALSYM DNS_TYPE_AFSDB}
  568.   DNS_TYPE_X25   = $0013; // 19
  569.   {$EXTERNALSYM DNS_TYPE_X25}
  570.   DNS_TYPE_ISDN  = $0014; // 20
  571.   {$EXTERNALSYM DNS_TYPE_ISDN}
  572.   DNS_TYPE_RT    = $0015; // 21
  573.   {$EXTERNALSYM DNS_TYPE_RT}
  575. //  RFC 1348
  576.   DNS_TYPE_NSAP    = $0016; // 22
  577.   {$EXTERNALSYM DNS_TYPE_NSAP}
  578.   DNS_TYPE_NSAPPTR = $0017; // 23
  579.   {$EXTERNALSYM DNS_TYPE_NSAPPTR}
  581. //  RFC 2065    (DNS security)
  582.   DNS_TYPE_SIG = $0018; // 24
  583.   {$EXTERNALSYM DNS_TYPE_SIG}
  584.   DNS_TYPE_KEY = $0019; // 25
  585.   {$EXTERNALSYM DNS_TYPE_KEY}
  587. //  RFC 1664    (X.400 mail)
  588.   DNS_TYPE_PX = $001a; // 26
  589.   {$EXTERNALSYM DNS_TYPE_PX}
  591. //  RFC 1712    (Geographic position)
  592.   DNS_TYPE_GPOS = $001b; // 27
  593.   {$EXTERNALSYM DNS_TYPE_GPOS}
  595. //  RFC 1886    (IPv6 Address)
  596.   DNS_TYPE_AAAA = $001c; // 28
  597.   {$EXTERNALSYM DNS_TYPE_AAAA}
  599. //  RFC 1876    (Geographic location)
  600.   DNS_TYPE_LOC = $001d; // 29
  601.   {$EXTERNALSYM DNS_TYPE_LOC}
  603. //  RFC 2065    (Secure negative response)
  604.   DNS_TYPE_NXT = $001e; // 30
  605.   {$EXTERNALSYM DNS_TYPE_NXT}
  607. //  Patton      (Endpoint Identifier)
  608.   DNS_TYPE_EID = $001f; // 31
  609.   {$EXTERNALSYM DNS_TYPE_EID}
  611. //  Patton      (Nimrod Locator)
  612.   DNS_TYPE_NIMLOC = $0020; // 32
  613.   {$EXTERNALSYM DNS_TYPE_NIMLOC}
  615. //  RFC 2052    (Service location)
  616.   DNS_TYPE_SRV = $0021; // 33
  617.   {$EXTERNALSYM DNS_TYPE_SRV}
  619. //  ATM Standard something-or-another (ATM Address)
  620.   DNS_TYPE_ATMA = $0022; // 34
  621.   {$EXTERNALSYM DNS_TYPE_ATMA}
  623. //  RFC 2168    (Naming Authority Pointer)
  624.   DNS_TYPE_NAPTR = $0023; // 35
  625.   {$EXTERNALSYM DNS_TYPE_NAPTR}
  627. //  RFC 2230    (Key Exchanger)
  628.   DNS_TYPE_KX = $0024; // 36
  629.   {$EXTERNALSYM DNS_TYPE_KX}
  631. //  RFC 2538    (CERT)
  632.   DNS_TYPE_CERT = $0025; // 37
  633.   {$EXTERNALSYM DNS_TYPE_CERT}
  635. //  A6 Draft    (A6)
  636.   DNS_TYPE_A6 = $0026; // 38
  637.   {$EXTERNALSYM DNS_TYPE_A6}
  639. //  DNAME Draft (DNAME)
  640.   DNS_TYPE_DNAME = $0027; // 39
  641.   {$EXTERNALSYM DNS_TYPE_DNAME}
  643. //  Eastlake    (Kitchen Sink)
  644.   DNS_TYPE_SINK = $0028; // 40
  645.   {$EXTERNALSYM DNS_TYPE_SINK}
  647. //  RFC 2671    (EDNS OPT)
  648.   DNS_TYPE_OPT = $0029; // 41
  649.   {$EXTERNALSYM DNS_TYPE_OPT}
  651. //
  652. //  IANA Reserved
  653. //
  655.   DNS_TYPE_UINFO  = $0064; // 100
  656.   {$EXTERNALSYM DNS_TYPE_UINFO}
  657.   DNS_TYPE_UID    = $0065; // 101
  658.   {$EXTERNALSYM DNS_TYPE_UID}
  659.   DNS_TYPE_GID    = $0066; // 102
  660.   {$EXTERNALSYM DNS_TYPE_GID}
  661.   DNS_TYPE_UNSPEC = $0067; // 103
  662.   {$EXTERNALSYM DNS_TYPE_UNSPEC}
  664. //
  665. //  Query only types (1035, 1995)
  666. //      - Crawford      (ADDRS)
  667. //      - TKEY draft    (TKEY)
  668. //      - TSIG draft    (TSIG)
  669. //      - RFC 1995      (IXFR)
  670. //      - RFC 1035      (AXFR up)
  671. //
  673.   DNS_TYPE_ADDRS = $00f8; // 248
  674.   {$EXTERNALSYM DNS_TYPE_ADDRS}
  675.   DNS_TYPE_TKEY  = $00f9; // 249
  676.   {$EXTERNALSYM DNS_TYPE_TKEY}
  677.   DNS_TYPE_TSIG  = $00fa; // 250
  678.   {$EXTERNALSYM DNS_TYPE_TSIG}
  679.   DNS_TYPE_IXFR  = $00fb; // 251
  680.   {$EXTERNALSYM DNS_TYPE_IXFR}
  681.   DNS_TYPE_AXFR  = $00fc; // 252
  682.   {$EXTERNALSYM DNS_TYPE_AXFR}
  683.   DNS_TYPE_MAILB = $00fd; // 253
  684.   {$EXTERNALSYM DNS_TYPE_MAILB}
  685.   DNS_TYPE_MAILA = $00fe; // 254
  686.   {$EXTERNALSYM DNS_TYPE_MAILA}
  687.   DNS_TYPE_ALL   = $00ff; // 255
  688.   {$EXTERNALSYM DNS_TYPE_ALL}
  689.   DNS_TYPE_ANY   = $00ff; // 255
  690.   {$EXTERNALSYM DNS_TYPE_ANY}
  692. //
  693. //  Temp Microsoft types -- use until get IANA approval for real type
  694. //
  696.   DNS_TYPE_WINS   = $ff01; // 64K - 255
  697.   {$EXTERNALSYM DNS_TYPE_WINS}
  698.   DNS_TYPE_WINSR  = $ff02; // 64K - 254
  699.   {$EXTERNALSYM DNS_TYPE_WINSR}
  700.   DNS_TYPE_NBSTAT = (DNS_TYPE_WINSR);
  701.   {$EXTERNALSYM DNS_TYPE_NBSTAT}
  704. //
  705. //  DNS Record Types -- Net Byte Order
  706. //
  708.   DNS_RTYPE_A       = $0100; // 1
  709.   {$EXTERNALSYM DNS_RTYPE_A}
  710.   DNS_RTYPE_NS      = $0200; // 2
  711.   {$EXTERNALSYM DNS_RTYPE_NS}
  712.   DNS_RTYPE_MD      = $0300; // 3
  713.   {$EXTERNALSYM DNS_RTYPE_MD}
  714.   DNS_RTYPE_MF      = $0400; // 4
  715.   {$EXTERNALSYM DNS_RTYPE_MF}
  716.   DNS_RTYPE_CNAME   = $0500; // 5
  717.   {$EXTERNALSYM DNS_RTYPE_CNAME}
  718.   DNS_RTYPE_SOA     = $0600; // 6
  719.   {$EXTERNALSYM DNS_RTYPE_SOA}
  720.   DNS_RTYPE_MB      = $0700; // 7
  721.   {$EXTERNALSYM DNS_RTYPE_MB}
  722.   DNS_RTYPE_MG      = $0800; // 8
  723.   {$EXTERNALSYM DNS_RTYPE_MG}
  724.   DNS_RTYPE_MR      = $0900; // 9
  725.   {$EXTERNALSYM DNS_RTYPE_MR}
  726.   DNS_RTYPE_NULL    = $0a00; // 10
  727.   {$EXTERNALSYM DNS_RTYPE_NULL}
  728.   DNS_RTYPE_WKS     = $0b00; // 11
  729.   {$EXTERNALSYM DNS_RTYPE_WKS}
  730.   DNS_RTYPE_PTR     = $0c00; // 12
  731.   {$EXTERNALSYM DNS_RTYPE_PTR}
  732.   DNS_RTYPE_HINFO   = $0d00; // 13
  733.   {$EXTERNALSYM DNS_RTYPE_HINFO}
  734.   DNS_RTYPE_MINFO   = $0e00; // 14
  735.   {$EXTERNALSYM DNS_RTYPE_MINFO}
  736.   DNS_RTYPE_MX      = $0f00; // 15
  737.   {$EXTERNALSYM DNS_RTYPE_MX}
  738.   DNS_RTYPE_TEXT    = $1000; // 16
  739.   {$EXTERNALSYM DNS_RTYPE_TEXT}
  740.   DNS_RTYPE_RP      = $1100; // 17
  741.   {$EXTERNALSYM DNS_RTYPE_RP}
  742.   DNS_RTYPE_AFSDB   = $1200; // 18
  743.   {$EXTERNALSYM DNS_RTYPE_AFSDB}
  744.   DNS_RTYPE_X25     = $1300; // 19
  745.   {$EXTERNALSYM DNS_RTYPE_X25}
  746.   DNS_RTYPE_ISDN    = $1400; // 20
  747.   {$EXTERNALSYM DNS_RTYPE_ISDN}
  748.   DNS_RTYPE_RT      = $1500; // 21
  749.   {$EXTERNALSYM DNS_RTYPE_RT}
  750.   DNS_RTYPE_NSAP    = $1600; // 22
  751.   {$EXTERNALSYM DNS_RTYPE_NSAP}
  752.   DNS_RTYPE_NSAPPTR = $1700; // 23
  753.   {$EXTERNALSYM DNS_RTYPE_NSAPPTR}
  754.   DNS_RTYPE_SIG     = $1800; // 24
  755.   {$EXTERNALSYM DNS_RTYPE_SIG}
  756.   DNS_RTYPE_KEY     = $1900; // 25
  757.   {$EXTERNALSYM DNS_RTYPE_KEY}
  758.   DNS_RTYPE_PX      = $1a00; // 26
  759.   {$EXTERNALSYM DNS_RTYPE_PX}
  760.   DNS_RTYPE_GPOS    = $1b00; // 27
  761.   {$EXTERNALSYM DNS_RTYPE_GPOS}
  762.   DNS_RTYPE_AAAA    = $1c00; // 28
  763.   {$EXTERNALSYM DNS_RTYPE_AAAA}
  764.   DNS_RTYPE_LOC     = $1d00; // 29
  765.   {$EXTERNALSYM DNS_RTYPE_LOC}
  766.   DNS_RTYPE_NXT     = $1e00; // 30
  767.   {$EXTERNALSYM DNS_RTYPE_NXT}
  768.   DNS_RTYPE_EID     = $1f00; // 31
  769.   {$EXTERNALSYM DNS_RTYPE_EID}
  770.   DNS_RTYPE_NIMLOC  = $2000; // 32
  771.   {$EXTERNALSYM DNS_RTYPE_NIMLOC}
  772.   DNS_RTYPE_SRV     = $2100; // 33
  773.   {$EXTERNALSYM DNS_RTYPE_SRV}
  774.   DNS_RTYPE_ATMA    = $2200; // 34
  775.   {$EXTERNALSYM DNS_RTYPE_ATMA}
  776.   DNS_RTYPE_NAPTR   = $2300; // 35
  777.   {$EXTERNALSYM DNS_RTYPE_NAPTR}
  778.   DNS_RTYPE_KX      = $2400; // 36
  779.   {$EXTERNALSYM DNS_RTYPE_KX}
  780.   DNS_RTYPE_CERT    = $2500; // 37
  781.   {$EXTERNALSYM DNS_RTYPE_CERT}
  782.   DNS_RTYPE_A6      = $2600; // 38
  783.   {$EXTERNALSYM DNS_RTYPE_A6}
  784.   DNS_RTYPE_DNAME   = $2700; // 39
  785.   {$EXTERNALSYM DNS_RTYPE_DNAME}
  786.   DNS_RTYPE_SINK    = $2800; // 40
  787.   {$EXTERNALSYM DNS_RTYPE_SINK}
  788.   DNS_RTYPE_OPT     = $2900; // 41
  789.   {$EXTERNALSYM DNS_RTYPE_OPT}
  791. //
  792. //  IANA Reserved
  793. //
  795.   DNS_RTYPE_UINFO  = $6400; // 100
  796.   {$EXTERNALSYM DNS_RTYPE_UINFO}
  797.   DNS_RTYPE_UID    = $6500; // 101
  798.   {$EXTERNALSYM DNS_RTYPE_UID}
  799.   DNS_RTYPE_GID    = $6600; // 102
  800.   {$EXTERNALSYM DNS_RTYPE_GID}
  801.   DNS_RTYPE_UNSPEC = $6700; // 103
  802.   {$EXTERNALSYM DNS_RTYPE_UNSPEC}
  804. //
  805. //  Query only types
  806. //
  808.   DNS_RTYPE_TKEY  = $f900; // 249
  809.   {$EXTERNALSYM DNS_RTYPE_TKEY}
  810.   DNS_RTYPE_TSIG  = $fa00; // 250
  811.   {$EXTERNALSYM DNS_RTYPE_TSIG}
  812.   DNS_RTYPE_IXFR  = $fb00; // 251
  813.   {$EXTERNALSYM DNS_RTYPE_IXFR}
  814.   DNS_RTYPE_AXFR  = $fc00; // 252
  815.   {$EXTERNALSYM DNS_RTYPE_AXFR}
  816.   DNS_RTYPE_MAILB = $fd00; // 253
  817.   {$EXTERNALSYM DNS_RTYPE_MAILB}
  818.   DNS_RTYPE_MAILA = $fe00; // 254
  819.   {$EXTERNALSYM DNS_RTYPE_MAILA}
  820.   DNS_RTYPE_ALL   = $ff00; // 255
  821.   {$EXTERNALSYM DNS_RTYPE_ALL}
  822.   DNS_RTYPE_ANY   = $ff00; // 255
  823.   {$EXTERNALSYM DNS_RTYPE_ANY}
  825. //
  826. //  Temp Microsoft types -- use until get IANA approval for real type
  827. //
  829.   DNS_RTYPE_WINS  = $01ff; // 64K - 255
  830.   {$EXTERNALSYM DNS_RTYPE_WINS}
  831.   DNS_RTYPE_WINSR = $02ff; // 64K - 254
  832.   {$EXTERNALSYM DNS_RTYPE_WINSR}
  834. //
  835. //  Record type specific definitions
  836. //
  838. //
  839. //  ATMA (ATM address type) formats
  840. //
  841. //  Define these directly for any environment (ex NT4)
  842. //  without winsock2 ATM support (ws2atm.h)
  843. //
  845. {$IFNDEF ATMA_E164}
  846.   DNS_ATMA_FORMAT_E164     = 1;
  847.   {$EXTERNALSYM DNS_ATMA_FORMAT_E164}
  848.   DNS_ATMA_FORMAT_AESA     = 2;
  849.   {$EXTERNALSYM DNS_ATMA_FORMAT_AESA}
  850.   DNS_ATMA_MAX_ADDR_LENGTH = (20);
  851.   {$EXTERNALSYM DNS_ATMA_MAX_ADDR_LENGTH}
  852. {$ELSE}
  853.   DNS_ATMA_FORMAT_E164     = ATM_E164;
  854.   {$EXTERNALSYM DNS_ATMA_FORMAT_E164}
  855.   DNS_ATMA_FORMAT_AESA     = ATM_AESA;
  856.   {$EXTERNALSYM DNS_ATMA_FORMAT_AESA}
  857.   DNS_ATMA_MAX_ADDR_LENGTH = ATM_ADDR_SIZE;
  858.   {$EXTERNALSYM DNS_ATMA_MAX_ADDR_LENGTH}
  859. {$ENDIF}
  861.   DNS_ATMA_AESA_ADDR_LENGTH  = (20);
  862.   {$EXTERNALSYM DNS_ATMA_AESA_ADDR_LENGTH}
  863.   DNS_ATMA_MAX_RECORD_LENGTH = (DNS_ATMA_MAX_ADDR_LENGTH+1);
  864.   {$EXTERNALSYM DNS_ATMA_MAX_RECORD_LENGTH}
  866. //
  867. //  DNSSEC defs
  868. //
  870. //  DNSSEC algorithms
  872.   DNSSEC_ALGORITHM_RSAMD5  = 1;
  873.   {$EXTERNALSYM DNSSEC_ALGORITHM_RSAMD5}
  874.   DNSSEC_ALGORITHM_NULL    = 253;
  875.   {$EXTERNALSYM DNSSEC_ALGORITHM_NULL}
  876.   DNSSEC_ALGORITHM_PRIVATE = 254;
  877.   {$EXTERNALSYM DNSSEC_ALGORITHM_PRIVATE}
  879. //  DNSSEC KEY protocol table
  881.   DNSSEC_PROTOCOL_NONE   = 0;
  882.   {$EXTERNALSYM DNSSEC_PROTOCOL_NONE}
  883.   DNSSEC_PROTOCOL_TLS    = 1;
  884.   {$EXTERNALSYM DNSSEC_PROTOCOL_TLS}
  885.   DNSSEC_PROTOCOL_EMAIL  = 2;
  886.   {$EXTERNALSYM DNSSEC_PROTOCOL_EMAIL}
  887.   DNSSEC_PROTOCOL_DNSSEC = 3;
  888.   {$EXTERNALSYM DNSSEC_PROTOCOL_DNSSEC}
  889.   DNSSEC_PROTOCOL_IPSEC  = 4;
  890.   {$EXTERNALSYM DNSSEC_PROTOCOL_IPSEC}
  892. //  DNSSEC KEY flag field
  894.   DNSSEC_KEY_FLAG_NOAUTH = $0001;
  895.   {$EXTERNALSYM DNSSEC_KEY_FLAG_NOAUTH}
  896.   DNSSEC_KEY_FLAG_NOCONF = $0002;
  897.   {$EXTERNALSYM DNSSEC_KEY_FLAG_NOCONF}
  898.   DNSSEC_KEY_FLAG_FLAG2  = $0004;
  899.   {$EXTERNALSYM DNSSEC_KEY_FLAG_FLAG2}
  900.   DNSSEC_KEY_FLAG_EXTEND = $0008;
  901.   {$EXTERNALSYM DNSSEC_KEY_FLAG_EXTEND}
  902. {$DEFINE DNSSEC_KEY_FLAG_}
  903.   DNSSEC_KEY_FLAG_FLAG4 = $0010;
  904.   {$EXTERNALSYM DNSSEC_KEY_FLAG_FLAG4}
  905.   DNSSEC_KEY_FLAG_FLAG5 = $0020;
  906.   {$EXTERNALSYM DNSSEC_KEY_FLAG_FLAG5}
  908. // bits 6,7 are name type
  910.   DNSSEC_KEY_FLAG_USER  = $0000;
  911.   {$EXTERNALSYM DNSSEC_KEY_FLAG_USER}
  912.   DNSSEC_KEY_FLAG_ZONE  = $0040;
  913.   {$EXTERNALSYM DNSSEC_KEY_FLAG_ZONE}
  914.   DNSSEC_KEY_FLAG_HOST  = $0080;
  915.   {$EXTERNALSYM DNSSEC_KEY_FLAG_HOST}
  916.   DNSSEC_KEY_FLAG_NTPE3 = $00c0;
  917.   {$EXTERNALSYM DNSSEC_KEY_FLAG_NTPE3}
  919. // bits 8-11 are reserved for future use
  921.   DNSSEC_KEY_FLAG_FLAG8  = $0100;
  922.   {$EXTERNALSYM DNSSEC_KEY_FLAG_FLAG8}
  923.   DNSSEC_KEY_FLAG_FLAG9  = $0200;
  924.   {$EXTERNALSYM DNSSEC_KEY_FLAG_FLAG9}
  925.   DNSSEC_KEY_FLAG_FLAG10 = $0400;
  926.   {$EXTERNALSYM DNSSEC_KEY_FLAG_FLAG10}
  927.   DNSSEC_KEY_FLAG_FLAG11 = $0800;
  928.   {$EXTERNALSYM DNSSEC_KEY_FLAG_FLAG11}
  930. // bits 12-15 are sig field
  932.   DNSSEC_KEY_FLAG_SIG0  = $0000;
  933.   {$EXTERNALSYM DNSSEC_KEY_FLAG_SIG0}
  934.   DNSSEC_KEY_FLAG_SIG1  = $1000;
  935.   {$EXTERNALSYM DNSSEC_KEY_FLAG_SIG1}
  936.   DNSSEC_KEY_FLAG_SIG2  = $2000;
  937.   {$EXTERNALSYM DNSSEC_KEY_FLAG_SIG2}
  938.   DNSSEC_KEY_FLAG_SIG3  = $3000;
  939.   {$EXTERNALSYM DNSSEC_KEY_FLAG_SIG3}
  940.   DNSSEC_KEY_FLAG_SIG4  = $4000;
  941.   {$EXTERNALSYM DNSSEC_KEY_FLAG_SIG4}
  942.   DNSSEC_KEY_FLAG_SIG5  = $5000;
  943.   {$EXTERNALSYM DNSSEC_KEY_FLAG_SIG5}
  944.   DNSSEC_KEY_FLAG_SIG6  = $6000;
  945.   {$EXTERNALSYM DNSSEC_KEY_FLAG_SIG6}
  946.   DNSSEC_KEY_FLAG_SIG7  = $7000;
  947.   {$EXTERNALSYM DNSSEC_KEY_FLAG_SIG7}
  948.   DNSSEC_KEY_FLAG_SIG8  = $8000;
  949.   {$EXTERNALSYM DNSSEC_KEY_FLAG_SIG8}
  950.   DNSSEC_KEY_FLAG_SIG9  = $9000;
  951.   {$EXTERNALSYM DNSSEC_KEY_FLAG_SIG9}
  952.   DNSSEC_KEY_FLAG_SIG10 = $a000;
  953.   {$EXTERNALSYM DNSSEC_KEY_FLAG_SIG10}
  954.   DNSSEC_KEY_FLAG_SIG11 = $b000;
  955.   {$EXTERNALSYM DNSSEC_KEY_FLAG_SIG11}
  956.   DNSSEC_KEY_FLAG_SIG12 = $c000;
  957.   {$EXTERNALSYM DNSSEC_KEY_FLAG_SIG12}
  958.   DNSSEC_KEY_FLAG_SIG13 = $d000;
  959.   {$EXTERNALSYM DNSSEC_KEY_FLAG_SIG13}
  960.   DNSSEC_KEY_FLAG_SIG14 = $e000;
  961.   {$EXTERNALSYM DNSSEC_KEY_FLAG_SIG14}
  962.   DNSSEC_KEY_FLAG_SIG15 = $f000;
  963.   {$EXTERNALSYM DNSSEC_KEY_FLAG_SIG15}
  965. //
  966. //  TKEY modes
  967. //
  969.   DNS_TKEY_MODE_SERVER_ASSIGN   = 1;
  970.   {$EXTERNALSYM DNS_TKEY_MODE_SERVER_ASSIGN}
  971.   DNS_TKEY_MODE_DIFFIE_HELLMAN  = 2;
  972.   {$EXTERNALSYM DNS_TKEY_MODE_DIFFIE_HELLMAN}
  973.   DNS_TKEY_MODE_GSS             = 3;
  974.   {$EXTERNALSYM DNS_TKEY_MODE_GSS}
  975.   DNS_TKEY_MODE_RESOLVER_ASSIGN = 4;
  976.   {$EXTERNALSYM DNS_TKEY_MODE_RESOLVER_ASSIGN}
  978. //
  979. //  WINS + NBSTAT flag field
  980. //
  982.   DNS_WINS_FLAG_SCOPE = DWORD($80000000);
  983.   {$EXTERNALSYM DNS_WINS_FLAG_SCOPE}
  984.   DNS_WINS_FLAG_LOCAL = ($00010000);
  985.   {$EXTERNALSYM DNS_WINS_FLAG_LOCAL}
  987. //
  988. //  Helpful checks
  989. //
  991. function IS_WORD_ALIGNED(P: Pointer): BOOL;
  992. {$EXTERNALSYM IS_DWORD_ALIGNED}
  994. function IS_DWORD_ALIGNED(P: Pointer): BOOL;
  995. {$EXTERNALSYM IS_DWORD_ALIGNED}
  997. function IS_QWORD_ALIGNED(P: Pointer): BOOL;
  998. {$EXTERNALSYM IS_QWORD_ALIGNED}
  1000. //
  1001. //  DNS config API
  1002. //
  1004. //
  1005. //  Types of DNS configuration info
  1006. //
  1008. type
  1009.   DNS_CONFIG_TYPE = (
  1010.     //  In Win2K
  1011.     DnsConfigPrimaryDomainName_W,
  1012.     DnsConfigPrimaryDomainName_A,
  1013.     DnsConfigPrimaryDomainName_UTF8,
  1015.     //  Not available yet
  1016.     DnsConfigAdapterDomainName_W,
  1017.     DnsConfigAdapterDomainName_A,
  1018.     DnsConfigAdapterDomainName_UTF8,
  1020.     //  In Win2K
  1021.     DnsConfigDnsServerList,
  1023.     //  Not available yet
  1024.     DnsConfigSearchList,
  1025.     DnsConfigAdapterInfo,
  1027.     //  In Win2K
  1028.     DnsConfigPrimaryHostNameRegistrationEnabled,
  1029.     DnsConfigAdapterHostNameRegistrationEnabled,
  1030.     DnsConfigAddressRegistrationMaxCount,
  1032.     //  In WindowsXP
  1033.     DnsConfigHostName_W,
  1034.     DnsConfigHostName_A,
  1035.     DnsConfigHostName_UTF8,
  1036.     DnsConfigFullHostName_W,
  1037.     DnsConfigFullHostName_A,
  1038.     DnsConfigFullHostName_UTF8);
  1039.   {$EXTERNALSYM DNS_CONFIG_TYPE}
  1040.   TDnsConfigType = DNS_CONFIG_TYPE;
  1042. //
  1043. //  Config API flags
  1044. //
  1046. //
  1047. //  Causes config info to be allocated with LocalAlloc()
  1048. //
  1050. const
  1051.   DNS_CONFIG_FLAG_ALLOC = ($00000001);
  1052.   {$EXTERNALSYM DNS_CONFIG_FLAG_ALLOC}
  1054. function DnsQueryConfig(Config: DNS_CONFIG_TYPE; Flag: DWORD; pwsAdapterName: PWSTR; pReserved, pBuffer: PVOID; pBufferLength: PDWORD): DNS_STATUS; stdcall;
  1055. {$EXTERNALSYM DnsQueryConfig}
  1057. //
  1058. //  DNS resource record structure
  1059. //
  1061. //
  1062. //  Record data for specific types
  1063. //
  1065. type
  1066.   PDNS_A_DATA = ^DNS_A_DATA;
  1067.   {$EXTERNALSYM PDNS_A_DATA}
  1068.   DNS_A_DATA = record
  1069.     IpAddress: IP4_ADDRESS;
  1070.   end;
  1071.   {$EXTERNALSYM DNS_A_DATA}
  1072.   TDnsAData = DNS_A_DATA;
  1073.   PDnsAData = PDNS_A_DATA;
  1075.   PDNS_PTR_DATA = ^DNS_PTR_DATA;
  1076.   {$EXTERNALSYM PDNS_PTR_DATA}
  1077.   DNS_PTR_DATA = record
  1078.     pNameHost: LPTSTR;
  1079.   end;
  1080.   {$EXTERNALSYM DNS_PTR_DATA}
  1081.   TDnsPtrData = DNS_PTR_DATA;
  1082.   PDnsPtrData = PDNS_PTR_DATA;
  1084.   PDNS_SOA_DATA = ^DNS_SOA_DATA;
  1085.   {$EXTERNALSYM PDNS_SOA_DATA}
  1086.   DNS_SOA_DATA = record
  1087.     pNamePrimaryServer: LPTSTR;
  1088.     pNameAdministrator: LPTSTR;
  1089.     dwSerialNo: DWORD;
  1090.     dwRefresh: DWORD;
  1091.     dwRetry: DWORD;
  1092.     dwExpire: DWORD;
  1093.     dwDefaultTtl: DWORD;
  1094.   end;
  1095.   {$EXTERNALSYM DNS_SOA_DATA}
  1096.   TDnsSoaData = DNS_SOA_DATA;
  1097.   PDnsSoaData = PDNS_SOA_DATA;
  1099.   PDNS_MINFO_DATA = ^DNS_MINFO_DATA;
  1100.   {$EXTERNALSYM PDNS_MINFO_DATA}
  1101.   DNS_MINFO_DATA = record
  1102.     pNameMailbox: LPTSTR;
  1103.     pNameErrorsMailbox: LPTSTR;
  1104.   end;
  1105.   {$EXTERNALSYM DNS_MINFO_DATA}
  1106.   TDnsMinfoData = DNS_MINFO_DATA;
  1107.   PDnsMinfoData = PDNS_MINFO_DATA;
  1109.   PDNS_MX_DATA = ^DNS_MX_DATA;
  1110.   {$EXTERNALSYM PDNS_MX_DATA}
  1111.   DNS_MX_DATA = record
  1112.     pNameExchange: LPTSTR;
  1113.     wPreference: WORD;
  1114.     Pad: WORD; // keep ptrs DWORD aligned
  1115.   end;
  1116.   {$EXTERNALSYM DNS_MX_DATA}
  1117.   TDnsMxData = DNS_MX_DATA;
  1118.   PDnsMxData = PDNS_MX_DATA;
  1120.   PDNS_TXT_DATA = ^DNS_TXT_DATA;
  1121.   {$EXTERNALSYM PDNS_TXT_DATA}
  1122.   DNS_TXT_DATA = record
  1123.     dwStringCount: DWORD;
  1124.     pStringArray: array [0..0] of LPTSTR;
  1125.   end;
  1126.   {$EXTERNALSYM DNS_TXT_DATA}
  1127.   TDnsTxtData = DNS_TXT_DATA;
  1128.   PDnsTxtData = PDNS_TXT_DATA;
  1130.   PDNS_NULL_DATA = ^DNS_NULL_DATA;
  1131.   {$EXTERNALSYM PDNS_NULL_DATA}
  1132.   DNS_NULL_DATA = record
  1133.     dwByteCount: DWORD;
  1134.     Data: array [0..0] of BYTE;
  1135.   end;
  1136.   {$EXTERNALSYM DNS_NULL_DATA}
  1137.   TDnsNullData = DNS_NULL_DATA;
  1138.   PDnsNullData = PDNS_NULL_DATA;
  1140.   PDNS_WKS_DATA = ^DNS_WKS_DATA;
  1141.   {$EXTERNALSYM PDNS_WKS_DATA}
  1142.   DNS_WKS_DATA = record
  1143.     IpAddress: IP4_ADDRESS;
  1144.     chProtocol: UCHAR;
  1145.     BitMask: array [0..0] of BYTE;
  1146.   end;
  1147.   {$EXTERNALSYM DNS_WKS_DATA}
  1148.   TDnsWksData = DNS_WKS_DATA;
  1149.   PDnsWksData = PDNS_WKS_DATA;
  1151.   PDNS_AAAA_DATA = ^DNS_AAAA_DATA;
  1152.   {$EXTERNALSYM PDNS_AAAA_DATA}
  1153.   DNS_AAAA_DATA = record
  1154.     Ip6Address: DNS_IP6_ADDRESS;
  1155.   end;
  1156.   {$EXTERNALSYM DNS_AAAA_DATA}
  1157.   TDnsAaaaData = DNS_AAAA_DATA;
  1158.   PDnsAaaaData = PDNS_AAAA_DATA;
  1160.   PDNS_SIG_DATA = ^DNS_SIG_DATA;
  1161.   {$EXTERNALSYM PDNS_SIG_DATA}
  1162.   DNS_SIG_DATA = record
  1163.     pNameSigner: LPTSTR;
  1164.     wTypeCovered: WORD;
  1165.     chAlgorithm: BYTE;
  1166.     chLabelCount: BYTE;
  1167.     dwOriginalTtl: DWORD;
  1168.     dwExpiration: DWORD;
  1169.     dwTimeSigned: DWORD;
  1170.     wKeyTag: WORD;
  1171.     Pad: WORD; // keep byte field aligned
  1172.     Signature: array [0..0] of BYTE;
  1173.   end;
  1174.   {$EXTERNALSYM DNS_SIG_DATA}
  1175.   TDnsSigData = DNS_SIG_DATA;
  1176.   PDnsSigData = PDNS_SIG_DATA;
  1178.   PDNS_KEY_DATA = ^DNS_KEY_DATA;
  1179.   {$EXTERNALSYM PDNS_KEY_DATA}
  1180.   DNS_KEY_DATA = record
  1181.     wFlags: WORD;
  1182.     chProtocol: BYTE;
  1183.     chAlgorithm: BYTE;
  1184.     Key: array [0..1 - 1] of BYTE;
  1185.   end;
  1186.   {$EXTERNALSYM DNS_KEY_DATA}
  1187.   TDnsKeyData = DNS_KEY_DATA;
  1188.   PDnsKeyData = PDNS_KEY_DATA;
  1190.   PDNS_LOC_DATA = ^DNS_LOC_DATA;
  1191.   {$EXTERNALSYM PDNS_LOC_DATA}
  1192.   DNS_LOC_DATA = record
  1193.     wVersion: WORD;
  1194.     wSize: WORD;
  1195.     wHorPrec: WORD;
  1196.     wVerPrec: WORD;
  1197.     dwLatitude: DWORD;
  1198.     dwLongitude: DWORD;
  1199.     dwAltitude: DWORD;
  1200.   end;
  1201.   {$EXTERNALSYM DNS_LOC_DATA}
  1202.   TDnsLocData = DNS_LOC_DATA;
  1203.   PDnsLocData = PDNS_LOC_DATA;
  1205.   PDNS_NXT_DATA = ^DNS_NXT_DATA;
  1206.   {$EXTERNALSYM PDNS_NXT_DATA}
  1207.   DNS_NXT_DATA = record
  1208.     pNameNext: LPTSTR;
  1209.     wNumTypes: WORD;
  1210.     wTypes: array [0..0] of WORD;
  1211.   end;
  1212.   {$EXTERNALSYM DNS_NXT_DATA}
  1213.   TDnsNxtData = DNS_NXT_DATA;
  1214.   PDnsNxtData = PDNS_NXT_DATA;
  1216.   PDNS_SRV_DATA = ^DNS_SRV_DATA;
  1217.   {$EXTERNALSYM PDNS_SRV_DATA}
  1218.   DNS_SRV_DATA = record
  1219.     pNameTarget: LPTSTR;
  1220.     wPriority: WORD;
  1221.     wWeight: WORD;
  1222.     wPort: WORD;
  1223.     Pad: WORD; // keep ptrs DWORD aligned
  1224.   end;
  1225.   {$EXTERNALSYM DNS_SRV_DATA}
  1226.   TDnsSrvData = DNS_SRV_DATA;
  1227.   PDnsSrvData = PDNS_SRV_DATA;
  1229.   PDNS_ATMA_DATA = ^DNS_ATMA_DATA;
  1230.   {$EXTERNALSYM PDNS_ATMA_DATA}
  1231.   DNS_ATMA_DATA = record
  1232.     AddressType: BYTE;
  1233.     Address: array [0..DNS_ATMA_MAX_ADDR_LENGTH - 1] of BYTE;
  1234.     //  E164 -- Null terminated string of less than
  1235.     //      DNS_ATMA_MAX_ADDR_LENGTH
  1236.     //
  1237.     //  For NSAP (AESA) BCD encoding of exactly
  1238.     //      DNS_ATMA_AESA_ADDR_LENGTH
  1239.   end;
  1240.   {$EXTERNALSYM DNS_ATMA_DATA}
  1241.   TDnsAtmaData = DNS_ATMA_DATA;
  1242.   PDnsAtmaData = PDNS_ATMA_DATA;
  1244.   PDNS_TKEY_DATA = ^DNS_TKEY_DATA;
  1245.   {$EXTERNALSYM PDNS_TKEY_DATA}
  1246.   DNS_TKEY_DATA = record
  1247.     pNameAlgorithm: LPTSTR;
  1248.     pAlgorithmPacket: PBYTE;
  1249.     pKey: PBYTE;
  1250.     pOtherData: PBYTE;
  1251.     dwCreateTime: DWORD;
  1252.     dwExpireTime: DWORD;
  1253.     wMode: WORD;
  1254.     wError: WORD;
  1255.     wKeyLength: WORD;
  1256.     wOtherLength: WORD;
  1257.     cAlgNameLength: UCHAR;
  1258.     bPacketPointers: BOOL;
  1259.   end;
  1260.   {$EXTERNALSYM DNS_TKEY_DATA}
  1261.   TDnsTkeyData = DNS_TKEY_DATA;
  1262.   PDnsTkeyData = PDNS_TKEY_DATA;
  1264.   PDNS_TSIG_DATA = ^DNS_TSIG_DATA;
  1265.   {$EXTERNALSYM PDNS_TSIG_DATA}
  1266.   DNS_TSIG_DATA = record
  1267.     pNameAlgorithm: LPTSTR;
  1268.     pAlgorithmPacket: PBYTE;
  1269.     pSignature: PBYTE;
  1270.     pOtherData: PBYTE;
  1271.     i64CreateTime: LONGLONG;
  1272.     wFudgeTime: WORD;
  1273.     wOriginalXid: WORD;
  1274.     wError: WORD;
  1275.     wSigLength: WORD;
  1276.     wOtherLength: WORD;
  1277.     cAlgNameLength: UCHAR;
  1278.     bPacketPointers: BOOL;
  1279.   end;
  1280.   {$EXTERNALSYM DNS_TSIG_DATA}
  1281.   TDnsTsigData = DNS_TSIG_DATA;
  1282.   PDnsTsigData = PDNS_TSIG_DATA;
  1285. //
  1286. //  MS only types -- only hit the wire in MS-MS zone transfer
  1287. //
  1289.   PDNS_WINS_DATA = ^DNS_WINS_DATA;
  1290.   {$EXTERNALSYM PDNS_WINS_DATA}
  1291.   DNS_WINS_DATA = record
  1292.     dwMappingFlag: DWORD;
  1293.     dwLookupTimeout: DWORD;
  1294.     dwCacheTimeout: DWORD;
  1295.     cWinsServerCount: DWORD;
  1296.     WinsServers: array [0..0] of IP4_ADDRESS;
  1297.   end;
  1298.   {$EXTERNALSYM DNS_WINS_DATA}
  1299.   TDnsWinsData = DNS_WINS_DATA;
  1300.   PDnsWinsData = PDNS_WINS_DATA;
  1302.   PDNS_WINSR_DATA = ^DNS_WINSR_DATA;
  1303.   {$EXTERNALSYM PDNS_WINSR_DATA}
  1304.   DNS_WINSR_DATA = record
  1305.     dwMappingFlag: DWORD;
  1306.     dwLookupTimeout: DWORD;
  1307.     dwCacheTimeout: DWORD;
  1308.     pNameResultDomain: LPTSTR;
  1309.   end;
  1310.   {$EXTERNALSYM DNS_WINSR_DATA}
  1311.   TDnsWinsrData = DNS_WINSR_DATA;
  1312.   PDnsWinsrData = PDNS_WINSR_DATA;
  1314. //
  1315. //  Length of non-fixed-length data types
  1316. //
  1318. function DNS_TEXT_RECORD_LENGTH(StringCount: Integer): Integer;
  1319. {$EXTERNALSYM DNS_TEXT_RECORD_LENGTH}
  1321. function DNS_NULL_RECORD_LENGTH(ByteCount: Integer): Integer;
  1322. {$EXTERNALSYM DNS_NULL_RECORD_LENGTH}
  1324. function DNS_WKS_RECORD_LENGTH(ByteCount: Integer): Integer;
  1325. {$EXTERNALSYM DNS_WKS_RECORD_LENGTH}
  1327. //function DNS_WINS_RECORD_LENGTH(IpCount: Integer): Integer;
  1328. //{$EXTERNALSYM DNS_WINS_RECORD_LENGTH}
  1330. //
  1331. //  Record flags
  1332. //
  1334. type
  1335.   _DnsRecordFlags = record
  1336.     //DWORD   Section     : 2;
  1337.     //DWORD   Delete      : 1;
  1338.     //DWORD   CharSet     : 2;
  1339.     //DWORD   Unused      : 3;
  1340.     //DWORD   Reserved    : 24;
  1341.     Flags: DWORD;
  1342.   end;
  1343.   {$EXTERNALSYM _DnsRecordFlags}
  1344.   DNS_RECORD_FLAGS = _DnsRecordFlags;
  1345.   {$EXTERNALSYM DNS_RECORD_FLAGS}
  1346.   TDnsRecordFlags = DNS_RECORD_FLAGS;
  1347.   PDnsRecordFlags = ^DNS_RECORD_FLAGS;
  1349. //
  1350. //  Wire Record Sections
  1351. //
  1352. //  Useable both in record flags "Section" and as index into
  1353. //  wire message header section counts.
  1354. //
  1356.   _DnsSection = (
  1357.     DnsSectionQuestion,
  1358.     DnsSectionAnswer,
  1359.     DnsSectionAuthority,
  1360.     DnsSectionAddtional);
  1361.   {$EXTERNALSYM _DnsSection}
  1362.   DNS_SECTION = _DnsSection;
  1363.   TDnsSection = _DnsSection;
  1365. //  Update message section names
  1367. const
  1368.   DnsSectionZone   = DnsSectionQuestion;
  1369.   {$EXTERNALSYM DnsSectionZone}
  1370.   DnsSectionPrereq = DnsSectionAnswer;
  1371.   {$EXTERNALSYM DnsSectionPrereq}
  1372.   DnsSectionUpdate = DnsSectionAuthority;
  1373.   {$EXTERNALSYM DnsSectionUpdate}
  1375. //
  1376. //  Record flags as bit flags
  1377. //  These may be or'd together to set the fields
  1378. //
  1380. //  RR Section in packet
  1382.   DNSREC_SECTION = ($00000003);
  1383.   {$EXTERNALSYM DNSREC_SECTION}
  1385.   DNSREC_QUESTION   = ($00000000);
  1386.   {$EXTERNALSYM DNSREC_QUESTION}
  1387.   DNSREC_ANSWER     = ($00000001);
  1388.   {$EXTERNALSYM DNSREC_ANSWER}
  1389.   DNSREC_AUTHORITY  = ($00000002);
  1390.   {$EXTERNALSYM DNSREC_AUTHORITY}
  1391.   DNSREC_ADDITIONAL = ($00000003);
  1392.   {$EXTERNALSYM DNSREC_ADDITIONAL}
  1394. //  RR Section in packet (update)
  1396.   DNSREC_ZONE   = ($00000000);
  1397.   {$EXTERNALSYM DNSREC_ZONE}
  1398.   DNSREC_PREREQ = ($00000001);
  1399.   {$EXTERNALSYM DNSREC_PREREQ}
  1400.   DNSREC_UPDATE = ($00000002);
  1401.   {$EXTERNALSYM DNSREC_UPDATE}
  1403. //  Delete RR (update) or No-exist (prerequisite)
  1405.   DNSREC_DELETE  = ($00000004);
  1406.   {$EXTERNALSYM DNSREC_DELETE}
  1407.   DNSREC_NOEXIST = ($00000004);
  1408.   {$EXTERNALSYM DNSREC_NOEXIST}
  1410. //
  1411. //  Record  RR set structure
  1412. //
  1413. //  Note:  The dwReserved flag serves to insure that the substructures
  1414. //  start on 64-bit boundaries.  Do NOT pack this structure, as the
  1415. //  substructures may contain pointers or int64 values which are
  1416. //  properly aligned unpacked.
  1417. //
  1419. type
  1420.   PDNS_RECORD = ^DNS_RECORD;
  1421.   {$EXTERNALSYM PDNS_RECORD}
  1422.   _DnsRecord = record
  1423.     pNext: PDNS_RECORD;
  1424.     pName: LPTSTR;
  1425.     wType: WORD;
  1426.     wDataLength: WORD; // Not referenced for DNS record types defined above.
  1427.     Flags: record
  1428.     case Integer of
  1429.       0: (DW: DWORD);             // flags as DWORD
  1430.       1: (S: DNS_RECORD_FLAGS);   // flags as structure
  1431.     end;
  1432.     dwTtl: DWORD;
  1433.     dwReserved: DWORD;
  1435.     //  Record Data
  1437.     Data: record
  1438.     case Integer of
  1439.        0: (A: DNS_A_DATA);
  1440.        1: (SOA, Soa_: DNS_SOA_DATA);
  1441.        2: (PTR, Ptr_,
  1442.            NS, Ns_,
  1443.            CNAME, Cname_,
  1444.            MB, Mb_,
  1445.            MD, Md_,
  1446.            MF, Mf_,
  1447.            MG, Mg_,
  1448.            MR, Mr_: DNS_PTR_DATA);
  1449.        3: (MINFO, Minfo_,
  1450.            RP, Rp_: DNS_MINFO_DATA);
  1451.        4: (MX, Mx_,
  1452.            AFSDB, Afsdb_,
  1453.            RT, Rt_: DNS_MX_DATA);
  1454.        5: (HINFO, Hinfo_,
  1455.            ISDN, Isdn_,
  1456.            TXT, Txt_,
  1457.            X25: DNS_TXT_DATA);
  1458.        6: (Null: DNS_NULL_DATA);
  1459.        7: (WKS, Wks_: DNS_WKS_DATA);
  1460.        8: (AAAA: DNS_AAAA_DATA);
  1461.        9: (KEY, Key_: DNS_KEY_DATA);
  1462.       10: (SIG, Sig_: DNS_SIG_DATA);
  1463.       11: (ATMA, Atma_: DNS_ATMA_DATA);
  1464.       12: (NXT, Nxt_: DNS_NXT_DATA);
  1465.       13: (SRV, Srv_: DNS_SRV_DATA);
  1466.       14: (TKEY, Tkey_: DNS_TKEY_DATA);
  1467.       15: (TSIG, Tsig_: DNS_TSIG_DATA);
  1468.       16: (WINS, Wins_: DNS_WINS_DATA);
  1469.       17: (WINSR, WinsR_, NBSTAT, Nbstat_: DNS_WINSR_DATA);
  1470.     end;
  1471.    end;
  1472.   {$EXTERNALSYM _DnsRecord}
  1473.   DNS_RECORD = _DnsRecord;
  1474.   {$EXTERNALSYM DNS_RECORD}
  1475.   PPDNS_RECORD = ^PDNS_RECORD;
  1476.   {$NODEFINE PPDNS_RECORD}
  1477.   TDnsRecord = DNS_RECORD;
  1478.   PDnsRecord = PDNS_RECORD;
  1480. //
  1481. //  Header or fixed size of DNS_RECORD
  1482. //
  1484. const
  1485.   DNS_RECORD_FIXED_SIZE = 24;                // FIELD_OFFSET( DNS_RECORD, Data )
  1486.   {$EXTERNALSYM DNS_RECORD_FIXED_SIZE}
  1487.   SIZEOF_DNS_RECORD_HEADER = DNS_RECORD_FIXED_SIZE;
  1488.   {$EXTERNALSYM SIZEOF_DNS_RECORD_HEADER}
  1490. //
  1491. //  Resource record set building
  1492. //
  1493. //  pFirst points to first record in list.
  1494. //  pLast points to last record in list.
  1495. //
  1497. type
  1498.   PDnsRRSet = ^DnsRRSet;
  1499.   {$EXTERNALSYM PDnsRRSet}
  1500.   _DnsRRSet = record
  1501.     pFirstRR: PDNS_RECORD;
  1502.     pLastRR: PDNS_RECORD;
  1503.   end;
  1504.   {$EXTERNALSYM _DnsRRSet}
  1505.   DnsRRSet = _DnsRRSet;
  1506.   {$EXTERNALSYM DnsRRSet}
  1507.   TDnsrrset = DnsRRSet;
  1509. //
  1510. //  To init pFirst is NULL.
  1511. //  But pLast points at the location of the pFirst pointer -- essentially
  1512. //  treating the pFirst ptr as a DNS_RECORD.  (It is a DNS_RECORD with
  1513. //  only a pNext field, but that's the only part we use.)
  1514. //
  1515. //  Then when the first record is added to the list, the pNext field of
  1516. //  this dummy record (which corresponds to pFirst's value) is set to
  1517. //  point at the first record.  So pFirst then properly points at the
  1518. //  first record.
  1519. //
  1520. //  (This works only because pNext is the first field in a
  1521. //  DNS_RECORD structure and hence casting a PDNS_RECORD ptr to
  1522. //  PDNS_RECORD* and dereferencing yields its pNext field)
  1523. //
  1524. //  Use TERMINATE when have built RR set by grabbing records out of
  1525. //  existing set.   This makes sure that at the end, the last RR is
  1526. //  properly NULL terminated.
  1527. //
  1529. procedure DNS_RRSET_INIT(rrset: PDnsRRSet);
  1530. {$EXTERNALSYM DNS_RRSET_INIT}
  1532. //procedure DNS_RRSET_ADD(rrset, pnewRR: PDNS_RRSET);
  1533. //{$EXTERNALSYM DNS_RRSET_ADD}
  1535. procedure DNS_RRSET_TERMINATE(rrset: PDnsRRSet);
  1536. {$EXTERNALSYM DNS_RRSET_TERMINATE}
  1538. //
  1539. //  Record set manipulation
  1540. //
  1542. //
  1543. //  Record Copy
  1544. //  Record copy functions also do conversion between character sets.
  1545. //
  1546. //  Note, it might be advisable to directly expose non-Ex copy
  1547. //  functions _W, _A for record and set, to avoid exposing the
  1548. //  conversion enum.
  1549. //
  1551. type
  1552.   _DNS_CHARSET = (
  1553.     DnsCharSetUnknown,
  1554.     DnsCharSetUnicode,
  1555.     DnsCharSetUtf8,
  1556.     DnsCharSetAnsi);
  1557.   {$EXTERNALSYM _DNS_CHARSET}
  1558.   DNS_CHARSET = _DNS_CHARSET;
  1559.   {$EXTERNALSYM DNS_CHARSET}
  1560.   TDnsCharSet = DNS_CHARSET;
  1561.   PDnsCharSet = ^DNS_CHARSET;
  1563. function DnsRecordCopyEx(pRecord: PDNS_RECORD; CharSetIn: DNS_CHARSET; CharSetOut: DNS_CHARSET): PDNS_RECORD; stdcall;
  1564. {$EXTERNALSYM DnsRecordCopyEx}
  1566. function DnsRecordSetCopyEx(pRecordSet: PDNS_RECORD; CharSetIn: DNS_CHARSET; CharSetOut: DNS_CHARSET): PDNS_RECORD; stdcall;
  1567. {$EXTERNALSYM DnsRecordSetCopyEx}
  1569. {$IFDEF UNICODE}
  1571. function DnsRecordCopy(pRR: PDNS_RECORD): PDNS_RECORD;
  1572. {$EXTERNALSYM DnsRecordCopy}
  1574. function DnsRecordSetCopy(pRR: PDNS_RECORD): PDNS_RECORD;
  1575. {$EXTERNALSYM DnsRecordSetCopy}
  1577. {$ELSE}
  1579. function DnsRecordCopy(pRR: PDNS_RECORD): PDNS_RECORD;
  1580. {$EXTERNALSYM DnsRecordCopy}
  1582. function DnsRecordSetCopy(pRR: PDNS_RECORD): PDNS_RECORD;
  1583. {$EXTERNALSYM DnsRecordSetCopy}
  1585. {$ENDIF}
  1587. //
  1588. //  Record Compare
  1589. //
  1590. //  Note:  these routines only compare records of the SAME character set.
  1591. //  (ANSI, unicode or UTF8).  Furthermore the routines assume the character
  1592. //  set is indicated within the record.  If compare of user created, rather
  1593. //  than DNS API created record lists is desired, then caller should use
  1594. //  DnsRecordCopy API and compare copies.
  1595. //
  1597. function DnsRecordCompare(pRecord1: PDNS_RECORD; pRecord2: PDNS_RECORD): BOOL; stdcall;
  1598. {$EXTERNALSYM DnsRecordCompare}
  1600. function DnsRecordSetCompare(pRR1: PDNS_RECORD; pRR2: PDNS_RECORD; var ppDiff1, ppDiff2: PDNS_RECORD): BOOL; stdcall;
  1601. {$EXTERNALSYM DnsRecordSetCompare}
  1603. //
  1604. //  Detach next record set from record list
  1605. //
  1607. function DnsRecordSetDetach(pRecordList: PDNS_RECORD): PDNS_RECORD; stdcall;
  1608. {$EXTERNALSYM DnsRecordSetDetach}
  1610. //
  1611. //  Free record list
  1612. //
  1613. //  Only supported free is deep free of entire record list with LocalFree().
  1614. //  This correctly frees record list returned by DnsQuery() or DnsRecordSetCopy()
  1615. //
  1617. type
  1618.   DNS_FREE_TYPE = (DnsFreeFlat, DnsFreeRecordList);
  1619.   {$EXTERNALSYM DNS_FREE_TYPE}
  1620.   TDnsFreeType = DNS_FREE_TYPE;
  1622. procedure DnsFreeRecordListDeep(pRecordList: PDNS_RECORD; FreeType: DNS_FREE_TYPE); stdcall;
  1623. {$EXTERNALSYM DnsFreeRecordListDeep}
  1625. procedure DnsRecordListFree(pRecordList: PDNS_RECORD; FreeType: DNS_FREE_TYPE); stdcall;
  1626. {$EXTERNALSYM DnsRecordListFree}
  1628. procedure DnsFree(pData: PVOID; FreeType: DNS_FREE_TYPE); stdcall;
  1629. {$EXTERNALSYM DnsFree}
  1631. //
  1632. //  DNS Query API
  1633. //
  1635. //
  1636. //  Options for DnsQuery
  1637. //
  1639. const
  1640.   DNS_QUERY_STANDARD                  = $00000000;
  1641.   {$EXTERNALSYM DNS_QUERY_STANDARD}
  1642.   DNS_QUERY_ACCEPT_TRUNCATED_RESPONSE = $00000001;
  1643.   {$EXTERNALSYM DNS_QUERY_ACCEPT_TRUNCATED_RESPONSE}
  1644.   DNS_QUERY_USE_TCP_ONLY              = $00000002;
  1645.   {$EXTERNALSYM DNS_QUERY_USE_TCP_ONLY}
  1646.   DNS_QUERY_NO_RECURSION              = $00000004;
  1647.   {$EXTERNALSYM DNS_QUERY_NO_RECURSION}
  1648.   DNS_QUERY_BYPASS_CACHE              = $00000008;
  1649.   {$EXTERNALSYM DNS_QUERY_BYPASS_CACHE}
  1651.   DNS_QUERY_NO_WIRE_QUERY = $00000010;
  1652.   {$EXTERNALSYM DNS_QUERY_NO_WIRE_QUERY}
  1653.   DNS_QUERY_NO_LOCAL_NAME = $00000020;
  1654.   {$EXTERNALSYM DNS_QUERY_NO_LOCAL_NAME}
  1655.   DNS_QUERY_NO_HOSTS_FILE = $00000040;
  1656.   {$EXTERNALSYM DNS_QUERY_NO_HOSTS_FILE}
  1657.   DNS_QUERY_NO_NETBT      = $00000080;
  1658.   {$EXTERNALSYM DNS_QUERY_NO_NETBT}
  1660.   DNS_QUERY_WIRE_ONLY      = $00000100;
  1661.   {$EXTERNALSYM DNS_QUERY_WIRE_ONLY}
  1662.   DNS_QUERY_RETURN_MESSAGE = $00000200;
  1663.   {$EXTERNALSYM DNS_QUERY_RETURN_MESSAGE}
  1665.   DNS_QUERY_TREAT_AS_FQDN         = $00001000;
  1666.   {$EXTERNALSYM DNS_QUERY_TREAT_AS_FQDN}
  1667.   DNS_QUERY_DONT_RESET_TTL_VALUES = $00100000;
  1668.   {$EXTERNALSYM DNS_QUERY_DONT_RESET_TTL_VALUES}
  1669.   DNS_QUERY_RESERVED              = DWORD($ff000000);
  1670.   {$EXTERNALSYM DNS_QUERY_RESERVED}
  1672. //  Backward compatibility with Win2K
  1673. //  Do not use
  1675.   DNS_QUERY_CACHE_ONLY = DNS_QUERY_NO_WIRE_QUERY;
  1676.   {$EXTERNALSYM DNS_QUERY_CACHE_ONLY}
  1678. function DnsQuery_A(pszName: PCSTR; wType: WORD; Options: DWORD; aipServers: PIP4_ARRAY; ppQueryResults: PPDNS_RECORD; pReserved: PPVOID): DNS_STATUS; stdcall;
  1679. {$EXTERNALSYM DnsQuery_A}
  1681. function DnsQuery_UTF8(pszName: PCSTR; wType: WORD; Options: DWORD; aipServers: PIP4_ARRAY; ppQueryResults: PPDNS_RECORD; pReserved: PPVOID): DNS_STATUS; stdcall;
  1682. {$EXTERNALSYM DnsQuery_UTF8}
  1684. function DnsQuery_W(pszName: LPCWSTR; wType: WORD; Options: DWORD; aipServers: PIP4_ARRAY; ppQueryResults: PPDNS_RECORD; pReserved: PPVOID): DNS_STATUS; stdcall;
  1685. {$EXTERNALSYM DnsQuery_W}
  1687. {$IFDEF UNICODE}
  1688. function DnsQuery(pszName: LPCWSTR; wType: WORD; Options: DWORD; aipServers: PIP4_ARRAY; ppQueryResults: PPDNS_RECORD; pReserved: PPVOID): DNS_STATUS; stdcall;
  1689. {$EXTERNALSYM DnsQuery}
  1690. {$ELSE}
  1691. function DnsQuery(pszName: PCSTR; wType: WORD; Options: DWORD; aipServers: PIP4_ARRAY; ppQueryResults: PPDNS_RECORD; pReserved: PPVOID): DNS_STATUS; stdcall;
  1692. {$EXTERNALSYM DnsQuery}
  1693. {$ENDIF}
  1695. //
  1696. //  DNS Update API
  1697. //
  1698. //      DnsAcquireContextHandle
  1699. //      DnsReleaseContextHandle
  1700. //      DnsModifyRecordsInSet
  1701. //      DnsReplaceRecordSet
  1702. //
  1704. //
  1705. //  Update flags
  1706. //
  1708. const
  1709.   DNS_UPDATE_SECURITY_USE_DEFAULT    = $00000000;
  1710.   {$EXTERNALSYM DNS_UPDATE_SECURITY_USE_DEFAULT}
  1711.   DNS_UPDATE_SECURITY_OFF            = $00000010;
  1712.   {$EXTERNALSYM DNS_UPDATE_SECURITY_OFF}
  1713.   DNS_UPDATE_SECURITY_ON             = $00000020;
  1714.   {$EXTERNALSYM DNS_UPDATE_SECURITY_ON}
  1715.   DNS_UPDATE_SECURITY_ONLY           = $00000100;
  1716.   {$EXTERNALSYM DNS_UPDATE_SECURITY_ONLY}
  1717.   DNS_UPDATE_CACHE_SECURITY_CONTEXT  = $00000200;
  1718.   {$EXTERNALSYM DNS_UPDATE_CACHE_SECURITY_CONTEXT}
  1719.   DNS_UPDATE_TEST_USE_LOCAL_SYS_ACCT = $00000400;
  1720.   {$EXTERNALSYM DNS_UPDATE_TEST_USE_LOCAL_SYS_ACCT}
  1721.   DNS_UPDATE_FORCE_SECURITY_NEGO     = $00000800;
  1722.   {$EXTERNALSYM DNS_UPDATE_FORCE_SECURITY_NEGO}
  1723.   DNS_UPDATE_TRY_ALL_MASTER_SERVERS  = $00001000;
  1724.   {$EXTERNALSYM DNS_UPDATE_TRY_ALL_MASTER_SERVERS}
  1725.   DNS_UPDATE_SKIP_NO_UPDATE_ADAPTERS = $00002000;
  1726.   {$EXTERNALSYM DNS_UPDATE_SKIP_NO_UPDATE_ADAPTERS}
  1727.   DNS_UPDATE_RESERVED                = DWORD($ffff0000);
  1728.   {$EXTERNALSYM DNS_UPDATE_RESERVED}
  1730. //
  1731. //  Note:  pCredentials paramater is currently respectively
  1732. //  PSEC_WINNT_AUTH_IDENTITY_W or PSEC_WINNT_AUTH_IDENTITY_A.
  1733. //  Using PVOID to obviate the need for including rpcdce.h
  1734. //  in order to include this file and to leave open the
  1735. //  possibility of alternative credential specifications in
  1736. //  the future.
  1737. //
  1739. function DnsAcquireContextHandle_W(CredentialFlags: DWORD; pCredentials: PVOID; pContextHandle: PHANDLE): DNS_STATUS; stdcall;
  1740. {$EXTERNALSYM DnsAcquireContextHandle_W}
  1742. function DnsAcquireContextHandle_A(CredentialFlags: DWORD; pCredentials: PVOID; pContextHandle: PHANDLE): DNS_STATUS; stdcall;
  1743. {$EXTERNALSYM DnsAcquireContextHandle_A}
  1745. {$IFDEF UNICODE}
  1746. function DnsAcquireContextHandle(CredentialFlags: DWORD; pCredentials: PVOID; pContextHandle: PHANDLE): DNS_STATUS; stdcall;
  1747. {$EXTERNALSYM DnsAcquireContextHandle}
  1748. {$ELSE}
  1749. function DnsAcquireContextHandle(CredentialFlags: DWORD; pCredentials: PVOID; pContextHandle: PHANDLE): DNS_STATUS; stdcall;
  1750. {$EXTERNALSYM DnsAcquireContextHandle}
  1751. {$ENDIF}
  1753. procedure DnsReleaseContextHandle(hContext: HANDLE); stdcall;
  1754. {$EXTERNALSYM DnsReleaseContextHandle}
  1756. //
  1757. //  Dynamic Update API
  1758. //
  1760. function DnsModifyRecordsInSet_W(pAddRecords: PDNS_RECORD; pDeleteRecords: PDNS_RECORD; Options: DWORD; hContext: HANDLE; pServerList: PIP4_ARRAY; pReserved: PVOID): DNS_STATUS; stdcall;
  1761. {$EXTERNALSYM DnsModifyRecordsInSet_W}
  1763. function DnsModifyRecordsInSet_A(pAddRecords: PDNS_RECORD; pDeleteRecords: PDNS_RECORD; Options: DWORD; hContext: HANDLE; pServerList: PIP4_ARRAY; pReserved: PVOID): DNS_STATUS; stdcall;
  1764. {$EXTERNALSYM DnsModifyRecordsInSet_A}
  1766. function DnsModifyRecordsInSet_UTF8(pAddRecords: PDNS_RECORD; pDeleteRecords: PDNS_RECORD; Options: DWORD; hContext: HANDLE; pServerList: PIP4_ARRAY; pReserved: PVOID): DNS_STATUS; stdcall;
  1767. {$EXTERNALSYM DnsModifyRecordsInSet_UTF8}
  1769. {$IFDEF UNICODE}
  1770. function DnsModifyRecordsInSet(pAddRecords: PDNS_RECORD; pDeleteRecords: PDNS_RECORD; Options: DWORD; hContext: HANDLE; pServerList: PIP4_ARRAY; pReserved: PVOID): DNS_STATUS; stdcall;
  1771. {$EXTERNALSYM DnsModifyRecordsInSet}
  1772. {$ELSE}
  1773. function DnsModifyRecordsInSet(pAddRecords: PDNS_RECORD; pDeleteRecords: PDNS_RECORD; Options: DWORD; hContext: HANDLE; pServerList: PIP4_ARRAY; pReserved: PVOID): DNS_STATUS; stdcall;
  1774. {$EXTERNALSYM DnsModifyRecordsInSet}
  1775. {$ENDIF}
  1777. function DnsReplaceRecordSetW(pNewSet: PDNS_RECORD; Options: DWORD; hContext: HANDLE; pServerList: PIP4_ARRAY; pReserved: PVOID): DNS_STATUS; stdcall;
  1778. {$EXTERNALSYM DnsReplaceRecordSetW}
  1780. function DnsReplaceRecordSetA(pNewSet: PDNS_RECORD; Options: DWORD; hContext: HANDLE; pServerList: PIP4_ARRAY; pReserved: PVOID): DNS_STATUS; stdcall;
  1781. {$EXTERNALSYM DnsReplaceRecordSetA}
  1783. function DnsReplaceRecordSetUTF8(pNewSet: PDNS_RECORD; Options: DWORD; hContext: HANDLE; pServerList: PIP4_ARRAY; pReserved: PVOID): DNS_STATUS; stdcall;
  1784. {$EXTERNALSYM DnsReplaceRecordSetUTF8}
  1786. {$IFDEF UNICODE}
  1787. function DnsReplaceRecordSet(pNewSet: PDNS_RECORD; Options: DWORD; hContext: HANDLE; pServerList: PIP4_ARRAY; pReserved: PVOID): DNS_STATUS; stdcall;
  1788. {$EXTERNALSYM DnsReplaceRecordSet}
  1789. {$ELSE}
  1790. function DnsReplaceRecordSet(pNewSet: PDNS_RECORD; Options: DWORD; hContext: HANDLE; pServerList: PIP4_ARRAY; pReserved: PVOID): DNS_STATUS; stdcall;
  1791. {$EXTERNALSYM DnsReplaceRecordSet}
  1792. {$ENDIF}
  1794. //
  1795. //  DNS name validation
  1796. //
  1798. type
  1799.   _DNS_NAME_FORMAT = (
  1800.     DnsNameDomain,
  1801.     DnsNameDomainLabel,
  1802.     DnsNameHostnameFull,
  1803.     DnsNameHostnameLabel,
  1804.     DnsNameWildcard,
  1805.     DnsNameSrvRecord);
  1806.   {$EXTERNALSYM _DNS_NAME_FORMAT}
  1807.   DNS_NAME_FORMAT = _DNS_NAME_FORMAT;
  1808.   {$EXTERNALSYM DNS_NAME_FORMAT}
  1809.   TDnsNameFormat = DNS_NAME_FORMAT;
  1810.   PDnsNameFormat = ^DNS_NAME_FORMAT;
  1812. function DnsValidateName_UTF8(pszName: LPCSTR; Format: DNS_NAME_FORMAT): DNS_STATUS; stdcall;
  1813. {$EXTERNALSYM DnsValidateName_UTF8}
  1815. function DnsValidateName_W(pwszName: LPCWSTR; Format: DNS_NAME_FORMAT): DNS_STATUS; stdcall;
  1816. {$EXTERNALSYM DnsValidateName_W}
  1818. function DnsValidateName_A(pszName: LPCSTR; Format: DNS_NAME_FORMAT): DNS_STATUS; stdcall;
  1819. {$EXTERNALSYM DnsValidateName_A}
  1821. {$IFDEF UNICODE}
  1823. function DnsValidateName(pszName: LPCWSTR; Format: DNS_NAME_FORMAT): DNS_STATUS;
  1824. {$EXTERNALSYM DnsValidateName}
  1826. {$ELSE}
  1828. function DnsValidateName(pszName: LPCSTR; Format: DNS_NAME_FORMAT): DNS_STATUS;
  1829. {$EXTERNALSYM DnsValidateName}
  1831. {$ENDIF}
  1833. //
  1834. //  DNS name comparison
  1835. //
  1837. function DnsNameCompare_A(pName1: LPSTR; pName2: LPSTR): BOOL; stdcall;
  1838. {$EXTERNALSYM DnsNameCompare_A}
  1840. function DnsNameCompare_W(pName1: LPWSTR; pName2: LPWSTR): BOOL; stdcall;
  1841. {$EXTERNALSYM DnsNameCompare_W}
  1843. {$IFDEF UNICODE}
  1844. function DnsNameCompare(pName1: LPWSTR; pName2: LPWSTR): BOOL; stdcall;
  1845. {$EXTERNALSYM DnsNameCompare}
  1846. {$ELSE}
  1847. function DnsNameCompare(pName1: LPSTR; pName2: LPSTR): BOOL; stdcall;
  1848. {$EXTERNALSYM DnsNameCompare}
  1849. {$ENDIF}
  1851. //
  1852. //  DNS message "roll-your-own" routines
  1853. //
  1855. type
  1856.   PDNS_MESSAGE_BUFFER = ^DNS_MESSAGE_BUFFER;
  1857.   {$EXTERNALSYM PDNS_MESSAGE_BUFFER}
  1858.   _DNS_MESSAGE_BUFFER = record
  1859.     MessageHead: DNS_HEADER;
  1860.     MessageBody: array [0..0] of CHAR;
  1861.   end;
  1862.   {$EXTERNALSYM _DNS_MESSAGE_BUFFER}
  1863.   DNS_MESSAGE_BUFFER = _DNS_MESSAGE_BUFFER;
  1864.   {$EXTERNALSYM DNS_MESSAGE_BUFFER}
  1865.   TDnsMessageBuffer = DNS_MESSAGE_BUFFER;
  1866.   PDnsMessageBuffer = PDNS_MESSAGE_BUFFER;
  1868. function DnsWriteQuestionToBuffer_W(pDnsBuffer: PDNS_MESSAGE_BUFFER; pdwBufferSize: LPDWORD; pszName: LPWSTR; wType: WORD; Xid: WORD; fRecursionDesired: BOOL): BOOL; stdcall;
  1869. {$EXTERNALSYM DnsWriteQuestionToBuffer_W}
  1871. function DnsWriteQuestionToBuffer_UTF8(pDnsBuffer: PDNS_MESSAGE_BUFFER; pdwBufferSize: LPDWORD; pszName: LPSTR; wType: WORD; Xid: WORD; fRecursionDesired: BOOL): BOOL; stdcall;
  1872. {$EXTERNALSYM DnsWriteQuestionToBuffer_UTF8}
  1874. function DnsExtractRecordsFromMessage_W(pDnsBuffer: PDNS_MESSAGE_BUFFER; wMessageLength: WORD; ppRecord: PPDNS_RECORD): DNS_STATUS; stdcall;
  1875. {$EXTERNALSYM DnsExtractRecordsFromMessage_W}
  1877. function DnsExtractRecordsFromMessage_UTF8(pDnsBuffer: PDNS_MESSAGE_BUFFER; wMessageLength: WORD; ppRecord: PPDNS_RECORD): DNS_STATUS; stdcall;
  1878. {$EXTERNALSYM DnsExtractRecordsFromMessage_UTF8}
  1880. implementation
  1882. const
  1883.   dnsapi = 'dnsapi.dll';
  1885. procedure INLINE_WORD_FLIP(var Out: WORD; In_: WORD);
  1886. begin
  1887.   Out := (In_ shl 8) or (In_ shr 8);
  1888. end;
  1890. procedure INLINE_HTONS(var Out: WORD; In_: WORD);
  1891. begin
  1892.   INLINE_WORD_FLIP(Out, In_);
  1893. end;
  1895. procedure INLINE_NTOHS(var Out: WORD; In_: WORD);
  1896. begin
  1897.   INLINE_WORD_FLIP(Out, In_);
  1898. end;
  1900. procedure INLINE_DWORD_FLIP(var Out: DWORD; In_: DWORD);
  1901. begin
  1902.   Out := ((In_ shl 8) and $00ff0000) or (In_ shl 24) or
  1903.     ((In_ shr 8) and $0000ff00) or (In_ shr 24);
  1904. end;
  1906. procedure INLINE_NTOHL(var Out: DWORD; In_: DWORD);
  1907. begin
  1908.   INLINE_DWORD_FLIP(Out, In_);
  1909. end;
  1911. procedure INLINE_HTONL(var Out: DWORD; In_: DWORD);
  1912. begin
  1913.   INLINE_DWORD_FLIP(Out, In_);
  1914. end;
  1916. procedure INLINE_WRITE_FLIPPED_WORD(pout: PWORD; In_: WORD);
  1917. begin
  1918.   INLINE_WORD_FLIP(pout^, In_);
  1919. end;
  1921. procedure INLINE_WRITE_FLIPPED_DWORD(pout: PDWORD; In_: DWORD);
  1922. begin
  1923.   INLINE_DWORD_FLIP(pout^, In_);
  1924. end;
  1926. function DNS_HEADER_FLAGS(pHead: PDNS_HEADER): WORD;
  1927. begin
  1928.   Result := PWORD(Integer(pHead) + SizeOf(WORD))^;
  1929. end;
  1931. procedure DNS_BYTE_FLIP_HEADER_COUNTS(var pHeader: PDNS_HEADER);
  1932. var
  1933.   _head: PDNS_HEADER;
  1934. begin
  1935.   _head := pHeader;
  1936.   INLINE_HTONS(_head^.Xid, _head^.Xid);
  1937.   INLINE_HTONS(_head^.QuestionCount, _head^.QuestionCount);
  1938.   INLINE_HTONS(_head^.AnswerCount, _head^.AnswerCount);
  1939.   INLINE_HTONS(_head^.NameServerCount, _head^.NameServerCount);
  1940.   INLINE_HTONS(_head^.AdditionalCount, _head^.AdditionalCount);
  1941. end;
  1943. {
  1944. #define DNS_QUESTION_NAME_FROM_HEADER( _pHeader_ ) 
  1945.             ( (PCHAR)( (PDNS_HEADER)(_pHeader_) + 1 ) )
  1947. #define DNS_ANSWER_FROM_QUESTION( _pQuestion_ ) 
  1948.             ( (PCHAR)( (PDNS_QUESTION)(_pQuestion_) + 1 ) )
  1949. }
  1951. function IS_WORD_ALIGNED(P: Pointer): BOOL;
  1952. begin
  1953.   Result := (Integer(P) and 1) = 0;
  1954. end;
  1956. function IS_DWORD_ALIGNED(P: Pointer): BOOL;
  1957. begin
  1958.   Result := (Integer(P) and 3) = 0;
  1959. end;
  1961. function IS_QWORD_ALIGNED(P: Pointer): BOOL;
  1962. begin
  1963.   Result := (Integer(P) and 7) = 0;
  1964. end;
  1967. {$IFDEF DYNAMIC_LINK}
  1968. var
  1969.   _DnsQueryConfig: Pointer;
  1971. function DnsQueryConfig;
  1972. begin
  1973.   GetProcedureAddress(_DnsQueryConfig, dnsapi, 'DnsQueryConfig');
  1974.   asm
  1975.     mov esp, ebp
  1976.     pop ebp
  1977.     jmp [_DnsQueryConfig]
  1978.   end;
  1979. end;
  1980. {$ELSE}
  1981. function DnsQueryConfig; external dnsapi name 'DnsQueryConfig';
  1982. {$ENDIF DYNAMIC_LINK}
  1984. function DNS_TEXT_RECORD_LENGTH(StringCount: Integer): Integer;
  1985. begin
  1986.   Result := SizeOf(DWORD) + ((StringCount) * SizeOf(PChar));
  1987. end;
  1989. function DNS_NULL_RECORD_LENGTH(ByteCount: Integer): Integer;
  1990. begin
  1991.   Result := SizeOf(DWORD) + (ByteCount);
  1992. end;
  1994. function DNS_WKS_RECORD_LENGTH(ByteCount: Integer): Integer;
  1995. begin
  1996.   Result := SizeOf(DNS_WKS_DATA) + (ByteCount - 1);
  1997. end;
  1999. //#define DNS_WINS_RECORD_LENGTH(IpCount) 
  2000. //            (FIELD_OFFSET(DNS_WINS_DATA, WinsServers) + ((IpCount) * sizeof(IP4_ADDRESS)))
  2003. procedure DNS_RRSET_INIT(rrset: PDnsRRSet);
  2004. begin
  2005.   rrset^.pFirstRR := nil;
  2006.   rrset^.pLastRR := (@rrset^.pFirstRR);
  2007. end;
  2009. //#define DNS_RRSET_ADD( rrset, pnewRR )          
  2010. //        {                                       
  2011. //            PDNS_RRSET  _prrset = &(rrset);     
  2012. //            PDNS_RECORD _prrnew = (pnewRR);     
  2013. //            _prrset->pLastRR->pNext = _prrnew;  
  2014. //            _prrset->pLastRR = _prrnew;         
  2015. //        }
  2017. procedure DNS_RRSET_TERMINATE(rrset: PDnsRRSet);
  2018. begin
  2019.   rrset^.pLastRR^.pNext := nil;
  2020. end;
  2023. {$IFDEF DYNAMIC_LINK}
  2024. var
  2025.   _DnsRecordCopyEx: Pointer;
  2027. function DnsRecordCopyEx;
  2028. begin
  2029.   GetProcedureAddress(_DnsRecordCopyEx, dnsapi, 'DnsRecordCopyEx');
  2030.   asm
  2031.     mov esp, ebp
  2032.     pop ebp
  2033.     jmp [_DnsRecordCopyEx]
  2034.   end;
  2035. end;
  2036. {$ELSE}
  2037. function DnsRecordCopyEx; external dnsapi name 'DnsRecordCopyEx';
  2038. {$ENDIF DYNAMIC_LINK}
  2040. {$IFDEF DYNAMIC_LINK}
  2041. var
  2042.   _DnsRecordSetCopyEx: Pointer;
  2044. function DnsRecordSetCopyEx;
  2045. begin
  2046.   GetProcedureAddress(_DnsRecordSetCopyEx, dnsapi, 'DnsRecordSetCopyEx');
  2047.   asm
  2048.     mov esp, ebp
  2049.     pop ebp
  2050.     jmp [_DnsRecordSetCopyEx]
  2051.   end;
  2052. end;
  2053. {$ELSE}
  2054. function DnsRecordSetCopyEx; external dnsapi name 'DnsRecordSetCopyEx';
  2055. {$ENDIF DYNAMIC_LINK}
  2056. {$IFDEF UNICODE}
  2057. function DnsRecordCopy(pRR: PDNS_RECORD): PDNS_RECORD;
  2058. begin
  2059.   Result := DnsRecordCopyEx(pRR, DnsCharSetUnicode, DnsCharSetUnicode);
  2060. end;
  2062. function DnsRecordSetCopy(pRR: PDNS_RECORD): PDNS_RECORD;
  2063. begin
  2064.   Result := DnsRecordSetCopyEx(pRR, DnsCharSetUnicode, DnsCharSetUnicode);
  2065. end;
  2066. {$ELSE}
  2067. function DnsRecordCopy(pRR: PDNS_RECORD): PDNS_RECORD;
  2068. begin
  2069.   Result := DnsRecordCopyEx(pRR, DnsCharSetAnsi, DnsCharSetAnsi);
  2070. end;
  2072. function DnsRecordSetCopy(pRR: PDNS_RECORD): PDNS_RECORD;
  2073. begin
  2074.   Result := DnsRecordSetCopyEx(pRR, DnsCharSetAnsi, DnsCharSetAnsi);
  2075. end;
  2076. {$ENDIF}
  2078. {$IFDEF DYNAMIC_LINK}
  2079. var
  2080.   _DnsRecordCompare: Pointer;
  2082. function DnsRecordCompare;
  2083. begin
  2084.   GetProcedureAddress(_DnsRecordCompare, dnsapi, 'DnsRecordCompare');
  2085.   asm
  2086.     mov esp, ebp
  2087.     pop ebp
  2088.     jmp [_DnsRecordCompare]
  2089.   end;
  2090. end;
  2091. {$ELSE}
  2092. function DnsRecordCompare; external dnsapi name 'DnsRecordCompare';
  2093. {$ENDIF DYNAMIC_LINK}
  2095. {$IFDEF DYNAMIC_LINK}
  2096. var
  2097.   _DnsRecordSetCompare: Pointer;
  2099. function DnsRecordSetCompare;
  2100. begin
  2101.   GetProcedureAddress(_DnsRecordSetCompare, dnsapi, 'DnsRecordSetCompare');
  2102.   asm
  2103.     mov esp, ebp
  2104.     pop ebp
  2105.     jmp [_DnsRecordSetCompare]
  2106.   end;
  2107. end;
  2108. {$ELSE}
  2109. function DnsRecordSetCompare; external dnsapi name 'DnsRecordSetCompare';
  2110. {$ENDIF DYNAMIC_LINK}
  2112. {$IFDEF DYNAMIC_LINK}
  2113. var
  2114.   _DnsRecordSetDetach: Pointer;
  2116. function DnsRecordSetDetach;
  2117. begin
  2118.   GetProcedureAddress(_DnsRecordSetDetach, dnsapi, 'DnsRecordSetDetach');
  2119.   asm
  2120.     mov esp, ebp
  2121.     pop ebp
  2122.     jmp [_DnsRecordSetDetach]
  2123.   end;
  2124. end;
  2125. {$ELSE}
  2126. function DnsRecordSetDetach; external dnsapi name 'DnsRecordSetDetach';
  2127. {$ENDIF DYNAMIC_LINK}
  2129. {$IFDEF DYNAMIC_LINK}
  2130. var
  2131.   _DnsFreeRecordListDeep: Pointer;
  2133. procedure DnsFreeRecordListDeep;
  2134. begin
  2135.   GetProcedureAddress(_DnsFreeRecordListDeep, dnsapi, 'DnsRecordListFree');
  2136.   asm
  2137.     mov esp, ebp
  2138.     pop ebp
  2139.     jmp [_DnsFreeRecordListDeep]
  2140.   end;
  2141. end;
  2142. {$ELSE}
  2143. procedure DnsFreeRecordListDeep; external dnsapi name 'DnsRecordListFree';
  2144. {$ENDIF DYNAMIC_LINK}
  2146. {$IFDEF DYNAMIC_LINK}
  2147. var
  2148.   _DnsRecordListFree: Pointer;
  2150. procedure DnsRecordListFree;
  2151. begin
  2152.   GetProcedureAddress(_DnsRecordListFree, dnsapi, 'DnsRecordListFree');
  2153.   asm
  2154.     mov esp, ebp
  2155.     pop ebp
  2156.     jmp [_DnsRecordListFree]
  2157.   end;
  2158. end;
  2159. {$ELSE}
  2160. procedure DnsRecordListFree; external dnsapi name 'DnsRecordListFree';
  2161. {$ENDIF DYNAMIC_LINK}
  2163. {$IFDEF DYNAMIC_LINK}
  2164. var
  2165.   _DnsFree: Pointer;
  2167. procedure DnsFree;
  2168. begin
  2169.   GetProcedureAddress(_DnsFree, dnsapi, 'DnsFree');
  2170.   asm
  2171.     mov esp, ebp
  2172.     pop ebp
  2173.     jmp [_DnsFree]
  2174.   end;
  2175. end;
  2176. {$ELSE}
  2177. procedure DnsFree; external dnsapi name 'DnsFree';
  2178. {$ENDIF DYNAMIC_LINK}
  2180. {$IFDEF DYNAMIC_LINK}
  2181. var
  2182.   _DnsQuery_A: Pointer;
  2184. function DnsQuery_A;
  2185. begin
  2186.   GetProcedureAddress(_DnsQuery_A, dnsapi, 'DnsQuery_A');
  2187.   asm
  2188.     mov esp, ebp
  2189.     pop ebp
  2190.     jmp [_DnsQuery_A]
  2191.   end;
  2192. end;
  2193. {$ELSE}
  2194. function DnsQuery_A; external dnsapi name 'DnsQuery_A';
  2195. {$ENDIF DYNAMIC_LINK}
  2197. {$IFDEF DYNAMIC_LINK}
  2198. var
  2199.   _DnsQuery_UTF8: Pointer;
  2201. function DnsQuery_UTF8;
  2202. begin
  2203.   GetProcedureAddress(_DnsQuery_UTF8, dnsapi, 'DnsQuery_UTF8');
  2204.   asm
  2205.     mov esp, ebp
  2206.     pop ebp
  2207.     jmp [_DnsQuery_UTF8]
  2208.   end;
  2209. end;
  2210. {$ELSE}
  2211. function DnsQuery_UTF8; external dnsapi name 'DnsQuery_UTF8';
  2212. {$ENDIF DYNAMIC_LINK}
  2214. {$IFDEF DYNAMIC_LINK}
  2215. var
  2216.   _DnsQuery_W: Pointer;
  2218. function DnsQuery_W;
  2219. begin
  2220.   GetProcedureAddress(_DnsQuery_W, dnsapi, 'DnsQuery_W');
  2221.   asm
  2222.     mov esp, ebp
  2223.     pop ebp
  2224.     jmp [_DnsQuery_W]
  2225.   end;
  2226. end;
  2227. {$ELSE}
  2228. function DnsQuery_W; external dnsapi name 'DnsQuery_W';
  2229. {$ENDIF DYNAMIC_LINK}
  2230. {$IFDEF UNICODE}
  2232. {$IFDEF DYNAMIC_LINK}
  2233. var
  2234.   _DnsQuery: Pointer;
  2236. function DnsQuery;
  2237. begin
  2238.   GetProcedureAddress(_DnsQuery, dnsapi, 'DnsQuery_W');
  2239.   asm
  2240.     mov esp, ebp
  2241.     pop ebp
  2242.     jmp [_DnsQuery]
  2243.   end;
  2244. end;
  2245. {$ELSE}
  2246. function DnsQuery; external dnsapi name 'DnsQuery_W';
  2247. {$ENDIF DYNAMIC_LINK}
  2248. {$ELSE}
  2250. {$IFDEF DYNAMIC_LINK}
  2251. var
  2252.   _DnsQuery: Pointer;
  2254. function DnsQuery;
  2255. begin
  2256.   GetProcedureAddress(_DnsQuery, dnsapi, 'DnsQuery_A');
  2257.   asm
  2258.     mov esp, ebp
  2259.     pop ebp
  2260.     jmp [_DnsQuery]
  2261.   end;
  2262. end;
  2263. {$ELSE}
  2264. function DnsQuery; external dnsapi name 'DnsQuery_A';
  2265. {$ENDIF DYNAMIC_LINK}
  2266. {$ENDIF}
  2268. {$IFDEF DYNAMIC_LINK}
  2269. var
  2270.   _DnsAcquireContextHandle_W: Pointer;
  2272. function DnsAcquireContextHandle_W;
  2273. begin
  2274.   GetProcedureAddress(_DnsAcquireContextHandle_W, dnsapi, 'DnsAcquireContextHandle_W');
  2275.   asm
  2276.     mov esp, ebp
  2277.     pop ebp
  2278.     jmp [_DnsAcquireContextHandle_W]
  2279.   end;
  2280. end;
  2281. {$ELSE}
  2282. function DnsAcquireContextHandle_W; external dnsapi name 'DnsAcquireContextHandle_W';
  2283. {$ENDIF DYNAMIC_LINK}
  2285. {$IFDEF DYNAMIC_LINK}
  2286. var
  2287.   _DnsAcquireContextHandle_A: Pointer;
  2289. function DnsAcquireContextHandle_A;
  2290. begin
  2291.   GetProcedureAddress(_DnsAcquireContextHandle_A, dnsapi, 'DnsAcquireContextHandle_A');
  2292.   asm
  2293.     mov esp, ebp
  2294.     pop ebp
  2295.     jmp [_DnsAcquireContextHandle_A]
  2296.   end;
  2297. end;
  2298. {$ELSE}
  2299. function DnsAcquireContextHandle_A; external dnsapi name 'DnsAcquireContextHandle_A';
  2300. {$ENDIF DYNAMIC_LINK}
  2301. {$IFDEF UNICODE}
  2303. {$IFDEF DYNAMIC_LINK}
  2304. var
  2305.   _DnsAcquireContextHandle: Pointer;
  2307. function DnsAcquireContextHandle;
  2308. begin
  2309.   GetProcedureAddress(_DnsAcquireContextHandle, dnsapi, 'DnsAcquireContextHandle_W');
  2310.   asm
  2311.     mov esp, ebp
  2312.     pop ebp
  2313.     jmp [_DnsAcquireContextHandle]
  2314.   end;
  2315. end;
  2316. {$ELSE}
  2317. function DnsAcquireContextHandle; external dnsapi name 'DnsAcquireContextHandle_W';
  2318. {$ENDIF DYNAMIC_LINK}
  2319. {$ELSE}
  2321. {$IFDEF DYNAMIC_LINK}
  2322. var
  2323.   _DnsAcquireContextHandle: Pointer;
  2325. function DnsAcquireContextHandle;
  2326. begin
  2327.   GetProcedureAddress(_DnsAcquireContextHandle, dnsapi, 'DnsAcquireContextHandle_A');
  2328.   asm
  2329.     mov esp, ebp
  2330.     pop ebp
  2331.     jmp [_DnsAcquireContextHandle]
  2332.   end;
  2333. end;
  2334. {$ELSE}
  2335. function DnsAcquireContextHandle; external dnsapi name 'DnsAcquireContextHandle_A';
  2336. {$ENDIF DYNAMIC_LINK}
  2337. {$ENDIF}
  2339. {$IFDEF DYNAMIC_LINK}
  2340. var
  2341.   _DnsReleaseContextHandle: Pointer;
  2343. procedure DnsReleaseContextHandle;
  2344. begin
  2345.   GetProcedureAddress(_DnsReleaseContextHandle, dnsapi, 'DnsReleaseContextHandle');
  2346.   asm
  2347.     mov esp, ebp
  2348.     pop ebp
  2349.     jmp [_DnsReleaseContextHandle]
  2350.   end;
  2351. end;
  2352. {$ELSE}
  2353. procedure DnsReleaseContextHandle; external dnsapi name 'DnsReleaseContextHandle';
  2354. {$ENDIF DYNAMIC_LINK}
  2356. {$IFDEF DYNAMIC_LINK}
  2357. var
  2358.   _DnsModifyRecordsInSet_W: Pointer;
  2360. function DnsModifyRecordsInSet_W;
  2361. begin
  2362.   GetProcedureAddress(_DnsModifyRecordsInSet_W, dnsapi, 'DnsModifyRecordsInSet_W');
  2363.   asm
  2364.     mov esp, ebp
  2365.     pop ebp
  2366.     jmp [_DnsModifyRecordsInSet_W]
  2367.   end;
  2368. end;
  2369. {$ELSE}
  2370. function DnsModifyRecordsInSet_W; external dnsapi name 'DnsModifyRecordsInSet_W';
  2371. {$ENDIF DYNAMIC_LINK}
  2373. {$IFDEF DYNAMIC_LINK}
  2374. var
  2375.   _DnsModifyRecordsInSet_A: Pointer;
  2377. function DnsModifyRecordsInSet_A;
  2378. begin
  2379.   GetProcedureAddress(_DnsModifyRecordsInSet_A, dnsapi, 'DnsModifyRecordsInSet_A');
  2380.   asm
  2381.     mov esp, ebp
  2382.     pop ebp
  2383.     jmp [_DnsModifyRecordsInSet_A]
  2384.   end;
  2385. end;
  2386. {$ELSE}
  2387. function DnsModifyRecordsInSet_A; external dnsapi name 'DnsModifyRecordsInSet_A';
  2388. {$ENDIF DYNAMIC_LINK}
  2390. {$IFDEF DYNAMIC_LINK}
  2391. var
  2392.   _DnsModifyRecordsInSet_UTF8: Pointer;
  2394. function DnsModifyRecordsInSet_UTF8;
  2395. begin
  2396.   GetProcedureAddress(_DnsModifyRecordsInSet_UTF8, dnsapi, 'DnsModifyRecordsInSet_UTF8');
  2397.   asm
  2398.     mov esp, ebp
  2399.     pop ebp
  2400.     jmp [_DnsModifyRecordsInSet_UTF8]
  2401.   end;
  2402. end;
  2403. {$ELSE}
  2404. function DnsModifyRecordsInSet_UTF8; external dnsapi name 'DnsModifyRecordsInSet_UTF8';
  2405. {$ENDIF DYNAMIC_LINK}
  2406. {$IFDEF UNICODE}
  2408. {$IFDEF DYNAMIC_LINK}
  2409. var
  2410.   _DnsModifyRecordsInSet: Pointer;
  2412. function DnsModifyRecordsInSet;
  2413. begin
  2414.   GetProcedureAddress(_DnsModifyRecordsInSet, dnsapi, 'DnsModifyRecordsInSet_W');
  2415.   asm
  2416.     mov esp, ebp
  2417.     pop ebp
  2418.     jmp [_DnsModifyRecordsInSet]
  2419.   end;
  2420. end;
  2421. {$ELSE}
  2422. function DnsModifyRecordsInSet; external dnsapi name 'DnsModifyRecordsInSet_W';
  2423. {$ENDIF DYNAMIC_LINK}
  2424. {$ELSE}
  2426. {$IFDEF DYNAMIC_LINK}
  2427. var
  2428.   _DnsModifyRecordsInSet: Pointer;
  2430. function DnsModifyRecordsInSet;
  2431. begin
  2432.   GetProcedureAddress(_DnsModifyRecordsInSet, dnsapi, 'DnsModifyRecordsInSet_A');
  2433.   asm
  2434.     mov esp, ebp
  2435.     pop ebp
  2436.     jmp [_DnsModifyRecordsInSet]
  2437.   end;
  2438. end;
  2439. {$ELSE}
  2440. function DnsModifyRecordsInSet; external dnsapi name 'DnsModifyRecordsInSet_A';
  2441. {$ENDIF DYNAMIC_LINK}
  2442. {$ENDIF}
  2445. {$IFDEF DYNAMIC_LINK}
  2446. var
  2447.   _DnsReplaceRecordSetW: Pointer;
  2449. function DnsReplaceRecordSetW;
  2450. begin
  2451.   GetProcedureAddress(_DnsReplaceRecordSetW, dnsapi, 'DnsReplaceRecordSetW');
  2452.   asm
  2453.     mov esp, ebp
  2454.     pop ebp
  2455.     jmp [_DnsReplaceRecordSetW]
  2456.   end;
  2457. end;
  2458. {$ELSE}
  2459. function DnsReplaceRecordSetW; external dnsapi name 'DnsReplaceRecordSetW';
  2460. {$ENDIF DYNAMIC_LINK}
  2462. {$IFDEF DYNAMIC_LINK}
  2463. var
  2464.   _DnsReplaceRecordSetA: Pointer;
  2466. function DnsReplaceRecordSetA;
  2467. begin
  2468.   GetProcedureAddress(_DnsReplaceRecordSetA, dnsapi, 'DnsReplaceRecordSetA');
  2469.   asm
  2470.     mov esp, ebp
  2471.     pop ebp
  2472.     jmp [_DnsReplaceRecordSetA]
  2473.   end;
  2474. end;
  2475. {$ELSE}
  2476. function DnsReplaceRecordSetA; external dnsapi name 'DnsReplaceRecordSetA';
  2477. {$ENDIF DYNAMIC_LINK}
  2479. {$IFDEF DYNAMIC_LINK}
  2480. var
  2481.   _DnsReplaceRecordSetUTF8: Pointer;
  2483. function DnsReplaceRecordSetUTF8;
  2484. begin
  2485.   GetProcedureAddress(_DnsReplaceRecordSetUTF8, dnsapi, 'DnsReplaceRecordSetUTF8');
  2486.   asm
  2487.     mov esp, ebp
  2488.     pop ebp
  2489.     jmp [_DnsReplaceRecordSetUTF8]
  2490.   end;
  2491. end;
  2492. {$ELSE}
  2493. function DnsReplaceRecordSetUTF8; external dnsapi name 'DnsReplaceRecordSetUTF8';
  2494. {$ENDIF DYNAMIC_LINK}
  2495. {$IFDEF UNICODE}
  2497. {$IFDEF DYNAMIC_LINK}
  2498. var
  2499.   _DnsReplaceRecordSet: Pointer;
  2501. function DnsReplaceRecordSet;
  2502. begin
  2503.   GetProcedureAddress(_DnsReplaceRecordSet, dnsapi, 'DnsReplaceRecordSetW');
  2504.   asm
  2505.     mov esp, ebp
  2506.     pop ebp
  2507.     jmp [_DnsReplaceRecordSet]
  2508.   end;
  2509. end;
  2510. {$ELSE}
  2511. function DnsReplaceRecordSet; external dnsapi name 'DnsReplaceRecordSetW';
  2512. {$ENDIF DYNAMIC_LINK}
  2513. {$ELSE}
  2515. {$IFDEF DYNAMIC_LINK}
  2516. var
  2517.   _DnsReplaceRecordSet: Pointer;
  2519. function DnsReplaceRecordSet;
  2520. begin
  2521.   GetProcedureAddress(_DnsReplaceRecordSet, dnsapi, 'DnsReplaceRecordSetA');
  2522.   asm
  2523.     mov esp, ebp
  2524.     pop ebp
  2525.     jmp [_DnsReplaceRecordSet]
  2526.   end;
  2527. end;
  2528. {$ELSE}
  2529. function DnsReplaceRecordSet; external dnsapi name 'DnsReplaceRecordSetA';
  2530. {$ENDIF DYNAMIC_LINK}
  2531. {$ENDIF}
  2533. {$IFDEF DYNAMIC_LINK}
  2534. var
  2535.   _DnsValidateName_UTF8: Pointer;
  2537. function DnsValidateName_UTF8;
  2538. begin
  2539.   GetProcedureAddress(_DnsValidateName_UTF8, dnsapi, 'DnsValidateName_UTF8');
  2540.   asm
  2541.     mov esp, ebp
  2542.     pop ebp
  2543.     jmp [_DnsValidateName_UTF8]
  2544.   end;
  2545. end;
  2546. {$ELSE}
  2547. function DnsValidateName_UTF8; external dnsapi name 'DnsValidateName_UTF8';
  2548. {$ENDIF DYNAMIC_LINK}
  2550. {$IFDEF DYNAMIC_LINK}
  2551. var
  2552.   _DnsValidateName_W: Pointer;
  2554. function DnsValidateName_W;
  2555. begin
  2556.   GetProcedureAddress(_DnsValidateName_W, dnsapi, 'DnsValidateName_W');
  2557.   asm
  2558.     mov esp, ebp
  2559.     pop ebp
  2560.     jmp [_DnsValidateName_W]
  2561.   end;
  2562. end;
  2563. {$ELSE}
  2564. function DnsValidateName_W; external dnsapi name 'DnsValidateName_W';
  2565. {$ENDIF DYNAMIC_LINK}
  2567. {$IFDEF DYNAMIC_LINK}
  2568. var
  2569.   _DnsValidateName_A: Pointer;
  2571. function DnsValidateName_A;
  2572. begin
  2573.   GetProcedureAddress(_DnsValidateName_A, dnsapi, 'DnsValidateName_A');
  2574.   asm
  2575.     mov esp, ebp
  2576.     pop ebp
  2577.     jmp [_DnsValidateName_A]
  2578.   end;
  2579. end;
  2580. {$ELSE}
  2581. function DnsValidateName_A; external dnsapi name 'DnsValidateName_A';
  2582. {$ENDIF DYNAMIC_LINK}
  2583. {$IFDEF UNICODE}
  2584. function DnsValidateName(pszName: LPCWSTR; Format: DNS_NAME_FORMAT): DNS_STATUS;
  2585. begin
  2586.   Result := DnsValidateName_W(pszName, Format);
  2587. end;
  2588. {$ELSE}
  2589. function DnsValidateName(pszName: LPCSTR; Format: DNS_NAME_FORMAT): DNS_STATUS;
  2590. begin
  2591.   Result := DnsValidateName_A(pszName, Format);
  2592. end;
  2593. {$ENDIF}
  2595. {$IFDEF DYNAMIC_LINK}
  2596. var
  2597.   _DnsNameCompare_A: Pointer;
  2599. function DnsNameCompare_A;
  2600. begin
  2601.   GetProcedureAddress(_DnsNameCompare_A, dnsapi, 'DnsNameCompare_A');
  2602.   asm
  2603.     mov esp, ebp
  2604.     pop ebp
  2605.     jmp [_DnsNameCompare_A]
  2606.   end;
  2607. end;
  2608. {$ELSE}
  2609. function DnsNameCompare_A; external dnsapi name 'DnsNameCompare_A';
  2610. {$ENDIF DYNAMIC_LINK}
  2612. {$IFDEF DYNAMIC_LINK}
  2613. var
  2614.   _DnsNameCompare_W: Pointer;
  2616. function DnsNameCompare_W;
  2617. begin
  2618.   GetProcedureAddress(_DnsNameCompare_W, dnsapi, 'DnsNameCompare_W');
  2619.   asm
  2620.     mov esp, ebp
  2621.     pop ebp
  2622.     jmp [_DnsNameCompare_W]
  2623.   end;
  2624. end;
  2625. {$ELSE}
  2626. function DnsNameCompare_W; external dnsapi name 'DnsNameCompare_W';
  2627. {$ENDIF DYNAMIC_LINK}
  2628. {$IFDEF UNICODE}
  2630. {$IFDEF DYNAMIC_LINK}
  2631. var
  2632.   _DnsNameCompare: Pointer;
  2634. function DnsNameCompare;
  2635. begin
  2636.   GetProcedureAddress(_DnsNameCompare, dnsapi, 'DnsNameCompare_W');
  2637.   asm
  2638.     mov esp, ebp
  2639.     pop ebp
  2640.     jmp [_DnsNameCompare]
  2641.   end;
  2642. end;
  2643. {$ELSE}
  2644. function DnsNameCompare; external dnsapi name 'DnsNameCompare_W';
  2645. {$ENDIF DYNAMIC_LINK}
  2646. {$ELSE}
  2648. {$IFDEF DYNAMIC_LINK}
  2649. var
  2650.   _DnsNameCompare: Pointer;
  2652. function DnsNameCompare;
  2653. begin
  2654.   GetProcedureAddress(_DnsNameCompare, dnsapi, 'DnsNameCompare_A');
  2655.   asm
  2656.     mov esp, ebp
  2657.     pop ebp
  2658.     jmp [_DnsNameCompare]
  2659.   end;
  2660. end;
  2661. {$ELSE}
  2662. function DnsNameCompare; external dnsapi name 'DnsNameCompare_A';
  2663. {$ENDIF DYNAMIC_LINK}
  2664. {$ENDIF}
  2666. {$IFDEF DYNAMIC_LINK}
  2667. var
  2668.   _DnsWriteQuestionToBuffer_W: Pointer;
  2670. function DnsWriteQuestionToBuffer_W;
  2671. begin
  2672.   GetProcedureAddress(_DnsWriteQuestionToBuffer_W, dnsapi, 'DnsWriteQuestionToBuffer_W');
  2673.   asm
  2674.     mov esp, ebp
  2675.     pop ebp
  2676.     jmp [_DnsWriteQuestionToBuffer_W]
  2677.   end;
  2678. end;
  2679. {$ELSE}
  2680. function DnsWriteQuestionToBuffer_W; external dnsapi name 'DnsWriteQuestionToBuffer_W';
  2681. {$ENDIF DYNAMIC_LINK}
  2683. {$IFDEF DYNAMIC_LINK}
  2684. var
  2685.   _DnsWriteQuestionToBuffer_UTF8: Pointer;
  2687. function DnsWriteQuestionToBuffer_UTF8;
  2688. begin
  2689.   GetProcedureAddress(_DnsWriteQuestionToBuffer_UTF8, dnsapi, 'DnsWriteQuestionToBuffer_UTF8');
  2690.   asm
  2691.     mov esp, ebp
  2692.     pop ebp
  2693.     jmp [_DnsWriteQuestionToBuffer_UTF8]
  2694.   end;
  2695. end;
  2696. {$ELSE}
  2697. function DnsWriteQuestionToBuffer_UTF8; external dnsapi name 'DnsWriteQuestionToBuffer_UTF8';
  2698. {$ENDIF DYNAMIC_LINK}
  2700. {$IFDEF DYNAMIC_LINK}
  2701. var
  2702.   _DnsExtractRecordsFromMessage_W: Pointer;
  2704. function DnsExtractRecordsFromMessage_W;
  2705. begin
  2706.   GetProcedureAddress(_DnsExtractRecordsFromMessage_W, dnsapi, 'DnsExtractRecordsFromMessage_W');
  2707.   asm
  2708.     mov esp, ebp
  2709.     pop ebp
  2710.     jmp [_DnsExtractRecordsFromMessage_W]
  2711.   end;
  2712. end;
  2713. {$ELSE}
  2714. function DnsExtractRecordsFromMessage_W; external dnsapi name 'DnsExtractRecordsFromMessage_W';
  2715. {$ENDIF DYNAMIC_LINK}
  2717. {$IFDEF DYNAMIC_LINK}
  2718. var
  2719.   _DnsExtractRecFromMessage_UTF8: Pointer;
  2721. function DnsExtractRecordsFromMessage_UTF8;
  2722. begin
  2723.   GetProcedureAddress(_DnsExtractRecFromMessage_UTF8, dnsapi, 'DnsExtractRecordsFromMessage_UTF8');
  2724.   asm
  2725.     mov esp, ebp
  2726.     pop ebp
  2727.     jmp [_DnsExtractRecFromMessage_UTF8]
  2728.   end;
  2729. end;
  2730. {$ELSE}
  2731. function DnsExtractRecordsFromMessage_UTF8; external dnsapi name 'DnsExtractRecordsFromMessage_UTF8';
  2732. {$ENDIF DYNAMIC_LINK}
  2735. end.