?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
s3-docs: Fix typo.
[Samba.git] / librpc / idl / dnsserver.idl
blob33fadc60d96e6ea1a0772aa5b5c0abf00fbe24d8
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 helpstring("DNS Server")
13 ] interface dnsserver
14 {
15
16 #define wchar_t uint16
17 #define BOOLEAN boolean8
18 #define BOOL boolean32
19 #define BYTE uint8
20 #define UCHAR uint8
21 #define CHAR char
22 #define PBYTE BYTE*
23 #define DWORD uint32
24 #define PDWORD uint32 *
25
26 typedef struct {
27 DWORD StatId;
28 WORD wLength;
29 BOOLEAN fClear;
30 UCHAR fReserved;
31 } DNSSRV_STAT_HEADER;
32
33
34 typedef struct {
35 DNSSRV_STAT_HEADER Header;
36 BYTE Buffer[1];
37 } DNSSRV_STAT;
38
39 typedef struct {
40 DWORD AddrCount;
41 [size_is( AddrCount )] DWORD AddrArray[];
42 } IP4_ARRAY;
43 #define PIP4_ARRAY IP4_ARRAY*
44
45 typedef struct {
46 CHAR MaxSa[32];
47 DWORD DnsAddrUserDword[8];
48 } DNS_ADDR;
49
50 typedef struct {
51 DWORD MaxCount;
52 DWORD AddrCount;
53 DWORD Tag;
54 WORD Family;
55 WORD WordReserved;
56 DWORD Flags;
57 DWORD MatchFlag;
58 DWORD Reserved1;
59 DWORD Reserved2;
60 [size_is( AddrCount )] DNS_ADDR AddrArray[];
61 } DNS_ADDR_ARRAY;
62 #define PDNS_ADDR_ARRAY DNS_ADDR_ARRAY*
63
64 /* */
65 /* RPC buffer type for returned data */
66 /* */
67 typedef struct {
68 DWORD dwLength;
69 [size_is(dwLength)] BYTE Buffer[];
70 } DNS_RPC_BUFFER;
71
72
73 /* */
74 /* Server data types */
75 /* */
76 typedef struct {
77 /* version */
78 /* basic configuration flags */
79
80 DWORD dwVersion;
81 UCHAR fBootMethod;
82 BOOLEAN fAdminConfigured;
83 BOOLEAN fAllowUpdate;
84 BOOLEAN fDsAvailable;
85
86 /* */
87 /* pointer section */
88 /* */
89
90 [string, charset(UTF8)] char * pszServerName;
91
92 /* DS container */
93
94 [string, charset(UTF16)] wchar_t * pszDsContainer;
95
96 /* IP interfaces */
97
98 PIP4_ARRAY aipServerAddrs;
99 PIP4_ARRAY aipListenAddrs;
100
101 /* forwarders */
102
103 PIP4_ARRAY aipForwarders;
104
105 /* future extensions */
106
107 PDWORD pExtension1;
108 PDWORD pExtension2;
109 PDWORD pExtension3;
110 PDWORD pExtension4;
111 PDWORD pExtension5;
112
113 /* */
114 /* DWORD section */
115 /* */
116
117 /* logging */
118
119 DWORD dwLogLevel;
120 DWORD dwDebugLevel;
121 /* configuration DWORDs */
122
123 DWORD dwForwardTimeout;
124 DWORD dwRpcProtocol;
125 DWORD dwNameCheckFlag;
126 DWORD cAddressAnswerLimit;
127 DWORD dwRecursionRetry;
128 DWORD dwRecursionTimeout;
129 DWORD dwMaxCacheTtl;
130 DWORD dwDsPollingInterval;
131
132 /* aging / scavenging */
133
134 DWORD dwScavengingInterval;
135 DWORD dwDefaultRefreshInterval;
136 DWORD dwDefaultNoRefreshInterval;
137
138 DWORD dwReserveArray[10];
139
140 /* */
141 /* BYTE section */
142 /* */
143 /* configuration flags */
144
145 BOOLEAN fAutoReverseZones;
146 BOOLEAN fAutoCacheUpdate;
147
148 /* recursion control */
149
150 BOOLEAN fRecurseAfterForwarding;
151 BOOLEAN fForwardDelegations;
152 BOOLEAN fNoRecursion;
153 BOOLEAN fSecureResponses;
154
155 /* lookup control */
156
157 BOOLEAN fRoundRobin;
158 BOOLEAN fLocalNetPriority;
159
160 /* BIND compatibility and mimicking */
161
162 BOOLEAN fBindSecondaries;
163 BOOLEAN fWriteAuthorityNs;
164
165 /* Bells and whistles */
166
167 BOOLEAN fStrictFileParsing;
168 BOOLEAN fLooseWildcarding;
169
170 /* aging / scavenging */
171
172 BOOLEAN fDefaultAgingState;
173 BOOLEAN fReserveArray[15];
174 }
175 DNS_RPC_SERVER_INFO_W2K;
176
177 typedef struct {
178 [string, charset(UTF8)] uint8 *extension;
179 } DNS_EXTENSION;
180
181 typedef [public] struct {
182 DWORD dwRpcStructureVersion;
183 DWORD dwReserved0;
184
185 /* basic configuration flags */
186
187 DWORD dwVersion;
188 UCHAR fBootMethod;
189 BOOLEAN fAdminConfigured;
190 BOOLEAN fAllowUpdate;
191 BOOLEAN fDsAvailable;
192
193 /* */
194 /* pointer section */
195 /* */
196
197 [string, charset(UTF8)] char * pszServerName;
198
199 /* DS container */
200
201 [string, charset(UTF16)] wchar_t * pszDsContainer;
202
203 /* IP interfaces */
204
205 PIP4_ARRAY aipServerAddrs;
206 PIP4_ARRAY aipListenAddrs;
207
208 /* forwarders */
209
210 PIP4_ARRAY aipForwarders;
211
212 /* logging */
213
214 PIP4_ARRAY aipLogFilter;
215 [string, charset(UTF16)] wchar_t * pwszLogFilePath;
216
217 /* Server domain/forest */
218
219 [string, charset(UTF8)] char * pszDomainName; /* UTF-8 FQDN */
220 [string, charset(UTF8)] char * pszForestName; /* UTF-8 FQDN */
221
222 /* Built-in directory partitions */
223
224 [string, charset(UTF8)] char * pszDomainDirectoryPartition; /* UTF-8 FQDN */
225 [string, charset(UTF8)] char * pszForestDirectoryPartition; /* UTF-8 FQDN */
226
227 /* future extensions */
228 DNS_EXTENSION pExtensions[6];
229
230 /* */
231 /* DWORD section */
232 /* */
233
234 /* logging */
235
236 DWORD dwLogLevel;
237 DWORD dwDebugLevel;
238
239 /* configuration DWORDs */
240 DWORD dwForwardTimeout;
241 DWORD dwRpcProtocol;
242 DWORD dwNameCheckFlag;
243 DWORD cAddressAnswerLimit;
244 DWORD dwRecursionRetry;
245 DWORD dwRecursionTimeout;
246 DWORD dwMaxCacheTtl;
247 DWORD dwDsPollingInterval;
248 DWORD dwLocalNetPriorityNetMask;
249
250 /* aging and scavenging */
251
252 DWORD dwScavengingInterval;
253 DWORD dwDefaultRefreshInterval;
254 DWORD dwDefaultNoRefreshInterval;
255 DWORD dwLastScavengeTime;
256
257 /* more logging */
258
259 DWORD dwEventLogLevel;
260 DWORD dwLogFileMaxSize;
261
262 /* Active Directory information */
263
264 DWORD dwDsForestVersion;
265 DWORD dwDsDomainVersion;
266 DWORD dwDsDsaVersion;
267
268 DWORD dwReserveArray[ 4 ];
269
270 /* */
271 /* BYTE section */
272 /* */
273 /* configuration flags */
274
275 BOOLEAN fAutoReverseZones;
276 BOOLEAN fAutoCacheUpdate;
277
278 /* recursion control */
279
280 BOOLEAN fRecurseAfterForwarding;
281 BOOLEAN fForwardDelegations;
282 BOOLEAN fNoRecursion;
283 BOOLEAN fSecureResponses;
284
285 /* lookup control */
286
287 BOOLEAN fRoundRobin;
288 BOOLEAN fLocalNetPriority;
289
290 /* BIND compatibility and mimicking */
291
292 BOOLEAN fBindSecondaries;
293 BOOLEAN fWriteAuthorityNs;
294
295 /* Bells and whistles */
296
297 BOOLEAN fStrictFileParsing;
298 BOOLEAN fLooseWildcarding;
299
300 /* aging \ scavenging */
301
302 BOOLEAN fDefaultAgingState;
303
304 BOOLEAN fReserveArray[ 15 ];
305 }
306 DNS_RPC_SERVER_INFO_DOTNET;
307
308 typedef struct {
309 DWORD dwRpcStructureVersion;
310 DWORD dwReserved0;
311
312 /* basic configuration flags */
313
314 DWORD dwVersion;
315 UCHAR fBootMethod;
316 BOOLEAN fAdminConfigured;
317 BOOLEAN fAllowUpdate;
318 BOOLEAN fDsAvailable;
319
320 /* */
321 /* pointer section */
322 /* */
323
324 [string, charset(UTF8)] char * pszServerName;
325
326 /* DS container */
327
328 [string, charset(UTF16)] wchar_t * pszDsContainer;
329
330 /* IP interfaces */
331
332 PDNS_ADDR_ARRAY aipServerAddrs;
333 PDNS_ADDR_ARRAY aipListenAddrs;
334
335 /* forwarders */
336
337 PDNS_ADDR_ARRAY aipForwarders;
338
339 /* logging */
340
341 PDNS_ADDR_ARRAY aipLogFilter;
342 [string, charset(UTF16)] wchar_t * pwszLogFilePath;
343
344 /* Server domain/forest */
345
346 [string, charset(UTF8)] char * pszDomainName; /* UTF-8 FQDN */
347 [string, charset(UTF8)] char * pszForestName; /* UTF-8 FQDN */
348
349 /* Built-in directory partitions */
350
351 [string, charset(UTF8)] char * pszDomainDirectoryPartition; /* UTF-8 FQDN */
352 [string, charset(UTF8)] char * pszForestDirectoryPartition; /* UTF-8 FQDN */
353
354 /* future extensions */
355 DNS_EXTENSION pExtensions[6];
356
357 /* */
358 /* DWORD section */
359 /* */
360
361 /* logging */
362
363 DWORD dwLogLevel;
364 DWORD dwDebugLevel;
365
366 /* configuration DWORDs */
367
368 DWORD dwForwardTimeout;
369 DWORD dwRpcProtocol;
370 DWORD dwNameCheckFlag;
371 DWORD cAddressAnswerLimit;
372 DWORD dwRecursionRetry;
373 DWORD dwRecursionTimeout;
374 DWORD dwMaxCacheTtl;
375 DWORD dwDsPollingInterval;
376 DWORD dwLocalNetPriorityNetMask;
377
378 /* aging and scavenging */
379
380 DWORD dwScavengingInterval;
381 DWORD dwDefaultRefreshInterval;
382 DWORD dwDefaultNoRefreshInterval;
383 DWORD dwLastScavengeTime;
384
385 /* more logging */
386
387 DWORD dwEventLogLevel;
388 DWORD dwLogFileMaxSize;
389
390 /* Active Directory information */
391
392 DWORD dwDsForestVersion;
393 DWORD dwDsDomainVersion;
394 DWORD dwDsDsaVersion;
395 BOOLEAN fReadOnlyDC;
396
397 DWORD dwReserveArray[ 3 ];
398
399 /* */
400 /* BYTE section */
401 /* */
402 /* configuration flags */
403
404 BOOLEAN fAutoReverseZones;
405 BOOLEAN fAutoCacheUpdate;
406
407 /* recursion control */
408
409 BOOLEAN fRecurseAfterForwarding;
410 BOOLEAN fForwardDelegations;
411 BOOLEAN fNoRecursion;
412 BOOLEAN fSecureResponses;
413 /* lookup control */
414
415 BOOLEAN fRoundRobin;
416 BOOLEAN fLocalNetPriority;
417
418 /* BIND compatibility and mimicking */
419
420 BOOLEAN fBindSecondaries;
421 BOOLEAN fWriteAuthorityNs;
422
423 /* Bells and whistles */
424
425 BOOLEAN fStrictFileParsing;
426 BOOLEAN fLooseWildcarding;
427
428 /* aging \ scavenging */
429
430 BOOLEAN fDefaultAgingState;
431
432 BOOLEAN fReserveArray[ 15 ];
433 }
434 DNS_RPC_SERVER_INFO_LONGHORN;
435 #define DNS_RPC_SERVER_INFO DNS_RPC_SERVER_INFO_LONGHORN
436
437 typedef struct {
438 DWORD fRecurseAfterForwarding;
439 DWORD dwForwardTimeout;
440 PIP4_ARRAY aipForwarders;
441 }
442 DNS_RPC_FORWARDERS_W2K;
443
444 typedef struct {
445 DWORD dwRpcStructureVersion;
446 DWORD dwReserved0;
447 DWORD fRecurseAfterForwarding;
448 DWORD dwForwardTimeout;
449 PIP4_ARRAY aipForwarders;
450 }
451 DNS_RPC_FORWARDERS_DOTNET;
452
453 typedef struct {
454 DWORD dwRpcStructureVersion;
455 DWORD dwReserved0;
456 DWORD fRecurseAfterForwarding;
457 DWORD dwForwardTimeout;
458 PDNS_ADDR_ARRAY aipForwarders;
459 }
460 DNS_RPC_FORWARDERS_LONGHORN;
461 #define DNS_RPC_FORWARDERS DNS_RPC_FORWARDERS_LONGHORN
462
463
464 /* */
465 /* Basic zone data */
466 /* */
467
468 typedef [bitmap32bit] bitmap {
469 RPC_ZONE_PAUSED = 0x001,
470 RPC_ZONE_SHUTDOWN = 0x002,
471 RPC_ZONE_REVERSE = 0x004,
472 RPC_ZONE_AUTOCREATED = 0x008,
473 RPC_ZONE_DSINTEGRATED = 0x010,
474 RPC_ZONE_AGING = 0x020,
475 RPC_ZONE_UPDATE = 0x0C0, /* two bits */
476 RPC_ZONE_READONLY = 0x100
477 } DNS_RPC_ZONE_FLAGS;
478
479 typedef struct {
480 [string, charset(UTF16)] uint16 * pszZoneName;
481 DNS_RPC_ZONE_FLAGS Flags;
482 UCHAR ZoneType;
483 UCHAR Version;
484 }
485 DNS_RPC_ZONE_W2K;
486 #define PDNS_RPC_ZONE_W2K DNS_RPC_ZONE_W2K*
487
488 typedef struct {
489 DWORD dwRpcStructureVersion;
490 DWORD dwReserved0;
491 [string, charset(UTF16)] wchar_t * pszZoneName;
492 DNS_RPC_ZONE_FLAGS Flags;
493 UCHAR ZoneType;
494 UCHAR Version;
495 DWORD dwDpFlags;
496 [string, charset(UTF8)] char * pszDpFqdn;
497 }
498 DNS_RPC_ZONE_DOTNET;
499 #define DNS_RPC_ZONE DNS_RPC_ZONE_DOTNET
500 #define PDNS_RPC_ZONE_DOTNET DNS_RPC_ZONE_DOTNET*
501
502
503 /* */
504 /* Zone enumeration */
505 /* */
506
507 typedef struct {
508 [range(0,500000)] DWORD dwZoneCount;
509 [size_is(dwZoneCount)] PDNS_RPC_ZONE_W2K ZoneArray[];
510 }
511 DNS_RPC_ZONE_LIST_W2K;
512
513
514 typedef struct {
515 DWORD dwRpcStructureVersion;
516 DWORD dwReserved0;
517 [range(0,500000)] DWORD dwZoneCount;
518 [size_is(dwZoneCount)] PDNS_RPC_ZONE_DOTNET ZoneArray[];
519 }
520 DNS_RPC_ZONE_LIST_DOTNET;
521 #define DNS_RPC_ZONE_LIST DNS_RPC_ZONE_LIST_DOTNET
522
523
524 /* */
525 /* Directory partition enumeration and info */
526 /* */
527
528 typedef struct {
529 DWORD dwRpcStructureVersion;
530 DWORD dwReserved0;
531
532 [string, charset(UTF8)] char * pszDpFqdn;
533 DWORD dwFlags;
534 DWORD dwZoneCount;
535 }
536 DNS_RPC_DP_ENUM;
537 #define PDNS_RPC_DP_ENUM DNS_RPC_DP_ENUM*
538
539 typedef struct {
540 DWORD dwRpcStructureVersion;
541 DWORD dwReserved0;
542 [range(0,5000)] DWORD dwDpCount;
543 [size_is(dwDpCount)] PDNS_RPC_DP_ENUM DpArray[];
544 }
545 DNS_RPC_DP_LIST;
546
547
548 typedef struct {
549 [string, charset(UTF16)] wchar_t * pszReplicaDn;
550 }
551 DNS_RPC_DP_REPLICA;
552 #define PDNS_RPC_DP_REPLICA DNS_RPC_DP_REPLICA*
553
554 typedef struct {
555 DWORD dwRpcStructureVersion;
556 DWORD dwReserved0;
557
558 [string, charset(UTF8)] char * pszDpFqdn;
559 [string, charset(UTF16)] wchar_t * pszDpDn;
560 [string, charset(UTF16)] wchar_t * pszCrDn;
561 DWORD dwFlags;
562 DWORD dwZoneCount;
563 DWORD dwState;
564
565 DWORD dwReserved[ 3 ];
566 DNS_EXTENSION pwszReserved[ 3 ];
567 [range(0,10000)] DWORD dwReplicaCount;
568 [size_is(dwReplicaCount)] PDNS_RPC_DP_REPLICA ReplicaArray[];
569 }
570 DNS_RPC_DP_INFO;
571
572
573 /* */
574 /* Enlist (or create) directory partition */
575 /* */
576
577 typedef struct {
578 DWORD dwRpcStructureVersion;
579 DWORD dwReserved0;
580 [string, charset(UTF8)] char * pszDpFqdn; /* UTF8 */
581 DWORD dwOperation;
582 }
583 DNS_RPC_ENLIST_DP;
584
585 /* */
586 /* Zone export */
587 /* */
588
589 typedef struct {
590 DWORD dwRpcStructureVersion;
591 DWORD dwReserved0;
592
593 [string, charset(UTF8)] char * pszZoneExportFile;
594 }
595 DNS_RPC_ZONE_EXPORT_INFO;
596
597 /* */
598 /* Zone property data */
599 /* */
600
601 typedef struct {
602 DWORD fSecureSecondaries;
603 DWORD fNotifyLevel;
604 PIP4_ARRAY aipSecondaries;
605 PIP4_ARRAY aipNotify;
606 }
607 DNS_RPC_ZONE_SECONDARIES_W2K;
608
609 typedef struct {
610 DWORD dwRpcStructureVersion;
611 DWORD dwReserved0;
612
613 DWORD fSecureSecondaries;
614 DWORD fNotifyLevel;
615 PIP4_ARRAY aipSecondaries;
616 PIP4_ARRAY aipNotify;
617 }
618 DNS_RPC_ZONE_SECONDARIES_DOTNET;
619
620 typedef struct {
621 DWORD dwRpcStructureVersion;
622 DWORD dwReserved0;
623
624 DWORD fSecureSecondaries;
625 DWORD fNotifyLevel;
626 PDNS_ADDR_ARRAY aipSecondaries;
627 PDNS_ADDR_ARRAY aipNotify;
628 }
629 DNS_RPC_ZONE_SECONDARIES_LONGHORN;
630 #define DNS_RPC_ZONE_SECONDARIES DNS_RPC_ZONE_SECONDARIES_LONGHORN
631
632 typedef struct {
633 DWORD fDsIntegrated;
634 [string, charset(UTF8)] char * pszFileName;
635 }
636 DNS_RPC_ZONE_DATABASE_W2K;
637
638 typedef struct {
639 DWORD dwRpcStructureVersion;
640 DWORD dwReserved0;
641
642 DWORD fDsIntegrated;
643 [string, charset(UTF8)] char * pszFileName;
644 }
645 DNS_RPC_ZONE_DATABASE_DOTNET;
646 #define DNS_RPC_ZONE_DATABASE DNS_RPC_ZONE_DATABASE_DOTNET
647
648 typedef struct {
649 DWORD dwRpcStructureVersion;
650 DWORD dwReserved0;
651 [string, charset(UTF8)] char * pszDestPartition;
652 }
653 DNS_RPC_ZONE_CHANGE_DP;
654
655 typedef struct {
656 [string, charset(UTF8)] char * pszZoneName;
657 DWORD dwZoneType;
658 DWORD fReverse;
659 DWORD fAllowUpdate;
660 DWORD fPaused;
661 DWORD fShutdown;
662 DWORD fAutoCreated;
663
664 /* Database info */
665 DWORD fUseDatabase;
666 [string, charset(UTF8)] char * pszDataFile;
667
668 /* Masters */
669 PIP4_ARRAY aipMasters;
670
671 /* Secondaries */
672 DWORD fSecureSecondaries;
673 DWORD fNotifyLevel;
674 PIP4_ARRAY aipSecondaries;
675 PIP4_ARRAY aipNotify;
676
677 /* WINS or NetBIOS lookup */
678 DWORD fUseWins;
679 DWORD fUseNbstat;
680
681 /* Aging */
682 DWORD fAging;
683 DWORD dwNoRefreshInterval;
684 DWORD dwRefreshInterval;
685 DWORD dwAvailForScavengeTime;
686 PIP4_ARRAY aipScavengeServers;
687
688 /* save some space, just in case */
689 /* avoid versioning issues if possible */
690 DWORD pvReserved1;
691 DWORD pvReserved2;
692 DWORD pvReserved3;
693 DWORD pvReserved4;
694 }
695 DNS_RPC_ZONE_INFO_W2K;
696
697 typedef struct {
698 DWORD dwRpcStructureVersion;
699 DWORD dwReserved0;
700
701 [string, charset(UTF8)] char * pszZoneName;
702 DWORD dwZoneType;
703 DWORD fReverse;
704 DWORD fAllowUpdate;
705 DWORD fPaused;
706 DWORD fShutdown;
707 DWORD fAutoCreated;
708
709 /* Database info */
710 DWORD fUseDatabase;
711 [string, charset(UTF8)] char * pszDataFile;
712
713 /* Masters */
714 PIP4_ARRAY aipMasters;
715
716 /* Secondaries */
717 DWORD fSecureSecondaries;
718 DWORD fNotifyLevel;
719 PIP4_ARRAY aipSecondaries;
720 PIP4_ARRAY aipNotify;
721
722 /* WINS or NetBIOS lookup */
723 DWORD fUseWins;
724 DWORD fUseNbstat;
725
726 /* Aging */
727 DWORD fAging;
728 DWORD dwNoRefreshInterval;
729 DWORD dwRefreshInterval;
730 DWORD dwAvailForScavengeTime;
731 PIP4_ARRAY aipScavengeServers;
732
733 /* Forwarder zones */
734 DWORD dwForwarderTimeout;
735 DWORD fForwarderSlave;
736
737 /* Stub zones */
738 PIP4_ARRAY aipLocalMasters;
739
740 /* Directory partition */
741 DWORD dwDpFlags;
742 [string, charset(UTF8)] char * pszDpFqdn;
743 [string, charset(UTF16)] wchar_t * pwszZoneDn;
744
745 /* Xfr time information */
746 DWORD dwLastSuccessfulSoaCheck;
747 DWORD dwLastSuccessfulXfr;
748
749 /* save some space, just in case */
750 DWORD dwReserved1;
751 DWORD dwReserved2;
752 DWORD dwReserved3;
753 DWORD dwReserved4;
754 DWORD dwReserved5;
755 [string, charset(UTF8)] char * pReserved1;
756 [string, charset(UTF8)] char * pReserved2;
757 [string, charset(UTF8)] char * pReserved3;
758 [string, charset(UTF8)] char * pReserved4;
759 }
760 DNS_RPC_ZONE_INFO_DOTNET;
761
762 typedef struct {
763 DWORD dwRpcStructureVersion;
764 DWORD dwReserved0;
765
766 [string, charset(UTF8)] char * pszZoneName;
767 DWORD dwZoneType;
768 DWORD fReverse;
769 DWORD fAllowUpdate;
770 DWORD fPaused;
771 DWORD fShutdown;
772 DWORD fAutoCreated;
773
774 /* Database info */
775 DWORD fUseDatabase;
776 [string, charset(UTF8)] char * pszDataFile;
777
778 /* Masters */
779 PDNS_ADDR_ARRAY aipMasters;
780
781 /* Secondaries */
782 DWORD fSecureSecondaries;
783 DWORD fNotifyLevel;
784 PDNS_ADDR_ARRAY aipSecondaries;
785 PDNS_ADDR_ARRAY aipNotify;
786
787 /* WINS or NetBIOS lookup */
788 DWORD fUseWins;
789 DWORD fUseNbstat;
790
791 /* Aging */
792 DWORD fAging;
793 DWORD dwNoRefreshInterval;
794 DWORD dwRefreshInterval;
795 DWORD dwAvailForScavengeTime;
796 PDNS_ADDR_ARRAY aipScavengeServers;
797
798 /* Forwarder zones */
799 DWORD dwForwarderTimeout;
800 DWORD fForwarderSlave;
801
802 /* Stub zones */
803 PDNS_ADDR_ARRAY aipLocalMasters;
804
805 /* Directory partition */
806 DWORD dwDpFlags;
807 [string, charset(UTF8)] char * pszDpFqdn;
808 [string, charset(UTF16)] wchar_t * pwszZoneDn;
809 /* Xfr time information */
810 DWORD dwLastSuccessfulSoaCheck;
811 DWORD dwLastSuccessfulXfr;
812
813 DWORD fQueuedForBackgroundLoad;
814 DWORD fBackgroundLoadInProgress;
815 BOOL fReadOnlyZone;
816
817 /* Additional zone transfer information */
818 DWORD dwLastXfrAttempt;
819 DWORD dwLastXfrResult;
820 }
821 DNS_RPC_ZONE_INFO_LONGHORN;
822 #define DNS_RPC_ZONE_INFO DNS_RPC_ZONE_INFO_LONGHORN
823
824 /* */
825 /* Zone create data */
826 /* */
827
828 typedef struct {
829 [string, charset(UTF8)] char * pszZoneName;
830 DWORD dwZoneType;
831 DWORD fAllowUpdate;
832 DWORD fAging;
833 DWORD dwFlags;
834
835 /* Database info */
836
837 [string, charset(UTF8)] char * pszDataFile;
838 DWORD fDsIntegrated;
839 DWORD fLoadExisting;
840
841 /* Admin name (if auto-create SOA) */
842
843 [string, charset(UTF8)] char * pszAdmin;
844
845 /* Masters (if secondary) */
846
847 PIP4_ARRAY aipMasters;
848
849 /* Secondaries */
850
851 PIP4_ARRAY aipSecondaries;
852 DWORD fSecureSecondaries;
853 DWORD fNotifyLevel;
854
855 /* Reserve some space to avoid versioning issues */
856
857 [string, charset(UTF8)] char * pvReserved1;
858 [string, charset(UTF8)] char * pvReserved2;
859 [string, charset(UTF8)] char * pvReserved3;
860 [string, charset(UTF8)] char * pvReserved4;
861 [string, charset(UTF8)] char * pvReserved5;
862 [string, charset(UTF8)] char * pvReserved6;
863 [string, charset(UTF8)] char * pvReserved7;
864 [string, charset(UTF8)] char * pvReserved8;
865 DWORD dwReserved1;
866 DWORD dwReserved2;
867 DWORD dwReserved3;
868 DWORD dwReserved4;
869 DWORD dwReserved5;
870 DWORD dwReserved6;
871 DWORD dwReserved7;
872 DWORD dwReserved8;
873 }
874 DNS_RPC_ZONE_CREATE_INFO_W2K;
875
876 typedef struct {
877 DWORD dwRpcStructureVersion;
878 DWORD dwReserved0;
879
880 [string, charset(UTF8)] char * pszZoneName;
881 DWORD dwZoneType;
882 DWORD fAllowUpdate;
883 DWORD fAging;
884 DWORD dwFlags;
885
886 /* Database info */
887
888 [string, charset(UTF8)] char * pszDataFile;
889 DWORD fDsIntegrated;
890 DWORD fLoadExisting;
891
892 /* Admin name (if auto-create SOA) */
893
894 [string, charset(UTF8)] char * pszAdmin;
895
896 /* Masters (if secondary) */
897
898 PIP4_ARRAY aipMasters;
899
900 /* Secondaries */
901
902 PIP4_ARRAY aipSecondaries;
903 DWORD fSecureSecondaries;
904 DWORD fNotifyLevel;
905
906 /* Forwarder zones */
907
908 DWORD dwTimeout;
909 DWORD fRecurseAfterForwarding;
910
911 /* Directory partition */
912
913 DWORD dwDpFlags; /* specify built-in DP or */
914 [string, charset(UTF8)] char * pszDpFqdn; /* UTF8 FQDN of partition */
915
916 DWORD dwReserved[ 32 ];
917 }
918 DNS_RPC_ZONE_CREATE_INFO_DOTNET;
919
920
921 typedef struct {
922 DWORD dwRpcStructureVersion;
923 DWORD dwReserved0;
924
925 [string, charset(UTF8)] char * pszZoneName;
926 DWORD dwZoneType;
927 DWORD fAllowUpdate;
928 DWORD fAging;
929 DWORD dwFlags;
930
931 /* Database info */
932
933 [string, charset(UTF8)] char * pszDataFile;
934 DWORD fDsIntegrated;
935 DWORD fLoadExisting;
936
937 /* Admin name (if auto-create SOA) */
938
939 [string, charset(UTF8)] char * pszAdmin;
940
941 /* Masters (if secondary) */
942
943 PDNS_ADDR_ARRAY aipMasters;
944
945 /* Secondaries */
946
947 PDNS_ADDR_ARRAY aipSecondaries;
948 DWORD fSecureSecondaries;
949 DWORD fNotifyLevel;
950
951 /* Forwarder zones */
952
953 DWORD dwTimeout;
954 DWORD fRecurseAfterForwarding;
955
956 /* Directory partition */
957
958 DWORD dwDpFlags; /* specify built-in DP or */
959 [string, charset(UTF8)] char * pszDpFqdn; /* UTF8 FQDN of partition */
960
961 DWORD dwReserved[ 32 ];
962 }
963 DNS_RPC_ZONE_CREATE_INFO_LONGHORN;
964 #define DNS_RPC_ZONE_CREATE_INFO DNS_RPC_ZONE_CREATE_INFO_LONGHORN
965
966 typedef struct {
967 DWORD dwRpcStructureVersion;
968 DWORD dwReserved0;
969
970 DWORD dwAutoConfigFlags;
971 DWORD dwReserved1;
972 [string, charset(UTF8)] char * pszNewDomainName;
973 }
974 DNS_RPC_AUTOCONFIGURE;
975
976 /* */
977 /* EnumZones2 filter specification */
978 /* */
979 typedef struct {
980 DWORD dwRpcStructureVersion;
981 DWORD dwReserved0;
982
983 DWORD dwFilter;
984 [string, charset(UTF8)] char * pszPartitionFqdn;
985 [string, charset(UTF8)] char * pszQueryString;
986
987 DNS_EXTENSION pszReserved[ 6 ];
988 }
989 DNS_RPC_ENUM_ZONES_FILTER;
990
991 /* */
992 /* RPC record structure */
993 /* */
994
995 typedef struct {
996 [value(strlen(str))] uint8 len;
997 [charset(UTF8)] uint8 str[len];
998 } DNS_RPC_NAME;
999
1000 typedef [nodiscriminant,gensize,flag(NDR_NOALIGN)] union {
1001 [case(DNS_TYPE_PTR)] DNS_RPC_NAME name;
1002 [case(DNS_TYPE_NS)] DNS_RPC_NAME name;
1003 [case(DNS_TYPE_CNAME)] DNS_RPC_NAME name;
1004 [case(DNS_TYPE_DNAME)] DNS_RPC_NAME name;
1005 [case(DNS_TYPE_MB)] DNS_RPC_NAME name;
1006 [case(DNS_TYPE_MR)] DNS_RPC_NAME name;
1007 [case(DNS_TYPE_MG)] DNS_RPC_NAME name;
1008 [case(DNS_TYPE_MD)] DNS_RPC_NAME name;
1009 [case(DNS_TYPE_MF)] DNS_RPC_NAME name;
1010 } DNS_RPC_DATA;
1011
1012 typedef struct {
1013 [value(ndr_size_DNS_RPC_DATA(&data,wType,ndr->flags))] uint16 wDataLength;
1014 dns_record_type wType;
1015 DWORD dwFlags;
1016 DWORD dwSerial;
1017 DWORD dwTtlSeconds;
1018 DWORD dwTimeStamp;
1019 DWORD dwReserved;
1020 [subcontext(0),subcontext_size(wDataLength),switch_is(wType)] DNS_RPC_DATA data;
1021 } DNS_RPC_RECORD;
1022
1023 typedef struct {
1024 [value(ndr_size_DNS_RPC_DATA(&rec.data,rec.wType,ndr->flags))] uint3264 wContextLength;
1025 DNS_RPC_RECORD rec;
1026 } DNS_RPC_RECORD_BUF;
1027
1028
1029 /* */
1030 /* These RPC structures have no version because they are simple */
1031 /* are they are explicitly defined by their names. */
1032 /* */
1033
1034 typedef struct {
1035 DWORD dwParam;
1036 [string, charset(UTF8)] char * pszNodeName;
1037 }
1038 DNS_RPC_NAME_AND_PARAM;
1039
1040 typedef struct {
1041 DWORD dwRpcStructureVersion;
1042 DWORD dwReserved0;
1043
1044 DWORD dwContext;
1045 DWORD dwReserved1;
1046 [string, charset(UTF8)] char * pszContextName;
1047 PDNS_ADDR_ARRAY aipValidateAddrs;
1048 }
1049 DNS_RPC_IP_VALIDATE;
1050
1051 /* */
1052 /* String array */
1053 /* */
1054 typedef struct {
1055 [range(0,10000)] DWORD dwCount;
1056 [size_is(dwCount),string,charset(UTF8)] char * pszStrings[];
1057 } DNS_RPC_UTF8_STRING_LIST;
1058
1059 /* */
1060 /* Union of RPC types */
1061 /* */
1062 typedef [v1_enum] enum {
1063 DNSSRV_TYPEID_NULL = 0,
1064 DNSSRV_TYPEID_DWORD = 1,
1065 DNSSRV_TYPEID_LPSTR = 2,
1066 DNSSRV_TYPEID_LPWSTR = 3,
1067 DNSSRV_TYPEID_IPARRAY = 4,
1068 DNSSRV_TYPEID_BUFFER = 5,
1069 DNSSRV_TYPEID_SERVER_INFO_W2K = 6,
1070 DNSSRV_TYPEID_STATS = 7,
1071 DNSSRV_TYPEID_FORWARDERS_W2K = 8,
1072 DNSSRV_TYPEID_ZONE_W2K = 9,
1073 DNSSRV_TYPEID_ZONE_INFO_W2K = 10,
1074 DNSSRV_TYPEID_ZONE_SECONDARIES_W2K = 11,
1075 DNSSRV_TYPEID_ZONE_DATABASE_W2K = 12,
1076 DNSSRV_TYPEID_ZONE_TYPE_RESET_W2K = 13,
1077 DNSSRV_TYPEID_ZONE_CREATE_W2K = 14,
1078 DNSSRV_TYPEID_NAME_AND_PARAM = 15,
1079 DNSSRV_TYPEID_ZONE_LIST_W2K = 16,
1080 DNSSRV_TYPEID_ZONE_RENAME = 17,
1081 DNSSRV_TYPEID_ZONE_EXPORT = 18,
1082 DNSSRV_TYPEID_SERVER_INFO_DOTNET = 19,
1083 DNSSRV_TYPEID_FORWARDERS_DOTNET = 20,
1084 DNSSRV_TYPEID_ZONE = 21,
1085 DNSSRV_TYPEID_ZONE_INFO_DOTNET = 22,
1086 DNSSRV_TYPEID_ZONE_SECONDARIES_DOTNET = 23,
1087 DNSSRV_TYPEID_ZONE_DATABASE = 24,
1088 DNSSRV_TYPEID_ZONE_TYPE_RESET_DOTNET = 25,
1089 DNSSRV_TYPEID_ZONE_CREATE_DOTNET = 26,
1090 DNSSRV_TYPEID_ZONE_LIST = 27,
1091 DNSSRV_TYPEID_DP_ENUM = 28,
1092 DNSSRV_TYPEID_DP_INFO = 29,
1093 DNSSRV_TYPEID_DP_LIST = 30,
1094 DNSSRV_TYPEID_ENLIST_DP = 31,
1095 DNSSRV_TYPEID_ZONE_CHANGE_DP = 32,
1096 DNSSRV_TYPEID_ENUM_ZONES_FILTER = 33,
1097 DNSSRV_TYPEID_ADDRARRAY = 34,
1098 DNSSRV_TYPEID_SERVER_INFO = 35,
1099 DNSSRV_TYPEID_ZONE_INFO = 36,
1100 DNSSRV_TYPEID_FORWARDERS = 37,
1101 DNSSRV_TYPEID_ZONE_SECONDARIES = 38,
1102 DNSSRV_TYPEID_ZONE_TYPE_RESET = 39,
1103 DNSSRV_TYPEID_ZONE_CREATE = 40,
1104 DNSSRV_TYPEID_IP_VALIDATE = 41,
1105 DNSSRV_TYPEID_AUTOCONFIGURE = 42,
1106 DNSSRV_TYPEID_UTF8_STRING_LIST = 43,
1107 DNSSRV_TYPEID_UNICODE_STRING_LIST = 44
1108 } DNS_RPC_TYPEID;
1109
1110
1111 typedef [switch_type(uint3264)] union {
1112 [case(DNSSRV_TYPEID_NULL)] PBYTE Null;
1113
1114 [case(DNSSRV_TYPEID_DWORD)] DWORD Dword;
1115
1116 [case(DNSSRV_TYPEID_LPSTR)] [string, charset(UTF8)] char * String;
1117
1118 [case(DNSSRV_TYPEID_LPWSTR)] [string, charset(UTF16)] wchar_t * WideString;
1119
1120 [case(DNSSRV_TYPEID_IPARRAY)] IP4_ARRAY *IpArray;
1121
1122 [case(DNSSRV_TYPEID_BUFFER)]
1123 DNS_RPC_BUFFER *Buffer;
1124
1125 [case(DNSSRV_TYPEID_SERVER_INFO_W2K)]
1126 DNS_RPC_SERVER_INFO_W2K *ServerInfoW2K;
1127
1128 [case(DNSSRV_TYPEID_STATS)]
1129 DNSSRV_STAT *Stats;
1130
1131 [case(DNSSRV_TYPEID_FORWARDERS_W2K)]
1132 DNS_RPC_FORWARDERS_W2K *ForwardersW2K;
1133
1134 [case(DNSSRV_TYPEID_ZONE_W2K)]
1135 DNS_RPC_ZONE_W2K *ZoneW2K;
1136
1137 [case(DNSSRV_TYPEID_ZONE_INFO_W2K)]
1138 DNS_RPC_ZONE_INFO_W2K *ZoneInfoW2K;
1139
1140 [case(DNSSRV_TYPEID_ZONE_SECONDARIES_W2K)]
1141 DNS_RPC_ZONE_SECONDARIES_W2K *SecondariesW2K;
1142
1143 [case(DNSSRV_TYPEID_ZONE_DATABASE_W2K)]
1144 DNS_RPC_ZONE_DATABASE_W2K *DatabaseW2K;
1145
1146 [case(DNSSRV_TYPEID_ZONE_CREATE_W2K)]
1147 DNS_RPC_ZONE_CREATE_INFO_W2K *ZoneCreateW2K;
1148
1149 [case(DNSSRV_TYPEID_NAME_AND_PARAM)]
1150 DNS_RPC_NAME_AND_PARAM *NameAndParam;
1151
1152 [case(DNSSRV_TYPEID_ZONE_LIST_W2K)]
1153 DNS_RPC_ZONE_LIST_W2K *ZoneListW2K;
1154
1155 [case(DNSSRV_TYPEID_SERVER_INFO_DOTNET)]
1156 DNS_RPC_SERVER_INFO_DOTNET *ServerInfoDotNet;
1157
1158 [case(DNSSRV_TYPEID_FORWARDERS_DOTNET)]
1159 DNS_RPC_FORWARDERS_DOTNET *ForwardersDotNet;
1160
1161 [case(DNSSRV_TYPEID_ZONE)]
1162 DNS_RPC_ZONE *Zone;
1163
1164 [case(DNSSRV_TYPEID_ZONE_INFO_DOTNET)]
1165 DNS_RPC_ZONE_INFO_DOTNET *ZoneInfoDotNet;
1166
1167 [case(DNSSRV_TYPEID_ZONE_SECONDARIES_DOTNET)]
1168 DNS_RPC_ZONE_SECONDARIES_DOTNET *SecondariesDotNet;
1169
1170 [case(DNSSRV_TYPEID_ZONE_DATABASE)]
1171 DNS_RPC_ZONE_DATABASE *Database;
1172
1173 [case(DNSSRV_TYPEID_ZONE_CREATE_DOTNET)]
1174 DNS_RPC_ZONE_CREATE_INFO_DOTNET *ZoneCreateDotNet;
1175
1176 [case(DNSSRV_TYPEID_ZONE_LIST)]
1177 DNS_RPC_ZONE_LIST *ZoneList;
1178
1179 [case(DNSSRV_TYPEID_ZONE_EXPORT)]
1180 DNS_RPC_ZONE_EXPORT_INFO *ZoneExport;
1181
1182 [case(DNSSRV_TYPEID_DP_INFO)]
1183 DNS_RPC_DP_INFO *DirectoryPartition;
1184
1185 [case(DNSSRV_TYPEID_DP_ENUM)]
1186 DNS_RPC_DP_ENUM *DirectoryPartitionEnum;
1187
1188 [case(DNSSRV_TYPEID_DP_LIST)]
1189 DNS_RPC_DP_LIST *DirectoryPartitionList;
1190
1191 [case(DNSSRV_TYPEID_ENLIST_DP)]
1192 DNS_RPC_ENLIST_DP *EnlistDirectoryPartition;
1193
1194 [case(DNSSRV_TYPEID_ZONE_CHANGE_DP)]
1195 DNS_RPC_ZONE_CHANGE_DP *ZoneChangeDirectoryPartition;
1196
1197 [case(DNSSRV_TYPEID_ENUM_ZONES_FILTER)]
1198 DNS_RPC_ENUM_ZONES_FILTER *EnumZonesFilter;
1199
1200 [case(DNSSRV_TYPEID_ADDRARRAY)]
1201 DNS_ADDR_ARRAY *AddrArray;
1202
1203 [case(DNSSRV_TYPEID_SERVER_INFO)]
1204 DNS_RPC_SERVER_INFO *ServerInfo;
1205
1206 [case(DNSSRV_TYPEID_ZONE_CREATE)]
1207 DNS_RPC_ZONE_CREATE_INFO *ZoneCreate;
1208
1209 [case(DNSSRV_TYPEID_FORWARDERS)]
1210 DNS_RPC_FORWARDERS *Forwarders;
1211
1212 [case(DNSSRV_TYPEID_ZONE_SECONDARIES)]
1213 DNS_RPC_ZONE_SECONDARIES *Secondaries;
1214
1215 [case(DNSSRV_TYPEID_IP_VALIDATE)]
1216 DNS_RPC_IP_VALIDATE *IpValidate;
1217
1218 [case(DNSSRV_TYPEID_ZONE_INFO)]
1219 DNS_RPC_ZONE_INFO *ZoneInfo;
1220
1221 [case(DNSSRV_TYPEID_AUTOCONFIGURE)]
1222 DNS_RPC_AUTOCONFIGURE *AutoConfigure;
1223
1224 [case(DNSSRV_TYPEID_UTF8_STRING_LIST)]
1225 DNS_RPC_UTF8_STRING_LIST *Utf8StringList;
1226 } DNSSRV_RPC_UNION;
1227
1228
1229 NTSTATUS DnssrvOperation(
1230 [in,unique,string,charset(UTF16)] uint16 *pwszServerName,
1231 [in,unique,string,charset(UTF8)] uint8 *pszZone,
1232 [in] DWORD dwContext,
1233 [in,unique,string,charset(UTF8)] uint8 *pszOperation,
1234 [in] DNS_RPC_TYPEID dwTypeId,
1235 [in, switch_is(dwTypeId)] DNSSRV_RPC_UNION pData
1236 );
1237
1238 NTSTATUS DnssrvQuery(
1239 [in,unique,string,charset(UTF16)] uint16 *pwszServerName,
1240 [in,unique,string,charset(UTF8)] uint8 *pszZone,
1241 [in,unique,string,charset(UTF8)] uint8 *pszOperation,
1242 [out] DNS_RPC_TYPEID *pdwTypeId,
1243 [out, switch_is(*pdwTypeId)] DNSSRV_RPC_UNION *ppData
1244 );
1245
1246 NTSTATUS DnssrvComplexOperation(
1247 [in,unique,string,charset(UTF16)] uint16 *pwszServerName,
1248 [in,unique,string,charset(UTF8)] uint8 *pszZone,
1249 [in,unique,string,charset(UTF8)] uint8 *pszOperation,
1250 [in] DNS_RPC_TYPEID dwTypeIn,
1251 [in, switch_is(dwTypeIn)] DNSSRV_RPC_UNION pDataIn,
1252 [out] DNS_RPC_TYPEID *pdwTypeOut,
1253 [out, switch_is(*pdwTypeOut)] DNSSRV_RPC_UNION *ppDataOut
1254 );
1255
1256 NTSTATUS DnssrvEnumRecords(
1257 [in,unique,string,charset(UTF16)] uint16 *pwszServerName,
1258 [in,unique,string,charset(UTF8)] uint8 *pszZone,
1259 [in,unique,string,charset(UTF8)] uint8 *pszNodeName,
1260 [in,unique,string,charset(UTF8)] uint8 *pszStartChild,
1261 [in] dns_record_type wRecordType,
1262 [in] DWORD fSelectFlag,
1263 [in,unique,string,charset(UTF8)] uint8 *pszFilterStart,
1264 [in,unique,string,charset(UTF8)] uint8 *pszFilterStop,
1265 [out] DWORD *pdwBufferLength,
1266 [out, size_is(, *pdwBufferLength)] PBYTE * ppBuffer
1267 );
1268
1269 NTSTATUS DnssrvUpdateRecord(
1270 [in,unique,string,charset(UTF16)] uint16 *pwszServerName,
1271 [in,unique,string,charset(UTF8)] uint8 *pszZone,
1272 [in,unique,string,charset(UTF8)] uint8 *pszNodeName,
1273 [in, unique] DNS_RPC_RECORD_BUF *pAddRecord,
1274 [in, unique] DNS_RPC_RECORD_BUF *DeleteRecord
1275 );
1276
1277 NTSTATUS DnssrvOperation2(
1278 [in] uint32 dwClientVersion,
1279 [in] uint32 dwSettingFlags,
1280 [in,unique,string,charset(UTF16)] uint16 *pwszServerName,
1281 [in,unique,string,charset(UTF8)] uint8 *pszZone,
1282 [in] DWORD dwContext,
1283 [in,unique,string,charset(UTF8)] uint8 *pszOperation,
1284 [in] DNS_RPC_TYPEID dwTypeId,
1285 [in, switch_is(dwTypeId)] DNSSRV_RPC_UNION pData
1286 );
1287
1288 NTSTATUS DnssrvQuery2(
1289 [in] uint32 dwClientVersion,
1290 [in] uint32 dwSettingFlags,
1291 [in,unique,string,charset(UTF16)] uint16 *pwszServerName,
1292 [in,unique,string,charset(UTF8)] uint8 *pszZone,
1293 [in,unique,string,charset(UTF8)] uint8 *pszOperation,
1294 [out] DNS_RPC_TYPEID *pdwTypeId,
1295 [out, switch_is(*pdwTypeId)] DNSSRV_RPC_UNION *ppData
1296 );
1297
1298 NTSTATUS DnssrvComplexOperation2(
1299 [in] uint32 dwClientVersion,
1300 [in] uint32 dwSettingFlags,
1301 [in,unique,string,charset(UTF16)] uint16 *pwszServerName,
1302 [in,unique,string,charset(UTF8)] uint8 *pszZone,
1303 [in,unique,string,charset(UTF8)] uint8 *pszOperation,
1304 [in] DNS_RPC_TYPEID dwTypeIn,
1305 [in, switch_is(dwTypeIn)] DNSSRV_RPC_UNION pDataIn,
1306 [out] DNS_RPC_TYPEID *pdwTypeOut,
1307 [out, switch_is(*pdwTypeOut)] DNSSRV_RPC_UNION *ppDataOut
1308 );
1309
1310 typedef struct {
1311 uint16 wLength;
1312 uint16 wRecordCount;
1313 uint32 dwFlags;
1314 uint32 dwChildCount;
1315 DNS_RPC_NAME dnsNodeName;
1316 DNS_RPC_RECORD records[wRecordCount];
1317 } DNS_RPC_RECORDS;
1318
1319 NTSTATUS DnssrvEnumRecords2(
1320 [in] DWORD dwClientVersion,
1321 [in] DWORD dwSettingFlags,
1322 [in,unique,string,charset(UTF16)] uint16 *pwszServerName,
1323 [in,unique,string,charset(UTF8)] uint8 *pszZone,
1324 [in,unique,string,charset(UTF8)] uint8 *pszNodeName,
1325 [in,unique,string,charset(UTF8)] uint8 *pszStartChild,
1326 [in] dns_record_type wRecordType,
1327 [in] DWORD fSelectFlag,
1328 [in,unique,string,charset(UTF8)] uint8 *pszFilterStart,
1329 [in,unique,string,charset(UTF8)] uint8 *pszFilterStop,
1330 [out] uint32 *pdwBufferLength,
1331 [out,unique,subcontext(4),subcontext_size(*pdwBufferLength)] DNS_RPC_RECORDS *pBuffer
1332 );
1333
1334 NTSTATUS DnssrvUpdateRecord2(
1335 [in] uint32 dwClientVersion,
1336 [in] uint32 dwSettingFlags,
1337 [in,unique,string,charset(UTF16)] uint16 *pwszServerName,
1338 [in,unique,string,charset(UTF8)] uint8 *pszZone,
1339 [in,string,charset(UTF8)] uint8 *pszNodeName,
1340 [in, unique] DNS_RPC_RECORD_BUF *pAddRecord,
1341 [in, unique] DNS_RPC_RECORD_BUF *DeleteRecord
1342 );
1343 }
Samba GIT mirror