?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
idl: add parser for the to_null property
[Samba/gebeck_regimport.git] / librpc / idl / dnsserver.idl
blob5e29511379f30ca3dfa39f6be304b317b1fad48c
1 #include "idl_types.h"
2 /*
3 dnsserver interface definition
4 for a protocol descrition see [MS-DNSP].pdf
5 */
6
7 import "misc.idl", "dnsp.idl";
8
9 [ uuid("50abc2a4-574d-40b3-9d66-ee4fd5fba076"),
10 version(5.0),
11 pointer_default(unique),
12 endpoint("ncacn_ip_tcp:", "ncacn_np:[\\pipe\\dnsserver]"),
13 helper("../librpc/ndr/ndr_dnsserver.h"),
14 helpstring("DNS Management Server")
15 ] interface dnsserver
16 {
17
18 #define wchar_t uint16
19 #define BOOLEAN boolean8
20 #define BOOL boolean32
21 #define BYTE uint8
22 #define UCHAR uint8
23 #define CHAR char
24 #define PBYTE BYTE*
25 #define DWORD uint32
26 #define PDWORD uint32 *
27
28 /* */
29 /* DNS RPC data types */
30 /* */
31
32 typedef [v1_enum] enum {
33 DNS_RPC_USE_TCPIP = 0x00000001,
34 DNS_RPC_USE_NAMED_PIPE = 0x00000002,
35 DNS_RPC_USE_LPC = 0x00000004,
36 DNS_RPC_USE_ALL_PROTOCOLS = 0xFFFFFFFF
37 }
38 DNS_RPC_PROTOCOLS;
39
40 typedef [v1_enum] enum {
41 DNS_CLIENT_VERSION_W2K = 0x00000000,
42 DNS_CLIENT_VERSION_DOTNET = 0x00060000,
43 DNS_CLIENT_VERSION_LONGHORN = 0x00070000
44 }
45 DNS_RPC_CLIENT_VERSION;
46
47 /* Return buffer */
48 typedef struct {
49 DWORD dwLength;
50 [size_is(dwLength)] BYTE Buffer[];
51 } DNS_RPC_BUFFER;
52
53 /* String Array */
54 typedef struct {
55 [range(0,10000)] DWORD dwCount;
56 [size_is(dwCount),string,charset(UTF8)] char * pszStrings[];
57 } DNS_RPC_UTF8_STRING_LIST;
58
59 /* Name and parameter value */
60 typedef struct {
61 DWORD dwParam;
62 [string, charset(UTF8)] char * pszNodeName;
63 }
64 DNS_RPC_NAME_AND_PARAM;
65
66
67 /* */
68 /* DNS Resource Record data types */
69 /* */
70
71 /* DNS_RECORD_TYPE is defined in dnsp.idl as dns_record_type */
72 /* DNS_RPC_NODE_FLAGS is defined in dnsp.idl as dns_rpc_node_flags */
73
74 typedef [gensize] struct {
75 [value(strlen(str))] uint8 len;
76 [charset(UTF8)] uint8 str[len];
77 }
78 DNS_RPC_NAME;
79
80 typedef struct {
81 uint16 wLength;
82 uint16 wRecordCount;
83 uint32 dwFlags;
84 uint32 dwChildCount;
85 DNS_RPC_NAME dnsNodeName;
86 }
87 DNS_RPC_NODE;
88
89 typedef struct {
90 uint32 dwSerialNo;
91 uint32 dwRefresh;
92 uint32 dwRetry;
93 uint32 dwExpire;
94 uint32 dwMinimumTtl;
95 DNS_RPC_NAME NamePrimaryServer;
96 DNS_RPC_NAME ZoneAdministratorEmail;
97 }
98 DNS_RPC_RECORD_SOA;
99
100 typedef struct {
101 uint16 wPreference;
102 DNS_RPC_NAME nameExchange;
103 }
104 DNS_RPC_RECORD_NAME_PREFERENCE;
105
106 typedef struct {
107 uint16 wPriority;
108 uint16 wWeight;
109 uint16 wPort;
110 DNS_RPC_NAME nameTarget;
111 }
112 DNS_RPC_RECORD_SRV;
113
114 typedef [nodiscriminant,gensize,flag(NDR_NOALIGN)] union {
115 [case(DNS_TYPE_TOMBSTONE)] NTTIME timestamp;
116 [case(DNS_TYPE_A)] [flag(NDR_BIG_ENDIAN)] ipv4address ipv4;
117 [case(DNS_TYPE_NS)] DNS_RPC_NAME name;
118 [case(DNS_TYPE_MD)] DNS_RPC_NAME name;
119 [case(DNS_TYPE_MF)] DNS_RPC_NAME name;
120 [case(DNS_TYPE_CNAME)] DNS_RPC_NAME name;
121 [case(DNS_TYPE_SOA)] DNS_RPC_RECORD_SOA soa;
122 [case(DNS_TYPE_MB)] DNS_RPC_NAME name;
123 [case(DNS_TYPE_MG)] DNS_RPC_NAME name;
124 [case(DNS_TYPE_MR)] DNS_RPC_NAME name;
125 [case(DNS_TYPE_PTR)] DNS_RPC_NAME ptr;
126 [case(DNS_TYPE_HINFO)] DNS_RPC_NAME hinfo;
127 [case(DNS_TYPE_MX)] DNS_RPC_RECORD_NAME_PREFERENCE mx;
128 [case(DNS_TYPE_TXT)] DNS_RPC_NAME name;
129 [case(DNS_TYPE_AAAA)] ipv6address ipv6;
130 [case(DNS_TYPE_SRV)] DNS_RPC_RECORD_SRV srv;
131 [case(DNS_TYPE_DNAME)] DNS_RPC_NAME name;
132 }
133 DNS_RPC_DATA;
134
135 typedef [public] struct {
136 [value(ndr_size_DNS_RPC_DATA(&data,wType,0))] uint16 wDataLength;
137 dns_record_type wType;
138 DWORD dwFlags;
139 DWORD dwSerial;
140 DWORD dwTtlSeconds;
141 DWORD dwTimeStamp;
142 DWORD dwReserved;
143 [subcontext(0),subcontext_size(wDataLength),switch_is(wType)] DNS_RPC_DATA data;
144 }
145 DNS_RPC_RECORD;
146
147 typedef struct {
148 [value(ndr_size_DNS_RPC_DATA(&rec.data,rec.wType,0))] uint3264 wContextLength;
149 DNS_RPC_RECORD rec;
150 }
151 DNS_RPC_RECORD_BUF;
152
153
154 /* */
155 /* DNS Address Information data types */
156 /* */
157
158 typedef [v1_enum] enum {
159 DNS_IPVAL_DNS_SERVERS = 0x00,
160 DNS_IPVAL_DNS_ROOTHINTS = 0x01,
161 DNS_IPVAL_DNS_FORWARDERS = 0x02,
162 DNS_IPVAL_DNS_ZONE_MASTERS = 0x03,
163 DNS_IPVAL_DNS_DELEGATIONS = 0x04
164 }
165 DNS_IPVAL_CONTEXT;
166
167 typedef [v1_enum] enum {
168 ERROR_SUCCESS = 0x00,
169 DNS_IPVAL_INVALID_ADDR = 0x01,
170 DNS_IPVAL_UNREACHABLE = 0x02,
171 DNS_IPVAL_NO_RESPONSE = 0x03,
172 DNS_IPVAL_NOT_AUTH_FOR_ZONE = 0x04,
173 DNS_IPVAL_UNKNOWN_ERROR = 0xFF,
174 DNS_IPVAL_NO_TCP = 0x80000000
175 }
176 DNS_IP_VALIDATE_RETURN_FLAGS;
177
178 typedef struct {
179 DWORD AddrCount;
180 [size_is( AddrCount )] DWORD AddrArray[];
181 } IP4_ARRAY;
182 #define PIP4_ARRAY IP4_ARRAY*
183
184 typedef struct {
185 CHAR MaxSa[32];
186 DWORD DnsAddrUserDword[8];
187 } DNS_ADDR;
188
189 typedef struct {
190 DWORD MaxCount;
191 DWORD AddrCount;
192 DWORD Tag;
193 WORD Family;
194 WORD WordReserved;
195 DWORD Flags;
196 DWORD MatchFlag;
197 DWORD Reserved1;
198 DWORD Reserved2;
199 [size_is( AddrCount )] DNS_ADDR AddrArray[];
200 } DNS_ADDR_ARRAY;
201 #define PDNS_ADDR_ARRAY DNS_ADDR_ARRAY*
202
203 typedef struct {
204 DWORD dwRpcStructureVersion;
205 DWORD dwReserved0;
206 DWORD dwContext;
207 DWORD dwReserved1;
208 [string, charset(UTF8)] char * pszContextName;
209 PDNS_ADDR_ARRAY aipValidateAddrs;
210 }
211 DNS_RPC_IP_VALIDATE;
212
213
214 /* */
215 /* DNS Server data types */
216 /* */
217
218 typedef [enum8bit] enum {
219 DNS_BOOT_METHOD_UNINITIALIZED = 0x00,
220 DNS_BOOT_METHOD_FILE = 0x01,
221 DNS_BOOT_METHOD_REGISTRY = 0x02,
222 DNS_BOOT_METHOD_DIRECTORY = 0x03
223 }
224 DNS_BOOT_METHOD;
225
226 typedef [v1_enum] enum {
227 DNS_ALLOW_RFC_NAMES_ONLY = 0x00,
228 DNS_ALLOW_NONRFC_NAMES = 0x01,
229 DNS_ALLOW_MULTIBYTE_NAMES = 0x02,
230 DNS_ALLOW_ALL_NAMES = 0x03
231 }
232 DNS_NAME_CHECK_FLAG;
233
234 typedef struct {
235 /* version */
236 /* basic configuration flags */
237
238 DWORD dwVersion;
239 DNS_BOOT_METHOD fBootMethod;
240 BOOLEAN fAdminConfigured;
241 BOOLEAN fAllowUpdate;
242 BOOLEAN fDsAvailable;
243
244 /* pointer section */
245
246 [string, charset(UTF8)] char * pszServerName;
247
248 /* DS container */
249
250 [string, charset(UTF16)] wchar_t * pszDsContainer;
251
252 /* IP interfaces */
253
254 PIP4_ARRAY aipServerAddrs;
255 PIP4_ARRAY aipListenAddrs;
256
257 /* forwarders */
258
259 PIP4_ARRAY aipForwarders;
260
261 /* future extensions */
262
263 PDWORD pExtension1;
264 PDWORD pExtension2;
265 PDWORD pExtension3;
266 PDWORD pExtension4;
267 PDWORD pExtension5;
268
269 /* DWORD section */
270
271 /* logging */
272
273 DWORD dwLogLevel;
274 DWORD dwDebugLevel;
275
276 /* configuration DWORDs */
277
278 DWORD dwForwardTimeout;
279 DWORD dwRpcProtocol;
280 DNS_NAME_CHECK_FLAG dwNameCheckFlag;
281 DWORD cAddressAnswerLimit;
282 DWORD dwRecursionRetry;
283 DWORD dwRecursionTimeout;
284 DWORD dwMaxCacheTtl;
285 DWORD dwDsPollingInterval;
286
287 /* aging / scavenging */
288
289 DWORD dwScavengingInterval;
290 DWORD dwDefaultRefreshInterval;
291 DWORD dwDefaultNoRefreshInterval;
292
293 DWORD dwReserveArray[10];
294
295 /* BYTE section */
296
297 /* configuration flags */
298
299 BOOLEAN fAutoReverseZones;
300 BOOLEAN fAutoCacheUpdate;
301
302 /* recursion control */
303
304 BOOLEAN fRecurseAfterForwarding;
305 BOOLEAN fForwardDelegations;
306 BOOLEAN fNoRecursion;
307 BOOLEAN fSecureResponses;
308
309 /* lookup control */
310
311 BOOLEAN fRoundRobin;
312 BOOLEAN fLocalNetPriority;
313
314 /* BIND compatibility and mimicking */
315
316 BOOLEAN fBindSecondaries;
317 BOOLEAN fWriteAuthorityNs;
318
319 /* Bells and whistles */
320
321 BOOLEAN fStrictFileParsing;
322 BOOLEAN fLooseWildcarding;
323
324 /* aging / scavenging */
325
326 BOOLEAN fDefaultAgingState;
327 BOOLEAN fReserveArray[15];
328 }
329 DNS_RPC_SERVER_INFO_W2K;
330
331 typedef struct {
332 [string, charset(UTF8)] uint8 *extension;
333 } DNS_EXTENSION;
334
335 typedef [public] struct {
336 DWORD dwRpcStructureVersion;
337 DWORD dwReserved0;
338
339 /* basic configuration flags */
340
341 DWORD dwVersion;
342 DNS_BOOT_METHOD fBootMethod;
343 BOOLEAN fAdminConfigured;
344 BOOLEAN fAllowUpdate;
345 BOOLEAN fDsAvailable;
346
347 /* pointer section */
348
349 [string, charset(UTF8)] char * pszServerName;
350
351 /* DS container */
352
353 [string, charset(UTF16)] wchar_t * pszDsContainer;
354
355 /* IP interfaces */
356
357 PIP4_ARRAY aipServerAddrs;
358 PIP4_ARRAY aipListenAddrs;
359
360 /* forwarders */
361
362 PIP4_ARRAY aipForwarders;
363
364 /* logging */
365
366 PIP4_ARRAY aipLogFilter;
367 [string, charset(UTF16)] wchar_t * pwszLogFilePath;
368
369 /* Server domain/forest */
370
371 [string, charset(UTF8)] char * pszDomainName; /* UTF-8 FQDN */
372 [string, charset(UTF8)] char * pszForestName; /* UTF-8 FQDN */
373
374 /* Built-in directory partitions */
375
376 [string, charset(UTF8)] char * pszDomainDirectoryPartition; /* UTF-8 FQDN */
377 [string, charset(UTF8)] char * pszForestDirectoryPartition; /* UTF-8 FQDN */
378
379 /* future extensions */
380 DNS_EXTENSION pExtensions[6];
381
382 /* DWORD section */
383
384 /* logging */
385
386 DWORD dwLogLevel;
387 DWORD dwDebugLevel;
388
389 /* configuration DWORDs */
390
391 DWORD dwForwardTimeout;
392 DWORD dwRpcProtocol;
393 DNS_NAME_CHECK_FLAG dwNameCheckFlag;
394 DWORD cAddressAnswerLimit;
395 DWORD dwRecursionRetry;
396 DWORD dwRecursionTimeout;
397 DWORD dwMaxCacheTtl;
398 DWORD dwDsPollingInterval;
399 DWORD dwLocalNetPriorityNetMask;
400
401 /* aging and scavenging */
402
403 DWORD dwScavengingInterval;
404 DWORD dwDefaultRefreshInterval;
405 DWORD dwDefaultNoRefreshInterval;
406 DWORD dwLastScavengeTime;
407
408 /* more logging */
409
410 DWORD dwEventLogLevel;
411 DWORD dwLogFileMaxSize;
412
413 /* Active Directory information */
414
415 DWORD dwDsForestVersion;
416 DWORD dwDsDomainVersion;
417 DWORD dwDsDsaVersion;
418
419 DWORD dwReserveArray[ 4 ];
420
421 /* BYTE section */
422
423 /* configuration flags */
424
425 BOOLEAN fAutoReverseZones;
426 BOOLEAN fAutoCacheUpdate;
427
428 /* recursion control */
429
430 BOOLEAN fRecurseAfterForwarding;
431 BOOLEAN fForwardDelegations;
432 BOOLEAN fNoRecursion;
433 BOOLEAN fSecureResponses;
434
435 /* lookup control */
436
437 BOOLEAN fRoundRobin;
438 BOOLEAN fLocalNetPriority;
439
440 /* BIND compatibility and mimicking */
441
442 BOOLEAN fBindSecondaries;
443 BOOLEAN fWriteAuthorityNs;
444
445 /* Bells and whistles */
446
447 BOOLEAN fStrictFileParsing;
448 BOOLEAN fLooseWildcarding;
449
450 /* aging \ scavenging */
451
452 BOOLEAN fDefaultAgingState;
453
454 BOOLEAN fReserveArray[ 15 ];
455 }
456 DNS_RPC_SERVER_INFO_DOTNET;
457
458 typedef [public] struct {
459 DWORD dwRpcStructureVersion;
460 DWORD dwReserved0;
461
462 /* basic configuration flags */
463
464 DWORD dwVersion;
465 DNS_BOOT_METHOD fBootMethod;
466 BOOLEAN fAdminConfigured;
467 BOOLEAN fAllowUpdate;
468 BOOLEAN fDsAvailable;
469
470 /* pointer section */
471
472 [string, charset(UTF8)] char * pszServerName;
473
474 /* DS container */
475
476 [string, charset(UTF16)] wchar_t * pszDsContainer;
477
478 /* IP interfaces */
479
480 PDNS_ADDR_ARRAY aipServerAddrs;
481 PDNS_ADDR_ARRAY aipListenAddrs;
482
483 /* forwarders */
484
485 PDNS_ADDR_ARRAY aipForwarders;
486
487 /* logging */
488
489 PDNS_ADDR_ARRAY aipLogFilter;
490 [string, charset(UTF16)] wchar_t * pwszLogFilePath;
491
492 /* Server domain/forest */
493
494 [string, charset(UTF8)] char * pszDomainName; /* UTF-8 FQDN */
495 [string, charset(UTF8)] char * pszForestName; /* UTF-8 FQDN */
496
497 /* Built-in directory partitions */
498
499 [string, charset(UTF8)] char * pszDomainDirectoryPartition; /* UTF-8 FQDN */
500 [string, charset(UTF8)] char * pszForestDirectoryPartition; /* UTF-8 FQDN */
501
502 /* future extensions */
503 DNS_EXTENSION pExtensions[6];
504
505 /* DWORD section */
506
507 /* logging */
508
509 DWORD dwLogLevel;
510 DWORD dwDebugLevel;
511
512 /* configuration DWORDs */
513
514 DWORD dwForwardTimeout;
515 DWORD dwRpcProtocol;
516 DNS_NAME_CHECK_FLAG dwNameCheckFlag;
517 DWORD cAddressAnswerLimit;
518 DWORD dwRecursionRetry;
519 DWORD dwRecursionTimeout;
520 DWORD dwMaxCacheTtl;
521 DWORD dwDsPollingInterval;
522 DWORD dwLocalNetPriorityNetMask;
523
524 /* aging and scavenging */
525
526 DWORD dwScavengingInterval;
527 DWORD dwDefaultRefreshInterval;
528 DWORD dwDefaultNoRefreshInterval;
529 DWORD dwLastScavengeTime;
530
531 /* more logging */
532
533 DWORD dwEventLogLevel;
534 DWORD dwLogFileMaxSize;
535
536 /* Active Directory information */
537
538 DWORD dwDsForestVersion;
539 DWORD dwDsDomainVersion;
540 DWORD dwDsDsaVersion;
541 BOOLEAN fReadOnlyDC;
542
543 DWORD dwReserveArray[ 3 ];
544
545 /* BYTE section */
546
547 /* configuration flags */
548
549 BOOLEAN fAutoReverseZones;
550 BOOLEAN fAutoCacheUpdate;
551
552 /* recursion control */
553
554 BOOLEAN fRecurseAfterForwarding;
555 BOOLEAN fForwardDelegations;
556 BOOLEAN fNoRecursion;
557 BOOLEAN fSecureResponses;
558
559 /* lookup control */
560
561 BOOLEAN fRoundRobin;
562 BOOLEAN fLocalNetPriority;
563
564 /* BIND compatibility and mimicking */
565
566 BOOLEAN fBindSecondaries;
567 BOOLEAN fWriteAuthorityNs;
568
569 /* Bells and whistles */
570
571 BOOLEAN fStrictFileParsing;
572 BOOLEAN fLooseWildcarding;
573
574 /* aging \ scavenging */
575
576 BOOLEAN fDefaultAgingState;
577
578 BOOLEAN fReserveArray[ 15 ];
579 }
580 DNS_RPC_SERVER_INFO_LONGHORN;
581 #define DNS_RPC_SERVER_INFO DNS_RPC_SERVER_INFO_LONGHORN
582
583
584 /* */
585 /* DNS Application directory partition data types */
586 /* */
587
588 typedef [bitmap32bit] bitmap {
589 DNS_DP_AUTOCREATED = 0x00000001,
590 DNS_DP_LEGACY = 0x00000002,
591 DNS_DP_DOMAIN_DEFAULT = 0x00000004,
592 DNS_DP_FOREST_DEFAULT = 0x00000008,
593 DNS_DP_ENLISTED = 0x00000010,
594 DNS_DP_DELETED = 0x00000020
595 }
596 DNS_RPC_DP_FLAGS;
597
598 typedef struct {
599 [string, charset(UTF16)] wchar_t * pszReplicaDn;
600 }
601 DNS_RPC_DP_REPLICA;
602 #define PDNS_RPC_DP_REPLICA DNS_RPC_DP_REPLICA*
603
604 typedef [v1_enum] enum {
605 DNS_DP_OKAY = 0x00,
606 DNS_DP_STATE_REPL_INCOMING = 0x01,
607 DNS_DP_STATE_REPL_OUTGOING = 0x02,
608 DNS_DP_STATE_UNKNOWN = 0x03
609 } DNS_DP_STATE;
610
611 typedef struct {
612 DWORD dwRpcStructureVersion;
613 DWORD dwReserved0;
614
615 [string, charset(UTF8)] char * pszDpFqdn;
616 [string, charset(UTF16)] wchar_t * pszDpDn;
617 [string, charset(UTF16)] wchar_t * pszCrDn;
618 DWORD dwFlags;
619 DWORD dwZoneCount;
620 DNS_DP_STATE dwState;
621
622 DWORD dwReserved[ 3 ];
623 DNS_EXTENSION pwszReserved[ 3 ];
624 [range(0,10000)] DWORD dwReplicaCount;
625 [size_is(dwReplicaCount)] PDNS_RPC_DP_REPLICA ReplicaArray[];
626 }
627 DNS_RPC_DP_INFO;
628
629 typedef struct {
630 DWORD dwRpcStructureVersion;
631 DWORD dwReserved0;
632
633 [string, charset(UTF8)] char * pszDpFqdn;
634 DWORD dwFlags;
635 DWORD dwZoneCount;
636 }
637 DNS_RPC_DP_ENUM;
638 #define PDNS_RPC_DP_ENUM DNS_RPC_DP_ENUM*
639
640 typedef struct {
641 DWORD dwRpcStructureVersion;
642 DWORD dwReserved0;
643 [range(0,5000)] DWORD dwDpCount;
644 [size_is(dwDpCount)] PDNS_RPC_DP_ENUM DpArray[];
645 }
646 DNS_RPC_DP_LIST;
647
648 typedef struct {
649 DWORD dwRpcStructureVersion;
650 DWORD dwReserved0;
651 [string, charset(UTF8)] char * pszDpFqdn; /* UTF8 */
652 DWORD dwOperation;
653 }
654 DNS_RPC_ENLIST_DP;
655
656 typedef struct {
657 DWORD dwRpcStructureVersion;
658 DWORD dwReserved0;
659 [string, charset(UTF8)] char * pszDestPartition;
660 }
661 DNS_RPC_ZONE_CHANGE_DP;
662
663
664 /* */
665 /* DNS Zone data types */
666 /* */
667
668 /* DNS_ZONE_TYPE defined in dnsp as dns_zone_type */
669
670 typedef [v1_enum] enum {
671 DNS_ZONE_SECSECURE_NO_SECURITY = 0x00,
672 DNS_ZONE_SECSECURE_NS_ONLY = 0x01,
673 DNS_ZONE_SECSECURE_LIST_ONLY = 0x02,
674 DNS_ZONE_SECSECURE_NO_XFER = 0x03
675 }
676 DNS_ZONE_SECONDARY_SECURITY;
677
678 typedef [v1_enum] enum {
679 DNS_ZONE_NOTIFY_OFF = 0x00,
680 DNS_ZONE_NOTIFY_ALL_SECONDARIES = 0x01,
681 DNS_ZONE_NOTIFY_LIST_ONLY = 0x02
682 }
683 DNS_ZONE_NOTIFY_LEVEL;
684
685 typedef [v1_enum] enum {
686 DNS_ZONE_REQUEST_PRIMARY = 0x00000001,
687 DNS_ZONE_REQUEST_SECONDARY = 0x00000002,
688 DNS_ZONE_REQUEST_CACHE = 0x00000004,
689 DNS_ZONE_REQUEST_AUTO = 0x00000008,
690 DNS_ZONE_REQUEST_FORWARD = 0x00000010,
691 DNS_ZONE_REQUEST_REVERSE = 0x00000020,
692 DNS_ZONE_REQUEST_FORWARDER = 0x00000040,
693 DNS_ZONE_REQUEST_STUB = 0x00000080,
694 DNS_ZONE_REQUEST_DS = 0x00000100,
695 DNS_ZONE_REQUEST_NON_DS = 0x00000200,
696 DNS_ZONE_REQUEST_DOMAIN_DP = 0x00000400,
697 DNS_ZONE_REQUEST_FOREST_DP = 0x00000800,
698 DNS_ZONE_REQUEST_CUSTOM_DP = 0x00001000,
699 DNS_ZONE_REQUEST_LEGACY_DP = 0x00002000
700 }
701 DNS_ZONE_REQUEST_FILTERS;
702
703 typedef [bitmap32bit] bitmap {
704 DNS_RPC_ZONE_PAUSED = 0x0001,
705 DNS_RPC_ZONE_SHUTDOWN = 0x0002,
706 DNS_RPC_ZONE_REVERSE = 0x0004,
707 DNS_RPC_ZONE_AUTOCREATED = 0x0008,
708 DNS_RPC_ZONE_DSINTEGRATED = 0x0010,
709 DNS_RPC_ZONE_AGING = 0x0020,
710 DNS_RPC_ZONE_UPDATE_UNSECURE = 0x0040,
711 DNS_RPC_ZONE_UPDATE_SECURE = 0x0080,
712 DNS_RPC_ZONE_READONLY = 0x0100
713 } DNS_RPC_ZONE_FLAGS;
714
715 typedef struct {
716 [string, charset(UTF16)] uint16 * pszZoneName;
717 DNS_RPC_ZONE_FLAGS Flags;
718 UCHAR ZoneType;
719 UCHAR Version;
720 }
721 DNS_RPC_ZONE_W2K;
722 #define PDNS_RPC_ZONE_W2K DNS_RPC_ZONE_W2K*
723
724 typedef struct {
725 DWORD dwRpcStructureVersion;
726 DWORD dwReserved0;
727 [string, charset(UTF16)] wchar_t * pszZoneName;
728 DNS_RPC_ZONE_FLAGS Flags;
729 UCHAR ZoneType;
730 UCHAR Version;
731 DNS_RPC_DP_FLAGS dwDpFlags;
732 [string, charset(UTF8)] char * pszDpFqdn;
733 }
734 DNS_RPC_ZONE_DOTNET;
735 #define DNS_RPC_ZONE DNS_RPC_ZONE_DOTNET
736 #define PDNS_RPC_ZONE_DOTNET DNS_RPC_ZONE_DOTNET*
737
738 /* Zone enumeration */
739 typedef struct {
740 [range(0,500000)] DWORD dwZoneCount;
741 [size_is(dwZoneCount)] PDNS_RPC_ZONE_W2K ZoneArray[];
742 }
743 DNS_RPC_ZONE_LIST_W2K;
744
745 typedef struct {
746 DWORD dwRpcStructureVersion;
747 DWORD dwReserved0;
748 [range(0,500000)] DWORD dwZoneCount;
749 [size_is(dwZoneCount)] PDNS_RPC_ZONE_DOTNET ZoneArray[];
750 }
751 DNS_RPC_ZONE_LIST_DOTNET;
752 #define DNS_RPC_ZONE_LIST DNS_RPC_ZONE_LIST_DOTNET
753
754 /* Zone information */
755 typedef struct {
756 [string, charset(UTF8)] char * pszZoneName;
757 DWORD dwZoneType;
758 BOOL fReverse;
759 dns_zone_update fAllowUpdate;
760 DWORD fPaused;
761 DWORD fShutdown;
762 DWORD fAutoCreated;
763
764 /* Database info */
765 DWORD fUseDatabase;
766 [string, charset(UTF8)] char * pszDataFile;
767
768 /* Masters */
769 PIP4_ARRAY aipMasters;
770
771 /* Secondaries */
772 DNS_ZONE_SECONDARY_SECURITY fSecureSecondaries;
773 DNS_ZONE_NOTIFY_LEVEL fNotifyLevel;
774 PIP4_ARRAY aipSecondaries;
775 PIP4_ARRAY aipNotify;
776
777 /* WINS or NetBIOS lookup */
778 BOOL fUseWins;
779 BOOL fUseNbstat;
780
781 /* Aging */
782 BOOL fAging;
783 DWORD dwNoRefreshInterval;
784 DWORD dwRefreshInterval;
785 DWORD dwAvailForScavengeTime;
786 PIP4_ARRAY aipScavengeServers;
787
788 /* save some space, just in case */
789 /* avoid versioning issues if possible */
790 DWORD pvReserved1;
791 DWORD pvReserved2;
792 DWORD pvReserved3;
793 DWORD pvReserved4;
794 }
795 DNS_RPC_ZONE_INFO_W2K;
796
797 typedef struct {
798 DWORD dwRpcStructureVersion;
799 DWORD dwReserved0;
800
801 [string, charset(UTF8)] char * pszZoneName;
802 DWORD dwZoneType;
803 BOOL fReverse;
804 dns_zone_update fAllowUpdate;
805 DWORD fPaused;
806 DWORD fShutdown;
807 DWORD fAutoCreated;
808
809 /* Database info */
810 DWORD fUseDatabase;
811 [string, charset(UTF8)] char * pszDataFile;
812
813 /* Masters */
814 PIP4_ARRAY aipMasters;
815
816 /* Secondaries */
817 DNS_ZONE_SECONDARY_SECURITY fSecureSecondaries;
818 DNS_ZONE_NOTIFY_LEVEL fNotifyLevel;
819 PIP4_ARRAY aipSecondaries;
820 PIP4_ARRAY aipNotify;
821
822 /* WINS or NetBIOS lookup */
823 BOOL fUseWins;
824 BOOL fUseNbstat;
825
826 /* Aging */
827 BOOL fAging;
828 DWORD dwNoRefreshInterval;
829 DWORD dwRefreshInterval;
830 DWORD dwAvailForScavengeTime;
831 PIP4_ARRAY aipScavengeServers;
832
833 /* Forwarder zones */
834 DWORD dwForwarderTimeout;
835 DWORD fForwarderSlave;
836
837 /* Stub zones */
838 PIP4_ARRAY aipLocalMasters;
839
840 /* Directory partition */
841 DWORD dwDpFlags;
842 [string, charset(UTF8)] char * pszDpFqdn;
843 [string, charset(UTF16)] wchar_t * pwszZoneDn;
844
845 /* Xfr time information */
846 DWORD dwLastSuccessfulSoaCheck;
847 DWORD dwLastSuccessfulXfr;
848
849 /* save some space, just in case */
850 DWORD dwReserved1;
851 DWORD dwReserved2;
852 DWORD dwReserved3;
853 DWORD dwReserved4;
854 DWORD dwReserved5;
855 [string, charset(UTF8)] char * pReserved1;
856 [string, charset(UTF8)] char * pReserved2;
857 [string, charset(UTF8)] char * pReserved3;
858 [string, charset(UTF8)] char * pReserved4;
859 }
860 DNS_RPC_ZONE_INFO_DOTNET;
861
862 typedef struct {
863 DWORD dwRpcStructureVersion;
864 DWORD dwReserved0;
865
866 [string, charset(UTF8)] char * pszZoneName;
867 DWORD dwZoneType;
868 BOOL fReverse;
869 dns_zone_update fAllowUpdate;
870 DWORD fPaused;
871 DWORD fShutdown;
872 DWORD fAutoCreated;
873
874 /* Database info */
875 DWORD fUseDatabase;
876 [string, charset(UTF8)] char * pszDataFile;
877
878 /* Masters */
879 PDNS_ADDR_ARRAY aipMasters;
880
881 /* Secondaries */
882 DNS_ZONE_SECONDARY_SECURITY fSecureSecondaries;
883 DNS_ZONE_NOTIFY_LEVEL fNotifyLevel;
884 PDNS_ADDR_ARRAY aipSecondaries;
885 PDNS_ADDR_ARRAY aipNotify;
886
887 /* WINS or NetBIOS lookup */
888 BOOL fUseWins;
889 BOOL fUseNbstat;
890
891 /* Aging */
892 BOOL fAging;
893 DWORD dwNoRefreshInterval;
894 DWORD dwRefreshInterval;
895 DWORD dwAvailForScavengeTime;
896 PDNS_ADDR_ARRAY aipScavengeServers;
897
898 /* Forwarder zones */
899 DWORD dwForwarderTimeout;
900 DWORD fForwarderSlave;
901
902 /* Stub zones */
903 PDNS_ADDR_ARRAY aipLocalMasters;
904
905 /* Directory partition */
906 DWORD dwDpFlags;
907 [string, charset(UTF8)] char * pszDpFqdn;
908 [string, charset(UTF16)] wchar_t * pwszZoneDn;
909 /* Xfr time information */
910 DWORD dwLastSuccessfulSoaCheck;
911 DWORD dwLastSuccessfulXfr;
912
913 DWORD fQueuedForBackgroundLoad;
914 DWORD fBackgroundLoadInProgress;
915 BOOL fReadOnlyZone;
916
917 /* Additional zone transfer information */
918 DWORD dwLastXfrAttempt;
919 DWORD dwLastXfrResult;
920 }
921 DNS_RPC_ZONE_INFO_LONGHORN;
922 #define DNS_RPC_ZONE_INFO DNS_RPC_ZONE_INFO_LONGHORN
923
924 /* Zone property data */
925 typedef struct {
926 DNS_ZONE_SECONDARY_SECURITY fSecureSecondaries;
927 DNS_ZONE_NOTIFY_LEVEL fNotifyLevel;
928 PIP4_ARRAY aipSecondaries;
929 PIP4_ARRAY aipNotify;
930 }
931 DNS_RPC_ZONE_SECONDARIES_W2K;
932
933 typedef struct {
934 DWORD dwRpcStructureVersion;
935 DWORD dwReserved0;
936
937 DNS_ZONE_SECONDARY_SECURITY fSecureSecondaries;
938 DNS_ZONE_NOTIFY_LEVEL fNotifyLevel;
939 PIP4_ARRAY aipSecondaries;
940 PIP4_ARRAY aipNotify;
941 }
942 DNS_RPC_ZONE_SECONDARIES_DOTNET;
943
944 typedef struct {
945 DWORD dwRpcStructureVersion;
946 DWORD dwReserved0;
947
948 DNS_ZONE_SECONDARY_SECURITY fSecureSecondaries;
949 DNS_ZONE_NOTIFY_LEVEL fNotifyLevel;
950 PDNS_ADDR_ARRAY aipSecondaries;
951 PDNS_ADDR_ARRAY aipNotify;
952 }
953 DNS_RPC_ZONE_SECONDARIES_LONGHORN;
954 #define DNS_RPC_ZONE_SECONDARIES DNS_RPC_ZONE_SECONDARIES_LONGHORN
955
956 /* Zone database */
957 typedef struct {
958 DWORD fDsIntegrated;
959 [string, charset(UTF8)] char * pszFileName;
960 }
961 DNS_RPC_ZONE_DATABASE_W2K;
962
963 typedef struct {
964 DWORD dwRpcStructureVersion;
965 DWORD dwReserved0;
966
967 DWORD fDsIntegrated;
968 [string, charset(UTF8)] char * pszFileName;
969 }
970 DNS_RPC_ZONE_DATABASE_DOTNET;
971 #define DNS_RPC_ZONE_DATABASE DNS_RPC_ZONE_DATABASE_DOTNET
972
973 /* Zone create data */
974 typedef struct {
975 [string, charset(UTF8)] char * pszZoneName;
976 DWORD dwZoneType;
977 dns_zone_update fAllowUpdate;
978 BOOL fAging;
979 DWORD dwFlags;
980
981 /* Database info */
982
983 [string, charset(UTF8)] char * pszDataFile;
984 DWORD fDsIntegrated;
985 DWORD fLoadExisting;
986
987 /* Admin name (if auto-create SOA) */
988
989 [string, charset(UTF8)] char * pszAdmin;
990
991 /* Masters (if secondary) */
992
993 PIP4_ARRAY aipMasters;
994
995 /* Secondaries */
996
997 PIP4_ARRAY aipSecondaries;
998 DNS_ZONE_SECONDARY_SECURITY fSecureSecondaries;
999 DNS_ZONE_NOTIFY_LEVEL fNotifyLevel;
1000
1001 /* Reserve some space to avoid versioning issues */
1002
1003 [string, charset(UTF8)] char * pvReserved1;
1004 [string, charset(UTF8)] char * pvReserved2;
1005 [string, charset(UTF8)] char * pvReserved3;
1006 [string, charset(UTF8)] char * pvReserved4;
1007 [string, charset(UTF8)] char * pvReserved5;
1008 [string, charset(UTF8)] char * pvReserved6;
1009 [string, charset(UTF8)] char * pvReserved7;
1010 [string, charset(UTF8)] char * pvReserved8;
1011 DWORD dwReserved1;
1012 DWORD dwReserved2;
1013 DWORD dwReserved3;
1014 DWORD dwReserved4;
1015 DWORD dwReserved5;
1016 DWORD dwReserved6;
1017 DWORD dwReserved7;
1018 DWORD dwReserved8;
1019 }
1020 DNS_RPC_ZONE_CREATE_INFO_W2K;
1021
1022 typedef struct {
1023 DWORD dwRpcStructureVersion;
1024 DWORD dwReserved0;
1025
1026 [string, charset(UTF8)] char * pszZoneName;
1027 DWORD dwZoneType;
1028 dns_zone_update fAllowUpdate;
1029 BOOL fAging;
1030 DWORD dwFlags;
1031
1032 /* Database info */
1033
1034 [string, charset(UTF8)] char * pszDataFile;
1035 DWORD fDsIntegrated;
1036 DWORD fLoadExisting;
1037
1038 /* Admin name (if auto-create SOA) */
1039
1040 [string, charset(UTF8)] char * pszAdmin;
1041
1042 /* Masters (if secondary) */
1043
1044 PIP4_ARRAY aipMasters;
1045
1046 /* Secondaries */
1047
1048 PIP4_ARRAY aipSecondaries;
1049 DNS_ZONE_SECONDARY_SECURITY fSecureSecondaries;
1050 DNS_ZONE_NOTIFY_LEVEL fNotifyLevel;
1051
1052 /* Forwarder zones */
1053
1054 DWORD dwTimeout;
1055 DWORD fRecurseAfterForwarding;
1056
1057 /* Directory partition */
1058
1059 DWORD dwDpFlags; /* specify built-in DP or */
1060 [string, charset(UTF8)] char * pszDpFqdn; /* UTF8 FQDN of partition */
1061
1062 DWORD dwReserved[ 32 ];
1063 }
1064 DNS_RPC_ZONE_CREATE_INFO_DOTNET;
1065
1066 typedef struct {
1067 DWORD dwRpcStructureVersion;
1068 DWORD dwReserved0;
1069
1070 [string, charset(UTF8)] char * pszZoneName;
1071 DWORD dwZoneType;
1072 dns_zone_update fAllowUpdate;
1073 BOOL fAging;
1074 DWORD dwFlags;
1075
1076 /* Database info */
1077
1078 [string, charset(UTF8)] char * pszDataFile;
1079 DWORD fDsIntegrated;
1080 DWORD fLoadExisting;
1081
1082 /* Admin name (if auto-create SOA) */
1083
1084 [string, charset(UTF8)] char * pszAdmin;
1085
1086 /* Masters (if secondary) */
1087
1088 PDNS_ADDR_ARRAY aipMasters;
1089
1090 /* Secondaries */
1091
1092 PDNS_ADDR_ARRAY aipSecondaries;
1093 DNS_ZONE_SECONDARY_SECURITY fSecureSecondaries;
1094 DNS_ZONE_NOTIFY_LEVEL fNotifyLevel;
1095
1096 /* Forwarder zones */
1097
1098 DWORD dwTimeout;
1099 DWORD fRecurseAfterForwarding;
1100
1101 /* Directory partition */
1102
1103 DWORD dwDpFlags; /* specify built-in DP or */
1104 [string, charset(UTF8)] char * pszDpFqdn; /* UTF8 FQDN of partition */
1105
1106 DWORD dwReserved[ 32 ];
1107 }
1108 DNS_RPC_ZONE_CREATE_INFO_LONGHORN;
1109 #define DNS_RPC_ZONE_CREATE_INFO DNS_RPC_ZONE_CREATE_INFO_LONGHORN
1110
1111 /* Zone export */
1112 typedef struct {
1113 DWORD dwRpcStructureVersion;
1114 DWORD dwReserved0;
1115
1116 [string, charset(UTF8)] char * pszZoneExportFile;
1117 }
1118 DNS_RPC_ZONE_EXPORT_INFO;
1119
1120 typedef struct {
1121 DWORD dwRpcStructureVersion;
1122 DWORD dwReserved0;
1123
1124 DWORD dwFilter;
1125 [string, charset(UTF8)] char * pszPartitionFqdn;
1126 [string, charset(UTF8)] char * pszQueryString;
1127
1128 DNS_EXTENSION pszReserved[ 6 ];
1129 }
1130 DNS_RPC_ENUM_ZONES_FILTER;
1131
1132 /* Forwarders information */
1133 typedef struct {
1134 DWORD fRecurseAfterForwarding;
1135 DWORD dwForwardTimeout;
1136 PIP4_ARRAY aipForwarders;
1137 }
1138 DNS_RPC_FORWARDERS_W2K;
1139
1140 typedef struct {
1141 DWORD dwRpcStructureVersion;
1142 DWORD dwReserved0;
1143 DWORD fRecurseAfterForwarding;
1144 DWORD dwForwardTimeout;
1145 PIP4_ARRAY aipForwarders;
1146 }
1147 DNS_RPC_FORWARDERS_DOTNET;
1148
1149 typedef struct {
1150 DWORD dwRpcStructureVersion;
1151 DWORD dwReserved0;
1152 DWORD fRecurseAfterForwarding;
1153 DWORD dwForwardTimeout;
1154 PDNS_ADDR_ARRAY aipForwarders;
1155 }
1156 DNS_RPC_FORWARDERS_LONGHORN;
1157 #define DNS_RPC_FORWARDERS DNS_RPC_FORWARDERS_LONGHORN
1158
1159
1160 /* */
1161 /* DNS autoconfig data types */
1162 /* */
1163
1164 typedef [v1_enum] enum {
1165 DNS_RPC_AUTOCONFIG_INTERNAL_ROOTHINTS = 0x00000001,
1166 DNS_RPC_AUTOCONFIG_INTERNAL_FORWARDERS = 0x00000002,
1167 DNS_RPC_AUTOCONFIG_INTERNAL_ZONES = 0x00000004,
1168 DNS_RPC_AUTOCONFIG_INTERNAL_SELFPOINT = 0x00000010,
1169 DNS_RPC_AUTOCONFIG_INTERNAL_SELFPOINT_PREPEND = 0x00000020,
1170 DNS_RPC_AUTOCONFIG_INTERNAL_SELFPOINT_APPEND = 0x00000040,
1171 DNS_RPC_AUTOCONFIG_INTERNAL_RETURN_ERROR = 0x00008000,
1172 DNS_RPC_AUTOCONFIG_ALL = 0xFFFFFFFF
1173 }
1174 DNS_RPC_AUTOCONFIG;
1175
1176 typedef struct {
1177 DWORD dwRpcStructureVersion;
1178 DWORD dwReserved0;
1179 DNS_RPC_AUTOCONFIG dwAutoConfigFlags;
1180 DWORD dwReserved1;
1181 [string, charset(UTF8)] char * pszNewDomainName;
1182 }
1183 DNS_RPC_AUTOCONFIGURE;
1184
1185
1186 /* */
1187 /* DNS logging data types */
1188 /* */
1189
1190 typedef [bitmap32bit] bitmap {
1191 DNS_EVENT_LOG_SUCCESS = 0x00000000,
1192 DNS_EVENT_LOG_ERROR_TYPE = 0x00000001,
1193 DNS_EVENT_LOG_WARNING_TYPE = 0x00000002,
1194 DNS_EVENT_LOG_INFORMATION_TYPE = 0x00000004
1195 }
1196 DNS_EVENT_LOG_TYPES;
1197
1198 typedef [bitmap32bit] bitmap {
1199 DNS_RPC_VIEW_AUTHORITY_DATA = 0x00000001,
1200 DNS_RPC_VIEW_CACHE_DATA = 0x00000002,
1201 DNS_RPC_VIEW_GLUE_DATA = 0x00000004,
1202 DNS_RPC_VIEW_ROOT_HINT_DATA = 0x00000008,
1203 DNS_RPC_VIEW_ADDITIONAL_DATA = 0x00000010,
1204 DNS_RPC_VIEW_NO_CHILDREN = 0x00010000,
1205 DNS_RPC_VIEW_ONLY_CHILDREN = 0x00020000
1206 }
1207 DNS_SELECT_FLAGS;
1208
1209
1210 /* */
1211 /* DNS statistics data types */
1212 /* */
1213
1214 typedef struct {
1215 DWORD StatId;
1216 WORD wLength;
1217 BOOLEAN fClear;
1218 UCHAR fReserved;
1219 }
1220 DNSSRV_STAT_HEADER;
1221
1222 typedef struct {
1223 DNSSRV_STAT_HEADER Header;
1224 BYTE Buffer[1];
1225 }
1226 DNSSRV_STAT;
1227
1228
1229 /* */
1230 /* DNS Typid and Union of all RPC data types */
1231 /* */
1232
1233 typedef [v1_enum] enum {
1234 DNSSRV_TYPEID_NULL = 0,
1235 DNSSRV_TYPEID_DWORD = 1,
1236 DNSSRV_TYPEID_LPSTR = 2,
1237 DNSSRV_TYPEID_LPWSTR = 3,
1238 DNSSRV_TYPEID_IPARRAY = 4,
1239 DNSSRV_TYPEID_BUFFER = 5,
1240 DNSSRV_TYPEID_SERVER_INFO_W2K = 6,
1241 DNSSRV_TYPEID_STATS = 7,
1242 DNSSRV_TYPEID_FORWARDERS_W2K = 8,
1243 DNSSRV_TYPEID_ZONE_W2K = 9,
1244 DNSSRV_TYPEID_ZONE_INFO_W2K = 10,
1245 DNSSRV_TYPEID_ZONE_SECONDARIES_W2K = 11,
1246 DNSSRV_TYPEID_ZONE_DATABASE_W2K = 12,
1247 DNSSRV_TYPEID_ZONE_TYPE_RESET_W2K = 13,
1248 DNSSRV_TYPEID_ZONE_CREATE_W2K = 14,
1249 DNSSRV_TYPEID_NAME_AND_PARAM = 15,
1250 DNSSRV_TYPEID_ZONE_LIST_W2K = 16,
1251 DNSSRV_TYPEID_ZONE_RENAME = 17,
1252 DNSSRV_TYPEID_ZONE_EXPORT = 18,
1253 DNSSRV_TYPEID_SERVER_INFO_DOTNET = 19,
1254 DNSSRV_TYPEID_FORWARDERS_DOTNET = 20,
1255 DNSSRV_TYPEID_ZONE = 21,
1256 DNSSRV_TYPEID_ZONE_INFO_DOTNET = 22,
1257 DNSSRV_TYPEID_ZONE_SECONDARIES_DOTNET = 23,
1258 DNSSRV_TYPEID_ZONE_DATABASE = 24,
1259 DNSSRV_TYPEID_ZONE_TYPE_RESET_DOTNET = 25,
1260 DNSSRV_TYPEID_ZONE_CREATE_DOTNET = 26,
1261 DNSSRV_TYPEID_ZONE_LIST = 27,
1262 DNSSRV_TYPEID_DP_ENUM = 28,
1263 DNSSRV_TYPEID_DP_INFO = 29,
1264 DNSSRV_TYPEID_DP_LIST = 30,
1265 DNSSRV_TYPEID_ENLIST_DP = 31,
1266 DNSSRV_TYPEID_ZONE_CHANGE_DP = 32,
1267 DNSSRV_TYPEID_ENUM_ZONES_FILTER = 33,
1268 DNSSRV_TYPEID_ADDRARRAY = 34,
1269 DNSSRV_TYPEID_SERVER_INFO = 35,
1270 DNSSRV_TYPEID_ZONE_INFO = 36,
1271 DNSSRV_TYPEID_FORWARDERS = 37,
1272 DNSSRV_TYPEID_ZONE_SECONDARIES = 38,
1273 DNSSRV_TYPEID_ZONE_TYPE_RESET = 39,
1274 DNSSRV_TYPEID_ZONE_CREATE = 40,
1275 DNSSRV_TYPEID_IP_VALIDATE = 41,
1276 DNSSRV_TYPEID_AUTOCONFIGURE = 42,
1277 DNSSRV_TYPEID_UTF8_STRING_LIST = 43,
1278 DNSSRV_TYPEID_UNICODE_STRING_LIST = 44
1279 }
1280 DNS_RPC_TYPEID;
1281
1282 typedef [switch_type(uint3264)] union {
1283 [case(DNSSRV_TYPEID_NULL)] PBYTE Null;
1284
1285 [case(DNSSRV_TYPEID_DWORD)] DWORD Dword;
1286
1287 [case(DNSSRV_TYPEID_LPSTR)] [string, charset(UTF8)] char * String;
1288
1289 [case(DNSSRV_TYPEID_LPWSTR)] [string, charset(UTF16)] wchar_t * WideString;
1290
1291 [case(DNSSRV_TYPEID_IPARRAY)] IP4_ARRAY *IpArray;
1292
1293 [case(DNSSRV_TYPEID_BUFFER)]
1294 DNS_RPC_BUFFER *Buffer;
1295
1296 [case(DNSSRV_TYPEID_SERVER_INFO_W2K)]
1297 DNS_RPC_SERVER_INFO_W2K *ServerInfoW2K;
1298
1299 [case(DNSSRV_TYPEID_STATS)]
1300 DNSSRV_STAT *Stats;
1301
1302 [case(DNSSRV_TYPEID_FORWARDERS_W2K)]
1303 DNS_RPC_FORWARDERS_W2K *ForwardersW2K;
1304
1305 [case(DNSSRV_TYPEID_ZONE_W2K)]
1306 DNS_RPC_ZONE_W2K *ZoneW2K;
1307
1308 [case(DNSSRV_TYPEID_ZONE_INFO_W2K)]
1309 DNS_RPC_ZONE_INFO_W2K *ZoneInfoW2K;
1310
1311 [case(DNSSRV_TYPEID_ZONE_SECONDARIES_W2K)]
1312 DNS_RPC_ZONE_SECONDARIES_W2K *SecondariesW2K;
1313
1314 [case(DNSSRV_TYPEID_ZONE_DATABASE_W2K)]
1315 DNS_RPC_ZONE_DATABASE_W2K *DatabaseW2K;
1316
1317 [case(DNSSRV_TYPEID_ZONE_CREATE_W2K)]
1318 DNS_RPC_ZONE_CREATE_INFO_W2K *ZoneCreateW2K;
1319
1320 [case(DNSSRV_TYPEID_NAME_AND_PARAM)]
1321 DNS_RPC_NAME_AND_PARAM *NameAndParam;
1322
1323 [case(DNSSRV_TYPEID_ZONE_LIST_W2K)]
1324 DNS_RPC_ZONE_LIST_W2K *ZoneListW2K;
1325
1326 [case(DNSSRV_TYPEID_SERVER_INFO_DOTNET)]
1327 DNS_RPC_SERVER_INFO_DOTNET *ServerInfoDotNet;
1328
1329 [case(DNSSRV_TYPEID_FORWARDERS_DOTNET)]
1330 DNS_RPC_FORWARDERS_DOTNET *ForwardersDotNet;
1331
1332 [case(DNSSRV_TYPEID_ZONE)]
1333 DNS_RPC_ZONE *Zone;
1334
1335 [case(DNSSRV_TYPEID_ZONE_INFO_DOTNET)]
1336 DNS_RPC_ZONE_INFO_DOTNET *ZoneInfoDotNet;
1337
1338 [case(DNSSRV_TYPEID_ZONE_SECONDARIES_DOTNET)]
1339 DNS_RPC_ZONE_SECONDARIES_DOTNET *SecondariesDotNet;
1340
1341 [case(DNSSRV_TYPEID_ZONE_DATABASE)]
1342 DNS_RPC_ZONE_DATABASE *Database;
1343
1344 [case(DNSSRV_TYPEID_ZONE_CREATE_DOTNET)]
1345 DNS_RPC_ZONE_CREATE_INFO_DOTNET *ZoneCreateDotNet;
1346
1347 [case(DNSSRV_TYPEID_ZONE_LIST)]
1348 DNS_RPC_ZONE_LIST *ZoneList;
1349
1350 [case(DNSSRV_TYPEID_ZONE_EXPORT)]
1351 DNS_RPC_ZONE_EXPORT_INFO *ZoneExport;
1352
1353 [case(DNSSRV_TYPEID_DP_INFO)]
1354 DNS_RPC_DP_INFO *DirectoryPartition;
1355
1356 [case(DNSSRV_TYPEID_DP_ENUM)]
1357 DNS_RPC_DP_ENUM *DirectoryPartitionEnum;
1358
1359 [case(DNSSRV_TYPEID_DP_LIST)]
1360 DNS_RPC_DP_LIST *DirectoryPartitionList;
1361
1362 [case(DNSSRV_TYPEID_ENLIST_DP)]
1363 DNS_RPC_ENLIST_DP *EnlistDirectoryPartition;
1364
1365 [case(DNSSRV_TYPEID_ZONE_CHANGE_DP)]
1366 DNS_RPC_ZONE_CHANGE_DP *ZoneChangeDirectoryPartition;
1367
1368 [case(DNSSRV_TYPEID_ENUM_ZONES_FILTER)]
1369 DNS_RPC_ENUM_ZONES_FILTER *EnumZonesFilter;
1370
1371 [case(DNSSRV_TYPEID_ADDRARRAY)]
1372 DNS_ADDR_ARRAY *AddrArray;
1373
1374 [case(DNSSRV_TYPEID_SERVER_INFO)]
1375 DNS_RPC_SERVER_INFO *ServerInfo;
1376
1377 [case(DNSSRV_TYPEID_ZONE_CREATE)]
1378 DNS_RPC_ZONE_CREATE_INFO *ZoneCreate;
1379
1380 [case(DNSSRV_TYPEID_FORWARDERS)]
1381 DNS_RPC_FORWARDERS *Forwarders;
1382
1383 [case(DNSSRV_TYPEID_ZONE_SECONDARIES)]
1384 DNS_RPC_ZONE_SECONDARIES *Secondaries;
1385
1386 [case(DNSSRV_TYPEID_IP_VALIDATE)]
1387 DNS_RPC_IP_VALIDATE *IpValidate;
1388
1389 [case(DNSSRV_TYPEID_ZONE_INFO)]
1390 DNS_RPC_ZONE_INFO *ZoneInfo;
1391
1392 [case(DNSSRV_TYPEID_AUTOCONFIGURE)]
1393 DNS_RPC_AUTOCONFIGURE *AutoConfigure;
1394
1395 [case(DNSSRV_TYPEID_UTF8_STRING_LIST)]
1396 DNS_RPC_UTF8_STRING_LIST *Utf8StringList;
1397 } DNSSRV_RPC_UNION;
1398
1399
1400 /* */
1401 /* DNS RPC interface */
1402 /* */
1403
1404 typedef [public,gensize] struct {
1405 [value((12+ndr_size_DNS_RPC_NAME(&dnsNodeName,0)+3) & ~3)] uint16 wLength;
1406 uint16 wRecordCount;
1407 uint32 dwFlags;
1408 uint32 dwChildCount;
1409 DNS_RPC_NAME dnsNodeName;
1410 DNS_RPC_RECORD records[wRecordCount];
1411 } DNS_RPC_RECORDS;
1412
1413 typedef [public,nopull,nopush,gensize] struct {
1414 uint32 count;
1415 DNS_RPC_RECORDS rec[count];
1416 } DNS_RPC_RECORDS_ARRAY;
1417
1418 WERROR DnssrvOperation(
1419 [in,unique,string,charset(UTF16)] uint16 *pwszServerName,
1420 [in,unique,string,charset(UTF8)] uint8 *pszZone,
1421 [in] DWORD dwContext,
1422 [in,unique,string,charset(UTF8)] uint8 *pszOperation,
1423 [in] DNS_RPC_TYPEID dwTypeId,
1424 [in, switch_is(dwTypeId)] DNSSRV_RPC_UNION pData
1425 );
1426
1427 WERROR DnssrvQuery(
1428 [in,unique,string,charset(UTF16)] uint16 *pwszServerName,
1429 [in,unique,string,charset(UTF8)] uint8 *pszZone,
1430 [in,unique,string,charset(UTF8)] uint8 *pszOperation,
1431 [out] DNS_RPC_TYPEID *pdwTypeId,
1432 [out, switch_is(*pdwTypeId)] DNSSRV_RPC_UNION *ppData
1433 );
1434
1435 WERROR DnssrvComplexOperation(
1436 [in,unique,string,charset(UTF16)] uint16 *pwszServerName,
1437 [in,unique,string,charset(UTF8)] uint8 *pszZone,
1438 [in,unique,string,charset(UTF8)] uint8 *pszOperation,
1439 [in] DNS_RPC_TYPEID dwTypeIn,
1440 [in, switch_is(dwTypeIn)] DNSSRV_RPC_UNION pDataIn,
1441 [out] DNS_RPC_TYPEID *pdwTypeOut,
1442 [out, switch_is(*pdwTypeOut)] DNSSRV_RPC_UNION *ppDataOut
1443 );
1444
1445 WERROR DnssrvEnumRecords(
1446 [in,unique,string,charset(UTF16)] uint16 *pwszServerName,
1447 [in,unique,string,charset(UTF8)] uint8 *pszZone,
1448 [in,unique,string,charset(UTF8)] uint8 *pszNodeName,
1449 [in,unique,string,charset(UTF8)] uint8 *pszStartChild,
1450 [in] dns_record_type wRecordType,
1451 [in] DNS_SELECT_FLAGS fSelectFlag,
1452 [in,unique,string,charset(UTF8)] uint8 *pszFilterStart,
1453 [in,unique,string,charset(UTF8)] uint8 *pszFilterStop,
1454 [out] DWORD *pdwBufferLength,
1455 [out,ref,subcontext(4),subcontext_size(*pdwBufferLength)] DNS_RPC_RECORDS_ARRAY **pBuffer
1456 );
1457
1458 WERROR DnssrvUpdateRecord(
1459 [in,unique,string,charset(UTF16)] uint16 *pwszServerName,
1460 [in,unique,string,charset(UTF8)] uint8 *pszZone,
1461 [in,unique,string,charset(UTF8)] uint8 *pszNodeName,
1462 [in, unique] DNS_RPC_RECORD_BUF *pAddRecord,
1463 [in, unique] DNS_RPC_RECORD_BUF *pDeleteRecord
1464 );
1465
1466 WERROR DnssrvOperation2(
1467 [in] DNS_RPC_CLIENT_VERSION dwClientVersion,
1468 [in] uint32 dwSettingFlags,
1469 [in,unique,string,charset(UTF16)] uint16 *pwszServerName,
1470 [in,unique,string,charset(UTF8)] uint8 *pszZone,
1471 [in] DWORD dwContext,
1472 [in,unique,string,charset(UTF8)] uint8 *pszOperation,
1473 [in] DNS_RPC_TYPEID dwTypeId,
1474 [in, switch_is(dwTypeId)] DNSSRV_RPC_UNION pData
1475 );
1476
1477 WERROR DnssrvQuery2(
1478 [in] DNS_RPC_CLIENT_VERSION dwClientVersion,
1479 [in] uint32 dwSettingFlags,
1480 [in,unique,string,charset(UTF16)] uint16 *pwszServerName,
1481 [in,unique,string,charset(UTF8)] uint8 *pszZone,
1482 [in,unique,string,charset(UTF8)] uint8 *pszOperation,
1483 [out] DNS_RPC_TYPEID *pdwTypeId,
1484 [out, switch_is(*pdwTypeId)] DNSSRV_RPC_UNION *ppData
1485 );
1486
1487 WERROR DnssrvComplexOperation2(
1488 [in] DNS_RPC_CLIENT_VERSION dwClientVersion,
1489 [in] uint32 dwSettingFlags,
1490 [in,unique,string,charset(UTF16)] uint16 *pwszServerName,
1491 [in,unique,string,charset(UTF8)] uint8 *pszZone,
1492 [in,unique,string,charset(UTF8)] uint8 *pszOperation,
1493 [in] DNS_RPC_TYPEID dwTypeIn,
1494 [in, switch_is(dwTypeIn)] DNSSRV_RPC_UNION pDataIn,
1495 [out] DNS_RPC_TYPEID *pdwTypeOut,
1496 [out, switch_is(*pdwTypeOut)] DNSSRV_RPC_UNION *ppDataOut
1497 );
1498
1499 WERROR DnssrvEnumRecords2(
1500 [in] DNS_RPC_CLIENT_VERSION dwClientVersion,
1501 [in] DWORD dwSettingFlags,
1502 [in,unique,string,charset(UTF16)] uint16 *pwszServerName,
1503 [in,unique,string,charset(UTF8)] uint8 *pszZone,
1504 [in,unique,string,charset(UTF8)] uint8 *pszNodeName,
1505 [in,unique,string,charset(UTF8)] uint8 *pszStartChild,
1506 [in] dns_record_type wRecordType,
1507 [in] DNS_SELECT_FLAGS fSelectFlag,
1508 [in,unique,string,charset(UTF8)] uint8 *pszFilterStart,
1509 [in,unique,string,charset(UTF8)] uint8 *pszFilterStop,
1510 [out] uint32 *pdwBufferLength,
1511 [out,ref,subcontext(4),subcontext_size(*pdwBufferLength)] DNS_RPC_RECORDS_ARRAY **pBuffer
1512 );
1513
1514 WERROR DnssrvUpdateRecord2(
1515 [in] DNS_RPC_CLIENT_VERSION dwClientVersion,
1516 [in] uint32 dwSettingFlags,
1517 [in,unique,string,charset(UTF16)] uint16 *pwszServerName,
1518 [in,unique,string,charset(UTF8)] uint8 *pszZone,
1519 [in,string,charset(UTF8)] uint8 *pszNodeName,
1520 [in, unique] DNS_RPC_RECORD_BUF *pAddRecord,
1521 [in, unique] DNS_RPC_RECORD_BUF *pDeleteRecord
1522 );
1523 }
reg import