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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 模拟服务器 > 查看源码
WinDNS.h
资源名称：SwordOnline.rar　[点击查看]
上传用户：dzyhzl
上传日期：2019-04-29
资源大小：56270k
文件大小：42k
源码类别：

模拟服务器

开发平台：

C/C++

WinDNS.h：源码内容
  1. /*++
  3. Copyright (c) 1996-2000  Microsoft Corporation
  5. Module Name:
  7.     windns.h
  9. Abstract:
  11.     Domain Name System (DNS)
  13.     DNS definitions and DNS API.
  15. Author:
  17.     Jim Gilroy (jamesg)     December 7, 1996
  18.     Glenn Curtis (glennc)   January 22, 1997
  20. Revision History:
  22. --*/
  25. #ifndef _WINDNS_INCLUDED_
  26. #define _WINDNS_INCLUDED_
  29. #ifdef __cplusplus
  30. extern "C"
  31. {
  32. #endif  // __cplusplus
  35. //
  36. //  Define QWORD -- not yet defined globally 
  37. //
  39. typedef unsigned __int64 QWORD;
  41. //
  42. //  DNS public types
  43. //
  45. typedef LONG    DNS_STATUS, *PDNS_STATUS;
  47. //
  48. //  IP Address
  49. //
  51. typedef DWORD   IP4_ADDRESS, *PIP4_ADDRESS;
  53. #define SIZEOF_IP4_ADDRESS                  (4)
  54. #define IP4_ADDRESS_STRING_LENGTH           (15)
  55. #define IP4_ADDRESS_STRING_BUFFER_LENGTH    (16)
  58. //
  59. //  IP Address Array type
  60. //
  62. typedef struct  _IP4_ARRAY
  63. {
  64.     DWORD           AddrCount;
  65. #ifdef MIDL_PASS
  66.     [size_is( AddrCount )]  IP4_ADDRESS  AddrArray[];
  67. #else
  68.     IP4_ADDRESS     AddrArray[1];
  69. #endif
  70. }
  71. IP4_ARRAY, *PIP4_ARRAY;
  74. //
  75. //  IPv6 Address
  76. //
  78. #ifdef MIDL_PASS
  79. typedef struct
  80. {
  81. #ifdef _WIN64
  82.     QWORD       IP6Qword[2];
  83. #else
  84.     DWORD       IP6Dword[4];
  85. #endif
  86. }
  87. IP6_ADDRESS, *PIP6_ADDRESS;
  88. #else
  89. typedef union
  90. {
  91. #ifdef _WIN64
  92.     QWORD       IP6Qword[2];
  93. #endif
  94.     DWORD       IP6Dword[4];
  95.     WORD        IP6Word[8];
  96.     BYTE        IP6Byte[16];
  97. #ifdef  IN6_ADDR
  98.     IN6_ADDR    In6;
  99. #endif
  100. }
  101. IP6_ADDRESS, *PIP6_ADDRESS;
  102. #endif
  104. //  Backward compatibility
  106. typedef IP6_ADDRESS  DNS_IP6_ADDRESS, *PDNS_IP6_ADDRESS;
  108. //
  109. //  IP6 string max is 45 bytes
  110. //      - 6 WORDs in colon+hex (5 chars)
  111. //      - last DWORD as IP4 (15 chars)
  112. //  
  114. #undef  IP6_ADDRESS_STRING_LENGTH
  115. #define IP6_ADDRESS_STRING_LENGTH           (47)
  116. #define IP6_ADDRESS_STRING_BUFFER_LENGTH    (48)
  118. //  backcompat
  119. #define IPV6_ADDRESS_STRING_LENGTH      IP6_ADDRESS_STRING_LENGTH
  122. //
  123. //  Inline byte flipping -- can be done in registers
  124. //
  126. #define INLINE_WORD_FLIP(out, in)   
  127.         {                           
  128.             WORD _in = (in);        
  129.             (out) = (_in << 8) | (_in >> 8);  
  130.         }
  131. #define INLINE_HTONS(out, in)   INLINE_WORD_FLIP(out, in)
  132. #define INLINE_NTOHS(out, in)   INLINE_WORD_FLIP(out, in)
  134. #define INLINE_DWORD_FLIP(out, in)  
  135.         {                           
  136.             DWORD _in = (in);       
  137.             (out) = ((_in << 8) & 0x00ff0000) | 
  138.                     (_in << 24)               | 
  139.                     ((_in >> 8) & 0x0000ff00) | 
  140.                     (_in >> 24);                
  141.         }
  142. #define INLINE_NTOHL(out, in) INLINE_DWORD_FLIP(out, in)
  143. #define INLINE_HTONL(out, in) INLINE_DWORD_FLIP(out, in)
  146. //
  147. //  Inline byte flip and write to packet (unaligned)
  148. //
  150. #define INLINE_WRITE_FLIPPED_WORD( pout, in ) 
  151.             INLINE_WORD_FLIP( *((UNALIGNED WORD *)(pout)), in )
  153. #define INLINE_WRITE_FLIPPED_DWORD( pout, in ) 
  154.             INLINE_DWORD_FLIP( *((UNALIGNED DWORD *)(pout)), in )
  159. //
  160. //  Basic DNS definitions
  161. //
  163. //
  164. //  DNS port for both UDP and TCP is 53.
  165. //
  167. #define DNS_PORT_HOST_ORDER     (0x0035)    // port 53
  168. #define DNS_PORT_NET_ORDER      (0x3500)
  170. //
  171. //  DNS UDP packets no more than 512 bytes
  172. //
  174. #define DNS_RFC_MAX_UDP_PACKET_LENGTH   (512)
  177. //
  178. //  DNS Names limited to 255, 63 in any one label
  179. //
  181. #define DNS_MAX_NAME_LENGTH             (255)
  182. #define DNS_MAX_LABEL_LENGTH            (63)
  184. #define DNS_MAX_NAME_BUFFER_LENGTH      (256)
  185. #define DNS_MAX_LABEL_BUFFER_LENGTH     (64)
  187. //
  188. //  Reverse lookup domain names
  189. //
  191. #define DNS_IP4_REVERSE_DOMAIN_STRING ("in-addr.arpa.")
  193. #define DNS_MAX_IP4_REVERSE_NAME_LENGTH 
  194.             (IP_ADDRESS_STRING_LENGTH+1+sizeof(DNS_IP4_REVERSE_DOMAIN_STRING))
  196. #define DNS_MAX_IP4_REVERSE_NAME_BUFFER_LENGTH 
  197.             (DNS_MAX_IP4_REVERSE_NAME_LENGTH + 1)
  200. #define DNS_IP6_REVERSE_DOMAIN_STRING ("ip6.int.")
  202. #define DNS_MAX_IP6_REVERSE_NAME_LENGTH 
  203.             (64+sizeof(DNS_IP6_REVERSE_DOMAIN_STRING))
  205. #define DNS_MAX_IP6_REVERSE_NAME_BUFFER_LENGTH 
  206.             (DNS_MAX_IP6_REVERSE_NAME_LENGTH + 1)
  208. //  Combined
  210. #define DNS_MAX_REVERSE_NAME_LENGTH 
  211.         DNS_MAX_IP6_REVERSE_NAME_LENGTH 
  213. #define DNS_MAX_REVERSE_NAME_BUFFER_LENGTH 
  214.         DNS_MAX_IP6_REVERSE_NAME_BUFFER_LENGTH
  217. //
  218. //  DNS Text string limited by size representable
  219. //      in a single byte length field
  221. #define DNS_MAX_TEXT_STRING_LENGTH  (255)
  226. //
  227. //  DNS On-The-Wire Structures
  228. //
  230. #pragma pack(1)
  232. //
  233. //  DNS Message Header
  234. //
  236. typedef struct _DNS_HEADER
  237. {
  238.     WORD    Xid;
  240.     BYTE    RecursionDesired : 1;
  241.     BYTE    Truncation : 1;
  242.     BYTE    Authoritative : 1;
  243.     BYTE    Opcode : 4;
  244.     BYTE    IsResponse : 1;
  246.     BYTE    ResponseCode : 4;
  247.     BYTE    Reserved : 3;
  248.     BYTE    RecursionAvailable : 1;
  250.     WORD    QuestionCount;
  251.     WORD    AnswerCount;
  252.     WORD    NameServerCount;
  253.     WORD    AdditionalCount;
  254. }
  255. DNS_HEADER, *PDNS_HEADER;
  258. //
  259. //  Flags as WORD
  260. //
  262. #define DNS_HEADER_FLAGS(pHead)     ( *((PWORD)(pHead)+1) )
  265. //
  266. //  Byte flip DNS header tofrom host order.
  267. //
  268. //  Note that this does NOT flip flags, as definition above defines
  269. //  flags as individual bytes for direct access to net byte order.
  270. //
  272. #define DNS_BYTE_FLIP_HEADER_COUNTS(pHeader)       
  273.         {                                   
  274.             PDNS_HEADER _head = (pHeader);  
  275.             INLINE_HTONS(_head->Xid,            _head->Xid             ); 
  276.             INLINE_HTONS(_head->QuestionCount,  _head->QuestionCount   ); 
  277.             INLINE_HTONS(_head->AnswerCount,    _head->AnswerCount     ); 
  278.             INLINE_HTONS(_head->NameServerCount,_head->NameServerCount ); 
  279.             INLINE_HTONS(_head->AdditionalCount,_head->AdditionalCount ); 
  280.         }
  282. //
  283. //  Question name follows header
  284. //
  286. #define DNS_OFFSET_TO_QUESTION_NAME     sizeof(DNS_HEADER)
  288. //
  289. //  Question immediately follows header so compressed question name
  290. //      0xC000 | sizeof(DNS_HEADER)
  292. #define DNS_COMPRESSED_QUESTION_NAME  (0xC00C)
  295. //
  296. //  Packet extraction macros
  297. //
  299. #define DNS_QUESTION_NAME_FROM_HEADER( _pHeader_ ) 
  300.             ( (PCHAR)( (PDNS_HEADER)(_pHeader_) + 1 ) )
  302. #define DNS_ANSWER_FROM_QUESTION( _pQuestion_ ) 
  303.             ( (PCHAR)( (PDNS_QUESTION)(_pQuestion_) + 1 ) )
  306. //
  307. //  DNS Question
  308. //
  310. typedef struct _DNS_WIRE_QUESTION
  311. {
  312.     //  Preceded by question name
  314.     WORD    QuestionType;
  315.     WORD    QuestionClass;
  316. }
  317. DNS_WIRE_QUESTION, *PDNS_WIRE_QUESTION;
  320. //
  321. //  DNS Resource Record
  322. //
  324. typedef struct _DNS_WIRE_RECORD
  325. {
  326.     //  Preceded by record owner name
  328.     WORD    RecordType;
  329.     WORD    RecordClass;
  330.     DWORD   TimeToLive;
  331.     WORD    DataLength;
  333.     //  Followed by record data
  334. }
  335. DNS_WIRE_RECORD, *PDNS_WIRE_RECORD;
  337. #pragma pack()
  340. //
  341. //  DNS Query Types
  342. //
  344. #define DNS_OPCODE_QUERY            0   // Query
  345. #define DNS_OPCODE_IQUERY           1   // Obsolete: IP to name
  346. #define DNS_OPCODE_SERVER_STATUS    2   // Obsolete: DNS ping
  347. #define DNS_OPCODE_UNKNOWN          3   // Unknown
  348. #define DNS_OPCODE_NOTIFY           4   // Notify
  349. #define DNS_OPCODE_UPDATE           5   // Dynamic Update
  351. //
  352. //  DNS response codes.
  353. //
  354. //  Sent in the "ResponseCode" field of a DNS_HEADER.
  355. //
  357. #define DNS_RCODE_NOERROR       0
  358. #define DNS_RCODE_FORMERR       1       // Format error
  359. #define DNS_RCODE_SERVFAIL      2       // Server failure
  360. #define DNS_RCODE_NXDOMAIN      3       // Name error
  361. #define DNS_RCODE_NOTIMPL       4       // Not implemented
  362. #define DNS_RCODE_REFUSED       5       // Refused
  363. #define DNS_RCODE_YXDOMAIN      6       // Domain name should not exist
  364. #define DNS_RCODE_YXRRSET       7       // RR set should not exist
  365. #define DNS_RCODE_NXRRSET       8       // RR set does not exist
  366. #define DNS_RCODE_NOTAUTH       9       // Not authoritative for zone
  367. #define DNS_RCODE_NOTZONE       10      // Name is not zone
  368. #define DNS_RCODE_MAX           15
  370. //
  371. //  Extended RCODEs
  372. //
  374. #define DNS_RCODE_BADVERS       16      // Bad EDNS version
  375. #define DNS_RCODE_BADSIG        16      // Bad signature
  376. #define DNS_RCODE_BADKEY        17      // Bad key
  377. #define DNS_RCODE_BADTIME       18      // Bad timestamp
  379. //
  380. //  Mappings to friendly names
  381. //
  383. #define DNS_RCODE_NO_ERROR          DNS_RCODE_NOERROR
  384. #define DNS_RCODE_FORMAT_ERROR      DNS_RCODE_FORMERR
  385. #define DNS_RCODE_SERVER_FAILURE    DNS_RCODE_SERVFAIL
  386. #define DNS_RCODE_NAME_ERROR        DNS_RCODE_NXDOMAIN
  387. #define DNS_RCODE_NOT_IMPLEMENTED   DNS_RCODE_NOTIMPL
  390. //
  391. //  DNS Classes
  392. //
  393. //  Classes are on the wire as WORDs.
  394. //
  395. //  _CLASS_ defines in host order.
  396. //  _RCLASS_ defines in net byte order.
  397. //
  398. //  Generally we'll avoid byte flip and test class in net byte order.
  399. //
  401. #define DNS_CLASS_INTERNET  0x0001      //  1
  402. #define DNS_CLASS_CSNET     0x0002      //  2
  403. #define DNS_CLASS_CHAOS     0x0003      //  3
  404. #define DNS_CLASS_HESIOD    0x0004      //  4
  405. #define DNS_CLASS_NONE      0x00fe      //  254
  406. #define DNS_CLASS_ALL       0x00ff      //  255
  407. #define DNS_CLASS_ANY       0x00ff      //  255
  409. #define DNS_RCLASS_INTERNET 0x0100      //  1
  410. #define DNS_RCLASS_CSNET    0x0200      //  2
  411. #define DNS_RCLASS_CHAOS    0x0300      //  3
  412. #define DNS_RCLASS_HESIOD   0x0400      //  4
  413. #define DNS_RCLASS_NONE     0xfe00      //  254
  414. #define DNS_RCLASS_ALL      0xff00      //  255
  415. #define DNS_RCLASS_ANY      0xff00      //  255
  419. //
  420. //  DNS Record Types
  421. //
  422. //  _TYPE_ defines are in host byte order.
  423. //  _RTYPE_ defines are in net byte order.
  424. //
  425. //  Generally always deal with types in host byte order as we index
  426. //  resource record functions by type.
  427. //
  429. #define DNS_TYPE_ZERO       0x0000
  431. //  RFC 1034/1035
  432. #define DNS_TYPE_A          0x0001      //  1
  433. #define DNS_TYPE_NS         0x0002      //  2
  434. #define DNS_TYPE_MD         0x0003      //  3
  435. #define DNS_TYPE_MF         0x0004      //  4
  436. #define DNS_TYPE_CNAME      0x0005      //  5
  437. #define DNS_TYPE_SOA        0x0006      //  6
  438. #define DNS_TYPE_MB         0x0007      //  7
  439. #define DNS_TYPE_MG         0x0008      //  8
  440. #define DNS_TYPE_MR         0x0009      //  9
  441. #define DNS_TYPE_NULL       0x000a      //  10
  442. #define DNS_TYPE_WKS        0x000b      //  11
  443. #define DNS_TYPE_PTR        0x000c      //  12
  444. #define DNS_TYPE_HINFO      0x000d      //  13
  445. #define DNS_TYPE_MINFO      0x000e      //  14
  446. #define DNS_TYPE_MX         0x000f      //  15
  447. #define DNS_TYPE_TEXT       0x0010      //  16
  449. //  RFC 1183
  450. #define DNS_TYPE_RP         0x0011      //  17
  451. #define DNS_TYPE_AFSDB      0x0012      //  18
  452. #define DNS_TYPE_X25        0x0013      //  19
  453. #define DNS_TYPE_ISDN       0x0014      //  20
  454. #define DNS_TYPE_RT         0x0015      //  21
  456. //  RFC 1348
  457. #define DNS_TYPE_NSAP       0x0016      //  22
  458. #define DNS_TYPE_NSAPPTR    0x0017      //  23
  460. //  RFC 2065    (DNS security)
  461. #define DNS_TYPE_SIG        0x0018      //  24
  462. #define DNS_TYPE_KEY        0x0019      //  25
  464. //  RFC 1664    (X.400 mail)
  465. #define DNS_TYPE_PX         0x001a      //  26
  467. //  RFC 1712    (Geographic position)
  468. #define DNS_TYPE_GPOS       0x001b      //  27
  470. //  RFC 1886    (IPv6 Address)
  471. #define DNS_TYPE_AAAA       0x001c      //  28
  473. //  RFC 1876    (Geographic location)
  474. #define DNS_TYPE_LOC        0x001d      //  29
  476. //  RFC 2065    (Secure negative response)
  477. #define DNS_TYPE_NXT        0x001e      //  30
  479. //  Patton      (Endpoint Identifier)
  480. #define DNS_TYPE_EID        0x001f      //  31
  482. //  Patton      (Nimrod Locator)
  483. #define DNS_TYPE_NIMLOC     0x0020      //  32
  485. //  RFC 2052    (Service location)
  486. #define DNS_TYPE_SRV        0x0021      //  33
  488. //  ATM Standard something-or-another (ATM Address)
  489. #define DNS_TYPE_ATMA       0x0022      //  34
  491. //  RFC 2168    (Naming Authority Pointer)
  492. #define DNS_TYPE_NAPTR      0x0023      //  35
  494. //  RFC 2230    (Key Exchanger)
  495. #define DNS_TYPE_KX         0x0024      //  36
  497. //  RFC 2538    (CERT)
  498. #define DNS_TYPE_CERT       0x0025      //  37
  500. //  A6 Draft    (A6)
  501. #define DNS_TYPE_A6         0x0026      //  38
  503. //  DNAME Draft (DNAME)
  504. #define DNS_TYPE_DNAME      0x0027      //  39
  506. //  Eastlake    (Kitchen Sink)
  507. #define DNS_TYPE_SINK       0x0028      //  40
  509. //  RFC 2671    (EDNS OPT)
  510. #define DNS_TYPE_OPT        0x0029      //  41
  512. //
  513. //  IANA Reserved
  514. //
  516. #define DNS_TYPE_UINFO      0x0064      //  100
  517. #define DNS_TYPE_UID        0x0065      //  101
  518. #define DNS_TYPE_GID        0x0066      //  102
  519. #define DNS_TYPE_UNSPEC     0x0067      //  103
  521. //
  522. //  Query only types (1035, 1995)
  523. //      - Crawford      (ADDRS)
  524. //      - TKEY draft    (TKEY)
  525. //      - TSIG draft    (TSIG)
  526. //      - RFC 1995      (IXFR)
  527. //      - RFC 1035      (AXFR up)
  528. //
  530. #define DNS_TYPE_ADDRS      0x00f8      //  248
  531. #define DNS_TYPE_TKEY       0x00f9      //  249
  532. #define DNS_TYPE_TSIG       0x00fa      //  250
  533. #define DNS_TYPE_IXFR       0x00fb      //  251
  534. #define DNS_TYPE_AXFR       0x00fc      //  252
  535. #define DNS_TYPE_MAILB      0x00fd      //  253
  536. #define DNS_TYPE_MAILA      0x00fe      //  254
  537. #define DNS_TYPE_ALL        0x00ff      //  255
  538. #define DNS_TYPE_ANY        0x00ff      //  255
  540. //
  541. //  Temp Microsoft types -- use until get IANA approval for real type
  542. //
  544. #define DNS_TYPE_WINS       0xff01      //  64K - 255
  545. #define DNS_TYPE_WINSR      0xff02      //  64K - 254
  546. #define DNS_TYPE_NBSTAT     (DNS_TYPE_WINSR)
  549. //
  550. //  DNS Record Types -- Net Byte Order
  551. //
  553. #define DNS_RTYPE_A         0x0100      //  1
  554. #define DNS_RTYPE_NS        0x0200      //  2
  555. #define DNS_RTYPE_MD        0x0300      //  3
  556. #define DNS_RTYPE_MF        0x0400      //  4
  557. #define DNS_RTYPE_CNAME     0x0500      //  5
  558. #define DNS_RTYPE_SOA       0x0600      //  6
  559. #define DNS_RTYPE_MB        0x0700      //  7
  560. #define DNS_RTYPE_MG        0x0800      //  8
  561. #define DNS_RTYPE_MR        0x0900      //  9
  562. #define DNS_RTYPE_NULL      0x0a00      //  10
  563. #define DNS_RTYPE_WKS       0x0b00      //  11
  564. #define DNS_RTYPE_PTR       0x0c00      //  12
  565. #define DNS_RTYPE_HINFO     0x0d00      //  13
  566. #define DNS_RTYPE_MINFO     0x0e00      //  14
  567. #define DNS_RTYPE_MX        0x0f00      //  15
  568. #define DNS_RTYPE_TEXT      0x1000      //  16
  569. #define DNS_RTYPE_RP        0x1100      //  17
  570. #define DNS_RTYPE_AFSDB     0x1200      //  18
  571. #define DNS_RTYPE_X25       0x1300      //  19
  572. #define DNS_RTYPE_ISDN      0x1400      //  20
  573. #define DNS_RTYPE_RT        0x1500      //  21
  574. #define DNS_RTYPE_NSAP      0x1600      //  22
  575. #define DNS_RTYPE_NSAPPTR   0x1700      //  23
  576. #define DNS_RTYPE_SIG       0x1800      //  24
  577. #define DNS_RTYPE_KEY       0x1900      //  25
  578. #define DNS_RTYPE_PX        0x1a00      //  26
  579. #define DNS_RTYPE_GPOS      0x1b00      //  27
  580. #define DNS_RTYPE_AAAA      0x1c00      //  28
  581. #define DNS_RTYPE_LOC       0x1d00      //  29
  582. #define DNS_RTYPE_NXT       0x1e00      //  30
  583. #define DNS_RTYPE_EID       0x1f00      //  31
  584. #define DNS_RTYPE_NIMLOC    0x2000      //  32
  585. #define DNS_RTYPE_SRV       0x2100      //  33
  586. #define DNS_RTYPE_ATMA      0x2200      //  34
  587. #define DNS_RTYPE_NAPTR     0x2300      //  35
  588. #define DNS_RTYPE_KX        0x2400      //  36
  589. #define DNS_RTYPE_CERT      0x2500      //  37
  590. #define DNS_RTYPE_A6        0x2600      //  38
  591. #define DNS_RTYPE_DNAME     0x2700      //  39
  592. #define DNS_RTYPE_SINK      0x2800      //  40
  593. #define DNS_RTYPE_OPT       0x2900      //  41
  595. //
  596. //  IANA Reserved
  597. //
  599. #define DNS_RTYPE_UINFO     0x6400      //  100
  600. #define DNS_RTYPE_UID       0x6500      //  101
  601. #define DNS_RTYPE_GID       0x6600      //  102
  602. #define DNS_RTYPE_UNSPEC    0x6700      //  103
  604. //
  605. //  Query only types
  606. //
  608. #define DNS_RTYPE_TKEY      0xf900      //  249
  609. #define DNS_RTYPE_TSIG      0xfa00      //  250
  610. #define DNS_RTYPE_IXFR      0xfb00      //  251
  611. #define DNS_RTYPE_AXFR      0xfc00      //  252
  612. #define DNS_RTYPE_MAILB     0xfd00      //  253
  613. #define DNS_RTYPE_MAILA     0xfe00      //  254
  614. #define DNS_RTYPE_ALL       0xff00      //  255
  615. #define DNS_RTYPE_ANY       0xff00      //  255
  617. //
  618. //  Temp Microsoft types -- use until get IANA approval for real type
  619. //
  621. #define DNS_RTYPE_WINS      0x01ff      //  64K - 255
  622. #define DNS_RTYPE_WINSR     0x02ff      //  64K - 254
  627. //
  628. //  Record type specific definitions
  629. //
  631. //
  632. //  ATMA (ATM address type) formats
  633. //
  634. //  Define these directly for any environment (ex NT4)
  635. //  without winsock2 ATM support (ws2atm.h)
  636. //
  638. #ifndef  ATMA_E164
  639. #define DNS_ATMA_FORMAT_E164            1
  640. #define DNS_ATMA_FORMAT_AESA            2
  641. #define DNS_ATMA_MAX_ADDR_LENGTH        (20)
  642. #else
  643. #define DNS_ATMA_FORMAT_E164            ATM_E164
  644. #define DNS_ATMA_FORMAT_AESA            ATM_AESA
  645. #define DNS_ATMA_MAX_ADDR_LENGTH        ATM_ADDR_SIZE
  646. #endif
  648. #define DNS_ATMA_AESA_ADDR_LENGTH       (20)
  649. #define DNS_ATMA_MAX_RECORD_LENGTH      (DNS_ATMA_MAX_ADDR_LENGTH+1)
  652. //
  653. //  DNSSEC defs
  654. //
  656. //  DNSSEC algorithms
  658. #define DNSSEC_ALGORITHM_RSAMD5     1
  659. #define DNSSEC_ALGORITHM_NULL       253
  660. #define DNSSEC_ALGORITHM_PRIVATE    254
  662. //  DNSSEC KEY protocol table
  664. #define DNSSEC_PROTOCOL_NONE        0
  665. #define DNSSEC_PROTOCOL_TLS         1
  666. #define DNSSEC_PROTOCOL_EMAIL       2
  667. #define DNSSEC_PROTOCOL_DNSSEC      3
  668. #define DNSSEC_PROTOCOL_IPSEC       4
  670. //  DNSSEC KEY flag field
  672. #define DNSSEC_KEY_FLAG_NOAUTH          0x0001
  673. #define DNSSEC_KEY_FLAG_NOCONF          0x0002
  674. #define DNSSEC_KEY_FLAG_FLAG2           0x0004
  675. #define DNSSEC_KEY_FLAG_EXTEND          0x0008
  676. #define DNSSEC_KEY_FLAG_
  677. #define DNSSEC_KEY_FLAG_FLAG4           0x0010
  678. #define DNSSEC_KEY_FLAG_FLAG5           0x0020
  680. // bits 6,7 are name type
  682. #define DNSSEC_KEY_FLAG_USER            0x0000
  683. #define DNSSEC_KEY_FLAG_ZONE            0x0040
  684. #define DNSSEC_KEY_FLAG_HOST            0x0080
  685. #define DNSSEC_KEY_FLAG_NTPE3           0x00c0
  687. // bits 8-11 are reserved for future use
  689. #define DNSSEC_KEY_FLAG_FLAG8           0x0100
  690. #define DNSSEC_KEY_FLAG_FLAG9           0x0200
  691. #define DNSSEC_KEY_FLAG_FLAG10          0x0400
  692. #define DNSSEC_KEY_FLAG_FLAG11          0x0800
  694. // bits 12-15 are sig field
  696. #define DNSSEC_KEY_FLAG_SIG0            0x0000
  697. #define DNSSEC_KEY_FLAG_SIG1            0x1000
  698. #define DNSSEC_KEY_FLAG_SIG2            0x2000
  699. #define DNSSEC_KEY_FLAG_SIG3            0x3000
  700. #define DNSSEC_KEY_FLAG_SIG4            0x4000
  701. #define DNSSEC_KEY_FLAG_SIG5            0x5000
  702. #define DNSSEC_KEY_FLAG_SIG6            0x6000
  703. #define DNSSEC_KEY_FLAG_SIG7            0x7000
  704. #define DNSSEC_KEY_FLAG_SIG8            0x8000
  705. #define DNSSEC_KEY_FLAG_SIG9            0x9000
  706. #define DNSSEC_KEY_FLAG_SIG10           0xa000
  707. #define DNSSEC_KEY_FLAG_SIG11           0xb000
  708. #define DNSSEC_KEY_FLAG_SIG12           0xc000
  709. #define DNSSEC_KEY_FLAG_SIG13           0xd000
  710. #define DNSSEC_KEY_FLAG_SIG14           0xe000
  711. #define DNSSEC_KEY_FLAG_SIG15           0xf000
  714. //
  715. //  TKEY modes
  716. //
  718. #define DNS_TKEY_MODE_SERVER_ASSIGN         1
  719. #define DNS_TKEY_MODE_DIFFIE_HELLMAN        2
  720. #define DNS_TKEY_MODE_GSS                   3
  721. #define DNS_TKEY_MODE_RESOLVER_ASSIGN       4
  723. //
  724. //  WINS + NBSTAT flag field
  725. //
  727. #define DNS_WINS_FLAG_SCOPE     (0x80000000)
  728. #define DNS_WINS_FLAG_LOCAL     (0x00010000)
  731. //
  732. //  Helpful checks
  733. //
  735. #define IS_WORD_ALIGNED(p)      ( !((UINT_PTR)(p) & (UINT_PTR)1) )
  736. #define IS_DWORD_ALIGNED(p)     ( !((UINT_PTR)(p) & (UINT_PTR)3) )
  737. #define IS_QWORD_ALIGNED(p)     ( !((UINT_PTR)(p) & (UINT_PTR)7) )
  742. //
  743. //  DNS config API
  744. //
  746. //
  747. //  Types of DNS configuration info
  748. //
  750. typedef enum
  751. {
  752.     //  In Win2K
  753.     DnsConfigPrimaryDomainName_W,
  754.     DnsConfigPrimaryDomainName_A,
  755.     DnsConfigPrimaryDomainName_UTF8,
  757.     //  Not available yet
  758.     DnsConfigAdapterDomainName_W,
  759.     DnsConfigAdapterDomainName_A,
  760.     DnsConfigAdapterDomainName_UTF8,
  762.     //  In Win2K
  763.     DnsConfigDnsServerList,
  765.     //  Not available yet
  766.     DnsConfigSearchList,
  767.     DnsConfigAdapterInfo,
  769.     //  In Win2K
  770.     DnsConfigPrimaryHostNameRegistrationEnabled,
  771.     DnsConfigAdapterHostNameRegistrationEnabled,
  772.     DnsConfigAddressRegistrationMaxCount,
  774.     //  In WindowsXP
  775.     DnsConfigHostName_W,
  776.     DnsConfigHostName_A,
  777.     DnsConfigHostName_UTF8,
  778.     DnsConfigFullHostName_W,
  779.     DnsConfigFullHostName_A,
  780.     DnsConfigFullHostName_UTF8
  781. }
  782. DNS_CONFIG_TYPE;
  784. //
  785. //  Config API flags
  786. //
  788. //
  789. //  Causes config info to be allocated with LocalAlloc()
  790. //
  792. #define DNS_CONFIG_FLAG_ALLOC   (0x00000001)
  795. DNS_STATUS
  796. WINAPI
  797. DnsQueryConfig(
  798.     IN      DNS_CONFIG_TYPE     Config,
  799.     IN      DWORD               Flag,
  800.     IN      PWSTR               pwsAdapterName,
  801.     IN      PVOID               pReserved,
  802.     OUT     PVOID               pBuffer,
  803.     IN OUT  PDWORD              pBufferLength
  804.     );
  808. //
  809. //  DNS resource record structure
  810. //
  812. //
  813. //  Record data for specific types
  814. //
  816. typedef struct
  817. {
  818.     IP4_ADDRESS     IpAddress;
  819. }
  820. DNS_A_DATA, *PDNS_A_DATA;
  822. typedef struct
  823. {
  824.     LPTSTR          pNameHost;
  825. }
  826. DNS_PTR_DATA, *PDNS_PTR_DATA;
  828. typedef struct
  829. {
  830.     LPTSTR          pNamePrimaryServer;
  831.     LPTSTR          pNameAdministrator;
  832.     DWORD           dwSerialNo;
  833.     DWORD           dwRefresh;
  834.     DWORD           dwRetry;
  835.     DWORD           dwExpire;
  836.     DWORD           dwDefaultTtl;
  837. }
  838. DNS_SOA_DATA, *PDNS_SOA_DATA;
  840. typedef struct
  841. {
  842.     LPTSTR          pNameMailbox;
  843.     LPTSTR          pNameErrorsMailbox;
  844. }
  845. DNS_MINFO_DATA, *PDNS_MINFO_DATA;
  847. typedef struct
  848. {
  849.     LPTSTR          pNameExchange;
  850.     WORD            wPreference;
  851.     WORD            Pad;        // keep ptrs DWORD aligned
  852. }
  853. DNS_MX_DATA, *PDNS_MX_DATA;
  855. typedef struct
  856. {
  857.     DWORD           dwStringCount;
  858. #ifdef MIDL_PASS
  859.     [size_is(dwStringCount)] LPTSTR pStringArray[];
  860. #else
  861.     LPTSTR          pStringArray[1];
  862. #endif
  863. }
  864. DNS_TXT_DATA, *PDNS_TXT_DATA;
  866. typedef struct
  867. {
  868.     DWORD           dwByteCount;
  869. #ifdef MIDL_PASS
  870.     [size_is(dwByteCount)] BYTE Data[];
  871. #else
  872.     BYTE            Data[1];
  873. #endif
  874. }
  875. DNS_NULL_DATA, *PDNS_NULL_DATA;
  877. typedef struct
  878. {
  879.     IP4_ADDRESS     IpAddress;
  880.     UCHAR           chProtocol;
  881.     BYTE            BitMask[1];
  882. }
  883. DNS_WKS_DATA, *PDNS_WKS_DATA;
  885. typedef struct
  886. {
  887.     DNS_IP6_ADDRESS Ip6Address;
  888. }
  889. DNS_AAAA_DATA, *PDNS_AAAA_DATA;
  891. typedef struct
  892. {
  893.     LPTSTR          pNameSigner;
  894.     WORD            wTypeCovered;
  895.     BYTE            chAlgorithm;
  896.     BYTE            chLabelCount;
  897.     DWORD           dwOriginalTtl;
  898.     DWORD           dwExpiration;
  899.     DWORD           dwTimeSigned;
  900.     WORD            wKeyTag;
  901.     WORD            Pad;            // keep byte field aligned
  902.     BYTE            Signature[1];
  903. }
  904. DNS_SIG_DATA, *PDNS_SIG_DATA;
  906. typedef struct
  907. {
  908.     WORD            wFlags;
  909.     BYTE            chProtocol;
  910.     BYTE            chAlgorithm;
  911.     BYTE            Key[1];
  912. }
  913. DNS_KEY_DATA, *PDNS_KEY_DATA;
  915. typedef struct
  916. {
  917.     WORD            wVersion;
  918.     WORD            wSize;
  919.     WORD            wHorPrec;
  920.     WORD            wVerPrec;
  921.     DWORD           dwLatitude;
  922.     DWORD           dwLongitude;
  923.     DWORD           dwAltitude;
  924. }
  925. DNS_LOC_DATA, *PDNS_LOC_DATA;
  927. typedef struct
  928. {
  929.     LPTSTR          pNameNext;
  930.     WORD            wNumTypes;
  931.     WORD            wTypes[1];
  932. }
  933. DNS_NXT_DATA, *PDNS_NXT_DATA;
  935. typedef struct
  936. {
  937.     LPTSTR          pNameTarget;
  938.     WORD            wPriority;
  939.     WORD            wWeight;
  940.     WORD            wPort;
  941.     WORD            Pad;            // keep ptrs DWORD aligned
  942. }
  943. DNS_SRV_DATA, *PDNS_SRV_DATA;
  945. typedef struct
  946. {
  947.     BYTE            AddressType;
  948.     BYTE            Address[ DNS_ATMA_MAX_ADDR_LENGTH ];
  950.     //  E164 -- Null terminated string of less than
  951.     //      DNS_ATMA_MAX_ADDR_LENGTH
  952.     //
  953.     //  For NSAP (AESA) BCD encoding of exactly
  954.     //      DNS_ATMA_AESA_ADDR_LENGTH
  955. }
  956. DNS_ATMA_DATA, *PDNS_ATMA_DATA;
  958. typedef struct
  959. {
  960.     LPTSTR          pNameAlgorithm;
  961.     PBYTE           pAlgorithmPacket;
  962.     PBYTE           pKey;
  963.     PBYTE           pOtherData;
  964.     DWORD           dwCreateTime;
  965.     DWORD           dwExpireTime;
  966.     WORD            wMode;
  967.     WORD            wError;
  968.     WORD            wKeyLength;
  969.     WORD            wOtherLength;
  970.     UCHAR           cAlgNameLength;
  971.     BOOL            bPacketPointers;
  972. }
  973. DNS_TKEY_DATA, *PDNS_TKEY_DATA;
  975. typedef struct
  976. {
  977.     LPTSTR          pNameAlgorithm;
  978.     PBYTE           pAlgorithmPacket;
  979.     PBYTE           pSignature;
  980.     PBYTE           pOtherData;
  981.     LONGLONG        i64CreateTime;
  982.     WORD            wFudgeTime;
  983.     WORD            wOriginalXid;
  984.     WORD            wError;
  985.     WORD            wSigLength;
  986.     WORD            wOtherLength;
  987.     UCHAR           cAlgNameLength;
  988.     BOOL            bPacketPointers;
  989. }
  990. DNS_TSIG_DATA, *PDNS_TSIG_DATA;
  993. //
  994. //  MS only types -- only hit the wire in MS-MS zone transfer
  995. //
  997. typedef struct
  998. {
  999.     DWORD           dwMappingFlag;
  1000.     DWORD           dwLookupTimeout;
  1001.     DWORD           dwCacheTimeout;
  1002.     DWORD           cWinsServerCount;
  1003.     IP4_ADDRESS     WinsServers[1];
  1004. }
  1005. DNS_WINS_DATA, *PDNS_WINS_DATA;
  1007. typedef struct
  1008. {
  1009.     DWORD           dwMappingFlag;
  1010.     DWORD           dwLookupTimeout;
  1011.     DWORD           dwCacheTimeout;
  1012.     LPTSTR          pNameResultDomain;
  1013. }
  1014. DNS_WINSR_DATA, *PDNS_WINSR_DATA;
  1017. //
  1018. //  Length of non-fixed-length data types
  1019. //
  1021. #define DNS_TEXT_RECORD_LENGTH(StringCount) 
  1022.             (FIELD_OFFSET(DNS_TXT_DATA, pStringArray) + ((StringCount) * sizeof(PCHAR)))
  1024. #define DNS_NULL_RECORD_LENGTH(ByteCount) 
  1025.             (FIELD_OFFSET(DNS_NULL_DATA, Data) + (ByteCount))
  1027. #define DNS_WKS_RECORD_LENGTH(ByteCount) 
  1028.             (FIELD_OFFSET(DNS_WKS_DATA, BitMask) + (ByteCount))
  1030. #define DNS_WINS_RECORD_LENGTH(IpCount) 
  1031.             (FIELD_OFFSET(DNS_WINS_DATA, WinsServers) + ((IpCount) * sizeof(IP4_ADDRESS)))
  1034. //
  1035. //  Record flags
  1036. //
  1038. typedef struct _DnsRecordFlags
  1039. {
  1040.     DWORD   Section     : 2;
  1041.     DWORD   Delete      : 1;
  1042.     DWORD   CharSet     : 2;
  1043.     DWORD   Unused      : 3;
  1045.     DWORD   Reserved    : 24;
  1046. }
  1047. DNS_RECORD_FLAGS;
  1050. //
  1051. //  Wire Record Sections
  1052. //
  1053. //  Useable both in record flags "Section" and as index into
  1054. //  wire message header section counts.
  1055. //
  1057. typedef enum _DnsSection
  1058. {
  1059.     DnsSectionQuestion,
  1060.     DnsSectionAnswer,
  1061.     DnsSectionAuthority,
  1062.     DnsSectionAddtional,
  1063. }
  1064. DNS_SECTION;
  1066. //  Update message section names
  1068. #define DnsSectionZone      DnsSectionQuestion
  1069. #define DnsSectionPrereq    DnsSectionAnswer
  1070. #define DnsSectionUpdate    DnsSectionAuthority
  1073. //
  1074. //  Record flags as bit flags
  1075. //  These may be or'd together to set the fields
  1076. //
  1078. //  RR Section in packet
  1080. #define     DNSREC_SECTION      (0x00000003)
  1082. #define     DNSREC_QUESTION     (0x00000000)
  1083. #define     DNSREC_ANSWER       (0x00000001)
  1084. #define     DNSREC_AUTHORITY    (0x00000002)
  1085. #define     DNSREC_ADDITIONAL   (0x00000003)
  1087. //  RR Section in packet (update)
  1089. #define     DNSREC_ZONE         (0x00000000)
  1090. #define     DNSREC_PREREQ       (0x00000001)
  1091. #define     DNSREC_UPDATE       (0x00000002)
  1093. //  Delete RR (update) or No-exist (prerequisite)
  1095. #define     DNSREC_DELETE       (0x00000004)
  1096. #define     DNSREC_NOEXIST      (0x00000004)
  1099. //
  1100. //  Record  RR set structure
  1101. //
  1102. //  Note:  The dwReserved flag serves to insure that the substructures
  1103. //  start on 64-bit boundaries.  Do NOT pack this structure, as the
  1104. //  substructures may contain pointers or int64 values which are
  1105. //  properly aligned unpacked.
  1106. //
  1108. #ifdef MIDL_PASS
  1110. #define PDNS_RECORD     PVOID
  1112. #else
  1114. typedef struct _DnsRecord
  1115. {
  1116.     struct _DnsRecord * pNext;
  1117.     LPTSTR              pName;
  1118.     WORD                wType;
  1119.     WORD                wDataLength; // Not referenced for DNS record types
  1120.                                      // defined above.
  1121.     union
  1122.     {
  1123.         DWORD               DW;     // flags as DWORD
  1124.         DNS_RECORD_FLAGS    S;      // flags as structure
  1126.     } Flags;
  1128.     DWORD               dwTtl;
  1129.     DWORD               dwReserved;
  1131.     //  Record Data
  1133.     union
  1134.     {
  1135.         DNS_A_DATA      A;
  1136.         DNS_SOA_DATA    SOA, Soa;
  1137.         DNS_PTR_DATA    PTR, Ptr,
  1138.                         NS, Ns,
  1139.                         CNAME, Cname,
  1140.                         MB, Mb,
  1141.                         MD, Md,
  1142.                         MF, Mf,
  1143.                         MG, Mg,
  1144.                         MR, Mr;
  1145.         DNS_MINFO_DATA  MINFO, Minfo,
  1146.                         RP, Rp;
  1147.         DNS_MX_DATA     MX, Mx,
  1148.                         AFSDB, Afsdb,
  1149.                         RT, Rt;
  1150.         DNS_TXT_DATA    HINFO, Hinfo,
  1151.                         ISDN, Isdn,
  1152.                         TXT, Txt,
  1153.                         X25;
  1154.         DNS_NULL_DATA   Null;
  1155.         DNS_WKS_DATA    WKS, Wks;
  1156.         DNS_AAAA_DATA   AAAA;
  1157.         DNS_KEY_DATA    KEY, Key;
  1158.         DNS_SIG_DATA    SIG, Sig;
  1159.         DNS_ATMA_DATA   ATMA, Atma;
  1160.         DNS_NXT_DATA    NXT, Nxt;
  1161.         DNS_SRV_DATA    SRV, Srv;
  1162.         DNS_TKEY_DATA   TKEY, Tkey;
  1163.         DNS_TSIG_DATA   TSIG, Tsig;
  1164.         DNS_WINS_DATA   WINS, Wins;
  1165.         DNS_WINSR_DATA  WINSR, WinsR, NBSTAT, Nbstat;
  1167.     } Data;
  1168. }
  1169. DNS_RECORD, *PDNS_RECORD;
  1171. //
  1172. //  Header or fixed size of DNS_RECORD
  1173. //
  1175. #define DNS_RECORD_FIXED_SIZE       FIELD_OFFSET( DNS_RECORD, Data )
  1176. #define SIZEOF_DNS_RECORD_HEADER    DNS_RECORD_FIXED_SIZE
  1178. #endif  // PRIVATE_DNS_RECORD
  1182. //
  1183. //  Resource record set building
  1184. //
  1185. //  pFirst points to first record in list.
  1186. //  pLast points to last record in list.
  1187. //
  1189. typedef struct _DnsRRSet
  1190. {
  1191.     PDNS_RECORD     pFirstRR;
  1192.     PDNS_RECORD     pLastRR;
  1193. }
  1194. DNS_RRSET, *PDNS_RRSET;
  1197. //
  1198. //  To init pFirst is NULL.
  1199. //  But pLast points at the location of the pFirst pointer -- essentially
  1200. //  treating the pFirst ptr as a DNS_RECORD.  (It is a DNS_RECORD with
  1201. //  only a pNext field, but that's the only part we use.)
  1202. //
  1203. //  Then when the first record is added to the list, the pNext field of
  1204. //  this dummy record (which corresponds to pFirst's value) is set to
  1205. //  point at the first record.  So pFirst then properly points at the
  1206. //  first record.
  1207. //
  1208. //  (This works only because pNext is the first field in a
  1209. //  DNS_RECORD structure and hence casting a PDNS_RECORD ptr to
  1210. //  PDNS_RECORD* and dereferencing yields its pNext field)
  1211. //
  1212. //  Use TERMINATE when have built RR set by grabbing records out of
  1213. //  existing set.   This makes sure that at the end, the last RR is
  1214. //  properly NULL terminated.
  1215. //
  1217. #define DNS_RRSET_INIT( rrset )                 
  1218.         {                                       
  1219.             PDNS_RRSET  _prrset = &(rrset);     
  1220.             _prrset->pFirstRR = NULL;           
  1221.             _prrset->pLastRR = (PDNS_RECORD) &_prrset->pFirstRR; 
  1222.         }
  1224. #define DNS_RRSET_ADD( rrset, pnewRR )          
  1225.         {                                       
  1226.             PDNS_RRSET  _prrset = &(rrset);     
  1227.             PDNS_RECORD _prrnew = (pnewRR);     
  1228.             _prrset->pLastRR->pNext = _prrnew;  
  1229.             _prrset->pLastRR = _prrnew;         
  1230.         }
  1232. #define DNS_RRSET_TERMINATE( rrset )            
  1233.         {                                       
  1234.             PDNS_RRSET  _prrset = &(rrset);     
  1235.             _prrset->pLastRR->pNext = NULL;     
  1236.         }
  1239. //
  1240. //  Record set manipulation
  1241. //
  1243. //
  1244. //  Record Copy
  1245. //  Record copy functions also do conversion between character sets.
  1246. //
  1247. //  Note, it might be advisable to directly expose non-Ex copy
  1248. //  functions _W, _A for record and set, to avoid exposing the
  1249. //  conversion enum.
  1250. //
  1252. typedef enum _DNS_CHARSET
  1253. {
  1254.     DnsCharSetUnknown,
  1255.     DnsCharSetUnicode,
  1256.     DnsCharSetUtf8,
  1257.     DnsCharSetAnsi,
  1258. }
  1259. DNS_CHARSET;
  1262. PDNS_RECORD
  1263. WINAPI
  1264. DnsRecordCopyEx(
  1265.     IN      PDNS_RECORD     pRecord,
  1266.     IN      DNS_CHARSET     CharSetIn,
  1267.     IN      DNS_CHARSET     CharSetOut
  1268.     );
  1270. PDNS_RECORD
  1271. WINAPI
  1272. DnsRecordSetCopyEx(
  1273.     IN      PDNS_RECORD     pRecordSet,
  1274.     IN      DNS_CHARSET     CharSetIn,
  1275.     IN      DNS_CHARSET     CharSetOut
  1276.     );
  1278. #ifdef UNICODE
  1279. #define DnsRecordCopy(pRR)  
  1280.         DnsRecordCopyEx( (pRR), DnsCharSetUnicode, DnsCharSetUnicode )
  1281. #define DnsRecordSetCopy(pRR)  
  1282.         DnsRecordSetCopyEx( (pRR), DnsCharSetUnicode, DnsCharSetUnicode )
  1283. #else
  1284. #define DnsRecordCopy(pRR)  
  1285.         DnsRecordCopyEx( (pRR), DnsCharSetAnsi, DnsCharSetAnsi )
  1286. #define DnsRecordSetCopy(pRR)  
  1287.         DnsRecordSetCopyEx( (pRR), DnsCharSetAnsi, DnsCharSetAnsi )
  1288. #endif
  1291. //
  1292. //  Record Compare
  1293. //
  1294. //  Note:  these routines only compare records of the SAME character set.
  1295. //  (ANSI, unicode or UTF8).  Furthermore the routines assume the character
  1296. //  set is indicated within the record.  If compare of user created, rather
  1297. //  than DNS API created record lists is desired, then caller should use
  1298. //  DnsRecordCopy API and compare copies.
  1299. //
  1301. BOOL
  1302. WINAPI
  1303. DnsRecordCompare(
  1304.     IN      PDNS_RECORD     pRecord1,
  1305.     IN      PDNS_RECORD     pRecord2
  1306.     );
  1308. BOOL
  1309. WINAPI
  1310. DnsRecordSetCompare(
  1311.     IN OUT  PDNS_RECORD     pRR1,
  1312.     IN OUT  PDNS_RECORD     pRR2,
  1313.     OUT     PDNS_RECORD *   ppDiff1,
  1314.     OUT     PDNS_RECORD *   ppDiff2
  1315.     );
  1317. //
  1318. //  Detach next record set from record list
  1319. //
  1321. PDNS_RECORD
  1322. DnsRecordSetDetach(
  1323.     IN OUT  PDNS_RECORD     pRecordList
  1324.     );
  1326. //
  1327. //  Free record list
  1328. //
  1329. //  Only supported free is deep free of entire record list with LocalFree().
  1330. //  This correctly frees record list returned by DnsQuery() or DnsRecordSetCopy()
  1331. //
  1333. typedef enum
  1334. {
  1335.     DnsFreeFlat = 0,
  1336.     DnsFreeRecordList
  1337. }
  1338. DNS_FREE_TYPE;
  1340. #define DnsFreeRecordListDeep   DnsFreeRecordList
  1343. VOID
  1344. WINAPI
  1345. DnsRecordListFree(
  1346.     IN OUT  PDNS_RECORD     pRecordList,
  1347.     IN      DNS_FREE_TYPE   FreeType
  1348.     );
  1350. VOID
  1351. WINAPI
  1352. DnsFree(
  1353.     IN OUT  PVOID           pData,
  1354.     IN      DNS_FREE_TYPE   FreeType
  1355.     );
  1359. //
  1360. //  DNS Query API
  1361. //
  1363. //
  1364. //  Options for DnsQuery
  1365. //
  1367. #define DNS_QUERY_STANDARD                  0x00000000
  1368. #define DNS_QUERY_ACCEPT_TRUNCATED_RESPONSE 0x00000001
  1369. #define DNS_QUERY_USE_TCP_ONLY              0x00000002
  1370. #define DNS_QUERY_NO_RECURSION              0x00000004
  1371. #define DNS_QUERY_BYPASS_CACHE              0x00000008
  1373. #define DNS_QUERY_NO_WIRE_QUERY             0x00000010
  1374. #define DNS_QUERY_NO_LOCAL_NAME             0x00000020
  1375. #define DNS_QUERY_NO_HOSTS_FILE             0x00000040
  1376. #define DNS_QUERY_NO_NETBT                  0x00000080
  1378. #define DNS_QUERY_WIRE_ONLY                 0x00000100
  1379. #define DNS_QUERY_RETURN_MESSAGE            0x00000200
  1381. #define DNS_QUERY_TREAT_AS_FQDN             0x00001000
  1382. #define DNS_QUERY_DONT_RESET_TTL_VALUES     0x00100000
  1383. #define DNS_QUERY_RESERVED                  0xff000000
  1387. //  Backward compatibility with Win2K
  1388. //  Do not use
  1390. #define DNS_QUERY_CACHE_ONLY                DNS_QUERY_NO_WIRE_QUERY
  1394. DNS_STATUS
  1395. WINAPI
  1396. DnsQuery_A(
  1397.     IN      PCSTR           pszName,
  1398.     IN      WORD            wType,
  1399.     IN      DWORD           Options,
  1400.     IN      PIP4_ARRAY      aipServers            OPTIONAL,
  1401.     IN OUT  PDNS_RECORD *   ppQueryResults        OPTIONAL,
  1402.     IN OUT  PVOID *         pReserved             OPTIONAL
  1403.     );
  1405. DNS_STATUS
  1406. WINAPI
  1407. DnsQuery_UTF8(
  1408.     IN      PCSTR           pszName,
  1409.     IN      WORD            wType,
  1410.     IN      DWORD           Options,
  1411.     IN      PIP4_ARRAY      aipServers            OPTIONAL,
  1412.     IN OUT  PDNS_RECORD *   ppQueryResults        OPTIONAL,
  1413.     IN OUT  PVOID *         pReserved             OPTIONAL
  1414.     );
  1416. DNS_STATUS
  1417. WINAPI
  1418. DnsQuery_W(
  1419.     IN      PCWSTR          pszName,
  1420.     IN      WORD            wType,
  1421.     IN      DWORD           Options,
  1422.     IN      PIP4_ARRAY      aipServers            OPTIONAL,
  1423.     IN OUT  PDNS_RECORD *   ppQueryResults        OPTIONAL,
  1424.     IN OUT  PVOID *         pReserved             OPTIONAL
  1425.     );
  1427. #ifdef UNICODE
  1428. #define DnsQuery DnsQuery_W
  1429. #else
  1430. #define DnsQuery DnsQuery_A
  1431. #endif
  1436. //
  1437. //  DNS Update API
  1438. //
  1439. //      DnsAcquireContextHandle
  1440. //      DnsReleaseContextHandle
  1441. //      DnsModifyRecordsInSet
  1442. //      DnsReplaceRecordSet
  1443. //
  1445. //
  1446. //  Update flags
  1447. //
  1449. #define DNS_UPDATE_SECURITY_USE_DEFAULT     0x00000000
  1450. #define DNS_UPDATE_SECURITY_OFF             0x00000010
  1451. #define DNS_UPDATE_SECURITY_ON              0x00000020
  1452. #define DNS_UPDATE_SECURITY_ONLY            0x00000100
  1453. #define DNS_UPDATE_CACHE_SECURITY_CONTEXT   0x00000200
  1454. #define DNS_UPDATE_TEST_USE_LOCAL_SYS_ACCT  0x00000400
  1455. #define DNS_UPDATE_FORCE_SECURITY_NEGO      0x00000800
  1456. #define DNS_UPDATE_TRY_ALL_MASTER_SERVERS   0x00001000
  1457. #define DNS_UPDATE_SKIP_NO_UPDATE_ADAPTERS  0x00002000
  1458. #define DNS_UPDATE_RESERVED                 0xffff0000
  1461. //
  1462. //  Note:  pCredentials paramater is currently respectively
  1463. //  PSEC_WINNT_AUTH_IDENTITY_W or PSEC_WINNT_AUTH_IDENTITY_A.
  1464. //  Using PVOID to obviate the need for including rpcdce.h
  1465. //  in order to include this file and to leave open the
  1466. //  possibility of alternative credential specifications in
  1467. //  the future.
  1468. //
  1470. DNS_STATUS
  1471. WINAPI
  1472. DnsAcquireContextHandle_W(
  1473.     IN      DWORD           CredentialFlags,
  1474.     IN      PVOID           pCredentials,       OPTIONAL
  1475.     //IN      PSEC_WINNT_AUTH_IDENTITY_W  pCredentials,
  1476.     OUT     PHANDLE         pContextHandle
  1477.     );
  1479. DNS_STATUS
  1480. WINAPI
  1481. DnsAcquireContextHandle_A(
  1482.     IN      DWORD           CredentialFlags,
  1483.     IN      PVOID           pCredentials,       OPTIONAL
  1484.     //IN      PSEC_WINNT_AUTH_IDENTITY_A  pCredentials,
  1485.     OUT     PHANDLE         pContextHandle
  1486.     );
  1488. #ifdef UNICODE
  1489. #define DnsAcquireContextHandle DnsAcquireContextHandle_W
  1490. #else
  1491. #define DnsAcquireContextHandle DnsAcquireContextHandle_A
  1492. #endif
  1495. VOID
  1496. WINAPI
  1497. DnsReleaseContextHandle(
  1498.     IN      HANDLE          hContext
  1499.     );
  1501. //
  1502. //  Dynamic Update API
  1503. //
  1505. DNS_STATUS
  1506. WINAPI
  1507. DnsModifyRecordsInSet_W(
  1508.     IN      PDNS_RECORD     pAddRecords,
  1509.     IN      PDNS_RECORD     pDeleteRecords,
  1510.     IN      DWORD           Options,
  1511.     IN      HANDLE          hContext,       OPTIONAL
  1512.     IN      PIP4_ARRAY      pServerList,    OPTIONAL
  1513.     IN      PVOID           pReserved
  1514.     );
  1516. DNS_STATUS
  1517. WINAPI
  1518. DnsModifyRecordsInSet_A(
  1519.     IN      PDNS_RECORD     pAddRecords,
  1520.     IN      PDNS_RECORD     pDeleteRecords,
  1521.     IN      DWORD           Options,
  1522.     IN      HANDLE          hContext,       OPTIONAL
  1523.     IN      PIP4_ARRAY      pServerList,    OPTIONAL
  1524.     IN      PVOID           pReserved
  1525.     );
  1527. DNS_STATUS
  1528. WINAPI
  1529. DnsModifyRecordsInSet_UTF8(
  1530.     IN      PDNS_RECORD     pAddRecords,
  1531.     IN      PDNS_RECORD     pDeleteRecords,
  1532.     IN      DWORD           Options,
  1533.     IN      HANDLE          hContext,       OPTIONAL
  1534.     IN      PIP4_ARRAY      pServerList,    OPTIONAL
  1535.     IN      PVOID           pReserved
  1536.     );
  1538. #ifdef UNICODE
  1539. #define DnsModifyRecordsInSet  DnsModifyRecordsInSet_W
  1540. #else
  1541. #define DnsModifyRecordsInSet  DnsModifyRecordsInSet_A
  1542. #endif
  1545. DNS_STATUS
  1546. WINAPI
  1547. DnsReplaceRecordSetW(
  1548.     IN      PDNS_RECORD     pNewSet,
  1549.     IN      DWORD           Options,
  1550.     IN      HANDLE          hContext,       OPTIONAL
  1551.     IN      PIP4_ARRAY      pServerList,    OPTIONAL
  1552.     IN      PVOID           pReserved
  1553.     );
  1555. DNS_STATUS
  1556. WINAPI
  1557. DnsReplaceRecordSetA(
  1558.     IN      PDNS_RECORD     pNewSet,
  1559.     IN      DWORD           Options,
  1560.     IN      HANDLE          hContext,       OPTIONAL
  1561.     IN      PIP4_ARRAY      pServerList,    OPTIONAL
  1562.     IN      PVOID           pReserved
  1563.     );
  1565. DNS_STATUS
  1566. WINAPI
  1567. DnsReplaceRecordSetUTF8(
  1568.     IN      PDNS_RECORD     pNewSet,
  1569.     IN      DWORD           Options,
  1570.     IN      HANDLE          hContext,       OPTIONAL
  1571.     IN      PIP4_ARRAY      pServerList,    OPTIONAL
  1572.     IN      PVOID           pReserved
  1573.     );
  1575. #ifdef UNICODE
  1576. #define DnsReplaceRecordSet  DnsReplaceRecordSetW
  1577. #else
  1578. #define DnsReplaceRecordSet  DnsReplaceRecordSetA
  1579. #endif
  1583. //
  1584. //  DNS name validation
  1585. //
  1587. typedef enum _DNS_NAME_FORMAT
  1588. {
  1589.     DnsNameDomain,
  1590.     DnsNameDomainLabel,
  1591.     DnsNameHostnameFull,
  1592.     DnsNameHostnameLabel,
  1593.     DnsNameWildcard,
  1594.     DnsNameSrvRecord
  1595. }
  1596. DNS_NAME_FORMAT;
  1599. DNS_STATUS
  1600. DnsValidateName_UTF8(
  1601.     IN      LPCSTR          pszName,
  1602.     IN      DNS_NAME_FORMAT Format
  1603.     );
  1605. DNS_STATUS
  1606. DnsValidateName_W(
  1607.     IN      LPCWSTR         pwszName,
  1608.     IN      DNS_NAME_FORMAT Format
  1609.     );
  1611. DNS_STATUS
  1612. DnsValidateName_A(
  1613.     IN      LPCSTR          pszName,
  1614.     IN      DNS_NAME_FORMAT Format
  1615.     );
  1617. #ifdef UNICODE
  1618. #define DnsValidateName(p,f)    DnsValidateName_W( (p), (f) )
  1619. #else
  1620. #define DnsValidateName(p,f)    DnsValidateName_A( (p), (f) )
  1621. #endif
  1624. //
  1625. //  DNS name comparison
  1626. //
  1628. BOOL
  1629. WINAPI
  1630. DnsNameCompare_A(
  1631.     IN      LPSTR           pName1,
  1632.     IN      LPSTR           pName2
  1633.     );
  1635. BOOL
  1636. WINAPI
  1637. DnsNameCompare_W(
  1638.     IN      LPWSTR          pName1,
  1639.     IN      LPWSTR          pName2
  1640.     );
  1642. #ifdef UNICODE
  1643. #define DnsNameCompare(n1,n2)   DnsNameCompare_W( (n1),(n2) )
  1644. #else
  1645. #define DnsNameCompare(n1,n2)   DnsNameCompare_A( (n1),(n2) )
  1646. #endif
  1650. //
  1651. //  DNS message "roll-your-own" routines
  1652. //
  1654. typedef struct _DNS_MESSAGE_BUFFER
  1655. {
  1656.     DNS_HEADER  MessageHead;
  1657.     CHAR        MessageBody[1];
  1658. }
  1659. DNS_MESSAGE_BUFFER, *PDNS_MESSAGE_BUFFER;
  1661. BOOL
  1662. WINAPI
  1663. DnsWriteQuestionToBuffer_W(
  1664.     IN OUT  PDNS_MESSAGE_BUFFER pDnsBuffer,
  1665.     IN OUT  LPDWORD             pdwBufferSize,
  1666.     IN      LPWSTR              pszName,
  1667.     IN      WORD                wType,
  1668.     IN      WORD                Xid,
  1669.     IN      BOOL                fRecursionDesired
  1670.     );
  1672. BOOL WINAPI
  1673. DnsWriteQuestionToBuffer_UTF8(
  1674.     IN OUT  PDNS_MESSAGE_BUFFER pDnsBuffer,
  1675.     IN OUT  LPDWORD             pdwBufferSize,
  1676.     IN      LPSTR               pszName,
  1677.     IN      WORD                wType,
  1678.     IN      WORD                Xid,
  1679.     IN      BOOL                fRecursionDesired
  1680.     );
  1682. DNS_STATUS
  1683. WINAPI
  1684. DnsExtractRecordsFromMessage_W(
  1685.     IN      PDNS_MESSAGE_BUFFER pDnsBuffer,
  1686.     IN      WORD                wMessageLength,
  1687.     OUT     PDNS_RECORD *       ppRecord
  1688.     );
  1690. DNS_STATUS
  1691. WINAPI
  1692. DnsExtractRecordsFromMessage_UTF8(
  1693.     IN      PDNS_MESSAGE_BUFFER pDnsBuffer,
  1694.     IN      WORD                wMessageLength,
  1695.     OUT     PDNS_RECORD *       ppRecord
  1696.     );
  1699. #ifdef __cplusplus
  1700. }
  1701. #endif  // __cplusplus
  1703. #endif // _WINDNS_INCLUDED_