librpc/idl/dnsserver.idl

   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 struct {
 605                 DWORD           dwRpcStructureVersion;
 606                 DWORD           dwReserved0;
 607
 608                 [string, charset(UTF8)] char *          pszDpFqdn;
 609                 [string, charset(UTF16)] wchar_t *       pszDpDn;
 610                 [string, charset(UTF16)] wchar_t *       pszCrDn;
 611                 DWORD           dwFlags;
 612                 DWORD           dwZoneCount;
 613                 DWORD           dwState;
 614
 615                 DWORD           dwReserved[    3 ];
 616                 DNS_EXTENSION   pwszReserved[ 3 ];
 617                 [range(0,10000)]               DWORD                    dwReplicaCount;
 618                 [size_is(dwReplicaCount)]      PDNS_RPC_DP_REPLICA      ReplicaArray[];
 619         }
 620         DNS_RPC_DP_INFO;
 621
 622         typedef struct {
 623                 DWORD           dwRpcStructureVersion;
 624                 DWORD           dwReserved0;
 625
 626                 [string, charset(UTF8)] char * pszDpFqdn;
 627                 DWORD           dwFlags;
 628                 DWORD           dwZoneCount;
 629         }
 630         DNS_RPC_DP_ENUM;
 631 #define PDNS_RPC_DP_ENUM DNS_RPC_DP_ENUM*
 632
 633         typedef struct {
 634                 DWORD                   dwRpcStructureVersion;
 635                 DWORD                   dwReserved0;
 636                 [range(0,5000)]         DWORD               dwDpCount;
 637                 [size_is(dwDpCount)]    PDNS_RPC_DP_ENUM    DpArray[];
 638         }
 639         DNS_RPC_DP_LIST;
 640
 641         typedef struct {
 642                 DWORD       dwRpcStructureVersion;
 643                 DWORD       dwReserved0;
 644                 [string, charset(UTF8)] char * pszDpFqdn;       /*      UTF8 */
 645                 DWORD       dwOperation;
 646         }
 647         DNS_RPC_ENLIST_DP;
 648
 649         typedef struct {
 650                 DWORD       dwRpcStructureVersion;
 651                 DWORD       dwReserved0;
 652                 [string, charset(UTF8)] char * pszDestPartition;
 653         }
 654         DNS_RPC_ZONE_CHANGE_DP;
 655
 656
 657         /* */
 658         /*   DNS Zone data types */
 659         /* */
 660
 661         /* DNS_ZONE_TYPE defined in dnsp as dns_zone_type */
 662
 663         typedef [v1_enum] enum {
 664                 DNS_ZONE_SECSECURE_NO_SECURITY  = 0x00,
 665                 DNS_ZONE_SECSECURE_NS_ONLY              = 0x01,
 666                 DNS_ZONE_SECSECURE_LIST_ONLY    = 0x02,
 667                 DNS_ZONE_SECSECURE_NO_XFER              = 0x03
 668         }
 669         DNS_ZONE_SECONDARY_SECURITY;
 670
 671         typedef [v1_enum] enum {
 672                 DNS_ZONE_NOTIFY_OFF                             = 0x00,
 673                 DNS_ZONE_NOTIFY_ALL_SECONDARIES = 0x01,
 674                 DNS_ZONE_NOTIFY_LIST_ONLY               = 0x02
 675         }
 676         DNS_ZONE_NOTIFY_LEVEL;
 677
 678         typedef [v1_enum] enum {
 679                 DNS_ZONE_REQUEST_PRIMARY                = 0x00000001,
 680                 DNS_ZONE_REQUEST_SECONDARY              = 0x00000002,
 681                 DNS_ZONE_REQUEST_CACHE                  = 0x00000004,
 682                 DNS_ZONE_REQUEST_AUTO                   = 0x00000008,
 683                 DNS_ZONE_REQUEST_FORWARD                = 0x00000010,
 684                 DNS_ZONE_REQUEST_REVERSE                = 0x00000020,
 685                 DNS_ZONE_REQUEST_FORWARDER              = 0x00000040,
 686                 DNS_ZONE_REQUEST_STUB                   = 0x00000080,
 687                 DNS_ZONE_REQUEST_DS                             = 0x00000100,
 688                 DNS_ZONE_REQUEST_NON_DS                 = 0x00000200,
 689                 DNS_ZONE_REQUEST_DOMAIN_DP              = 0x00000400,
 690                 DNS_ZONE_REQUEST_FOREST_DP              = 0x00000800,
 691                 DNS_ZONE_REQUEST_CUSTOM_DP              = 0x00001000,
 692                 DNS_ZONE_REQUEST_LEGACY_DP              = 0x00002000
 693         }
 694         DNS_ZONE_REQUEST_FILTERS;
 695
 696         typedef [bitmap32bit] bitmap {
 697                 DNS_RPC_ZONE_PAUSED                             = 0x0001,
 698                 DNS_RPC_ZONE_SHUTDOWN                   = 0x0002,
 699                 DNS_RPC_ZONE_REVERSE                    = 0x0004,
 700                 DNS_RPC_ZONE_AUTOCREATED                = 0x0008,
 701                 DNS_RPC_ZONE_DSINTEGRATED               = 0x0010,
 702                 DNS_RPC_ZONE_AGING                              = 0x0020,
 703                 DNS_RPC_ZONE_UPDATE_UNSECURE    = 0x0040,
 704                 DNS_RPC_ZONE_UPDATE_SECURE              = 0x0080,
 705                 DNS_RPC_ZONE_READONLY                   = 0x0100
 706         } DNS_RPC_ZONE_FLAGS;
 707
 708         typedef struct {
 709                 [string, charset(UTF16)] uint16 *      pszZoneName;
 710                 DNS_RPC_ZONE_FLAGS      Flags;
 711                 UCHAR                   ZoneType;
 712                 UCHAR                   Version;
 713         }
 714         DNS_RPC_ZONE_W2K;
 715 #define PDNS_RPC_ZONE_W2K DNS_RPC_ZONE_W2K*
 716
 717         typedef struct {
 718                 DWORD                   dwRpcStructureVersion;
 719                 DWORD                   dwReserved0;
 720                 [string, charset(UTF16)] wchar_t *      pszZoneName;
 721                 DNS_RPC_ZONE_FLAGS      Flags;
 722                 UCHAR                   ZoneType;
 723                 UCHAR                   Version;
 724                 DNS_RPC_DP_FLAGS        dwDpFlags;
 725                 [string, charset(UTF8)] char *         pszDpFqdn;
 726         }
 727         DNS_RPC_ZONE_DOTNET;
 728 #define DNS_RPC_ZONE DNS_RPC_ZONE_DOTNET
 729 #define PDNS_RPC_ZONE_DOTNET DNS_RPC_ZONE_DOTNET*
 730
 731         /* Zone enumeration */
 732         typedef struct {
 733                 [range(0,500000)]       DWORD               dwZoneCount;
 734                 [size_is(dwZoneCount)] PDNS_RPC_ZONE_W2K    ZoneArray[];
 735         }
 736         DNS_RPC_ZONE_LIST_W2K;
 737
 738         typedef struct {
 739                 DWORD                   dwRpcStructureVersion;
 740                 DWORD                   dwReserved0;
 741                 [range(0,500000)]       DWORD                   dwZoneCount;
 742                 [size_is(dwZoneCount)] PDNS_RPC_ZONE_DOTNET     ZoneArray[];
 743         }
 744         DNS_RPC_ZONE_LIST_DOTNET;
 745 #define DNS_RPC_ZONE_LIST DNS_RPC_ZONE_LIST_DOTNET
 746
 747         /* Zone information */
 748         typedef struct {
 749                 [string, charset(UTF8)] char * pszZoneName;
 750                 DWORD       dwZoneType;
 751                 BOOL       fReverse;
 752                 dns_zone_update       fAllowUpdate;
 753                 DWORD       fPaused;
 754                 DWORD       fShutdown;
 755                 DWORD       fAutoCreated;
 756
 757                 /* Database info */
 758                 DWORD       fUseDatabase;
 759                 [string, charset(UTF8)] char * pszDataFile;
 760
 761                 /* Masters */
 762                 PIP4_ARRAY aipMasters;
 763
 764                 /* Secondaries */
 765                 DNS_ZONE_SECONDARY_SECURITY      fSecureSecondaries;
 766                 DNS_ZONE_NOTIFY_LEVEL      fNotifyLevel;
 767                 PIP4_ARRAY aipSecondaries;
 768                 PIP4_ARRAY aipNotify;
 769
 770                 /* WINS or NetBIOS lookup */
 771                 BOOL      fUseWins;
 772                 BOOL      fUseNbstat;
 773
 774                 /* Aging */
 775                 BOOL         fAging;
 776                 DWORD         dwNoRefreshInterval;
 777                 DWORD         dwRefreshInterval;
 778                 DWORD         dwAvailForScavengeTime;
 779                 PIP4_ARRAY    aipScavengeServers;
 780
 781                 /* save some space, just in case */
 782                 /* avoid versioning issues if possible */
 783                 DWORD      pvReserved1;
 784                 DWORD      pvReserved2;
 785                 DWORD      pvReserved3;
 786                 DWORD       pvReserved4;
 787         }
 788         DNS_RPC_ZONE_INFO_W2K;
 789
 790         typedef struct {
 791                 DWORD       dwRpcStructureVersion;
 792                 DWORD       dwReserved0;
 793
 794                 [string, charset(UTF8)] char * pszZoneName;
 795                 DWORD       dwZoneType;
 796                 BOOL       fReverse;
 797                 dns_zone_update       fAllowUpdate;
 798                 DWORD       fPaused;
 799                 DWORD       fShutdown;
 800                 DWORD       fAutoCreated;
 801
 802                 /* Database info */
 803                 DWORD       fUseDatabase;
 804                 [string, charset(UTF8)] char * pszDataFile;
 805
 806                 /* Masters */
 807                 PIP4_ARRAY aipMasters;
 808
 809                 /* Secondaries */
 810                 DNS_ZONE_SECONDARY_SECURITY      fSecureSecondaries;
 811                 DNS_ZONE_NOTIFY_LEVEL      fNotifyLevel;
 812                 PIP4_ARRAY aipSecondaries;
 813                 PIP4_ARRAY aipNotify;
 814
 815                 /* WINS or NetBIOS lookup */
 816                 BOOL      fUseWins;
 817                 BOOL      fUseNbstat;
 818
 819                 /* Aging */
 820                 BOOL         fAging;
 821                 DWORD         dwNoRefreshInterval;
 822                 DWORD         dwRefreshInterval;
 823                 DWORD         dwAvailForScavengeTime;
 824                 PIP4_ARRAY    aipScavengeServers;
 825
 826                 /* Forwarder zones */
 827                 DWORD      dwForwarderTimeout;
 828                 DWORD      fForwarderSlave;
 829
 830                 /* Stub zones */
 831                 PIP4_ARRAY aipLocalMasters;
 832
 833                 /* Directory partition */
 834                 DWORD       dwDpFlags;
 835                 [string, charset(UTF8)] char *      pszDpFqdn;
 836                 [string, charset(UTF16)] wchar_t *   pwszZoneDn;
 837
 838                 /* Xfr time information */
 839                 DWORD      dwLastSuccessfulSoaCheck;
 840                 DWORD      dwLastSuccessfulXfr;
 841
 842                 /* save some space, just in case */
 843                 DWORD      dwReserved1;
 844                 DWORD         dwReserved2;
 845                 DWORD         dwReserved3;
 846                 DWORD         dwReserved4;
 847                 DWORD         dwReserved5;
 848                 [string, charset(UTF8)]   char *       pReserved1;
 849                 [string, charset(UTF8)]   char *       pReserved2;
 850                 [string, charset(UTF8)]   char *       pReserved3;
 851                 [string, charset(UTF8)]   char *       pReserved4;
 852         }
 853         DNS_RPC_ZONE_INFO_DOTNET;
 854
 855         typedef struct {
 856                 DWORD               dwRpcStructureVersion;
 857                 DWORD               dwReserved0;
 858
 859                 [string, charset(UTF8)] char *                  pszZoneName;
 860                 DWORD                  dwZoneType;
 861                 BOOL                  fReverse;
 862                 dns_zone_update        fAllowUpdate;
 863                 DWORD                  fPaused;
 864                 DWORD                  fShutdown;
 865                 DWORD                  fAutoCreated;
 866
 867                 /* Database info */
 868                 DWORD                  fUseDatabase;
 869                 [string, charset(UTF8)] char *                  pszDataFile;
 870
 871                 /* Masters */
 872                 PDNS_ADDR_ARRAY        aipMasters;
 873
 874                 /* Secondaries */
 875                 DNS_ZONE_SECONDARY_SECURITY                  fSecureSecondaries;
 876                 DNS_ZONE_NOTIFY_LEVEL                  fNotifyLevel;
 877                 PDNS_ADDR_ARRAY        aipSecondaries;
 878                 PDNS_ADDR_ARRAY        aipNotify;
 879
 880                 /* WINS or NetBIOS lookup */
 881                 BOOL              fUseWins;
 882                 BOOL              fUseNbstat;
 883
 884                 /* Aging */
 885                 BOOL                  fAging;
 886                 DWORD                  dwNoRefreshInterval;
 887                 DWORD                  dwRefreshInterval;
 888                 DWORD                  dwAvailForScavengeTime;
 889                 PDNS_ADDR_ARRAY        aipScavengeServers;
 890
 891                 /* Forwarder zones */
 892                 DWORD              dwForwarderTimeout;
 893                 DWORD              fForwarderSlave;
 894
 895                 /* Stub zones */
 896                 PDNS_ADDR_ARRAY        aipLocalMasters;
 897
 898                 /* Directory partition */
 899                 DWORD              dwDpFlags;
 900                 [string, charset(UTF8)] char *              pszDpFqdn;
 901                 [string, charset(UTF16)] wchar_t *             pwszZoneDn;
 902                 /* Xfr time information */
 903                 DWORD              dwLastSuccessfulSoaCheck;
 904                 DWORD              dwLastSuccessfulXfr;
 905
 906                 DWORD                 fQueuedForBackgroundLoad;
 907                 DWORD                 fBackgroundLoadInProgress;
 908                 BOOL                  fReadOnlyZone;
 909
 910                 /* Additional zone transfer information */
 911                 DWORD              dwLastXfrAttempt;
 912                 DWORD              dwLastXfrResult;
 913         }
 914         DNS_RPC_ZONE_INFO_LONGHORN;
 915 #define DNS_RPC_ZONE_INFO DNS_RPC_ZONE_INFO_LONGHORN
 916
 917         /* Zone property data */
 918         typedef struct {
 919                 DNS_ZONE_SECONDARY_SECURITY       fSecureSecondaries;
 920                 DNS_ZONE_NOTIFY_LEVEL       fNotifyLevel;
 921                 PIP4_ARRAY aipSecondaries;
 922                 PIP4_ARRAY aipNotify;
 923         }
 924         DNS_RPC_ZONE_SECONDARIES_W2K;
 925
 926         typedef struct {
 927                 DWORD       dwRpcStructureVersion;
 928                 DWORD       dwReserved0;
 929
 930                 DNS_ZONE_SECONDARY_SECURITY         fSecureSecondaries;
 931                 DNS_ZONE_NOTIFY_LEVEL         fNotifyLevel;
 932                 PIP4_ARRAY    aipSecondaries;
 933                 PIP4_ARRAY    aipNotify;
 934         }
 935         DNS_RPC_ZONE_SECONDARIES_DOTNET;
 936
 937         typedef struct {
 938                 DWORD               dwRpcStructureVersion;
 939                 DWORD               dwReserved0;
 940
 941                 DNS_ZONE_SECONDARY_SECURITY                 fSecureSecondaries;
 942                 DNS_ZONE_NOTIFY_LEVEL                 fNotifyLevel;
 943                 PDNS_ADDR_ARRAY       aipSecondaries;
 944                 PDNS_ADDR_ARRAY       aipNotify;
 945         }
 946         DNS_RPC_ZONE_SECONDARIES_LONGHORN;
 947 #define DNS_RPC_ZONE_SECONDARIES DNS_RPC_ZONE_SECONDARIES_LONGHORN
 948
 949         /* Zone database */
 950         typedef struct {
 951                 DWORD       fDsIntegrated;
 952                 [string, charset(UTF8)] char * pszFileName;
 953         }
 954         DNS_RPC_ZONE_DATABASE_W2K;
 955
 956         typedef struct {
 957                 DWORD       dwRpcStructureVersion;
 958                 DWORD       dwReserved0;
 959
 960                 DWORD       fDsIntegrated;
 961                 [string, charset(UTF8)] char * pszFileName;
 962         }
 963         DNS_RPC_ZONE_DATABASE_DOTNET;
 964 #define DNS_RPC_ZONE_DATABASE DNS_RPC_ZONE_DATABASE_DOTNET
 965
 966         /* Zone create data */
 967         typedef struct {
 968                 [string, charset(UTF8)] char *       pszZoneName;
 969                 DWORD       dwZoneType;
 970                 dns_zone_update       fAllowUpdate;
 971                 BOOL       fAging;
 972                 DWORD       dwFlags;
 973
 974                 /*   Database info */
 975
 976                 [string, charset(UTF8)] char *       pszDataFile;
 977                 DWORD       fDsIntegrated;
 978                 DWORD       fLoadExisting;
 979
 980                 /*   Admin name (if auto-create SOA) */
 981
 982                 [string, charset(UTF8)] char *           pszAdmin;
 983
 984                 /*   Masters (if secondary) */
 985
 986                 PIP4_ARRAY   aipMasters;
 987
 988                 /*   Secondaries */
 989
 990                 PIP4_ARRAY   aipSecondaries;
 991                 DNS_ZONE_SECONDARY_SECURITY        fSecureSecondaries;
 992                 DNS_ZONE_NOTIFY_LEVEL        fNotifyLevel;
 993
 994                 /*   Reserve some space to avoid versioning issues */
 995
 996                 [string, charset(UTF8)]   char   *       pvReserved1;
 997                 [string, charset(UTF8)]   char   *       pvReserved2;
 998                 [string, charset(UTF8)]   char   *       pvReserved3;
 999                 [string, charset(UTF8)]   char   *       pvReserved4;
1000                 [string, charset(UTF8)]   char   *       pvReserved5;
1001                 [string, charset(UTF8)]   char   *       pvReserved6;
1002                 [string, charset(UTF8)]   char   *       pvReserved7;
1003                 [string, charset(UTF8)]   char   *       pvReserved8;
1004                 DWORD         dwReserved1;
1005                 DWORD         dwReserved2;
1006                 DWORD         dwReserved3;
1007                 DWORD         dwReserved4;
1008                 DWORD         dwReserved5;
1009                 DWORD         dwReserved6;
1010                 DWORD         dwReserved7;
1011                 DWORD         dwReserved8;
1012         }
1013         DNS_RPC_ZONE_CREATE_INFO_W2K;
1014
1015         typedef struct {
1016                 DWORD       dwRpcStructureVersion;
1017                 DWORD       dwReserved0;
1018
1019                 [string, charset(UTF8)] char *       pszZoneName;
1020                 DWORD       dwZoneType;
1021                 dns_zone_update       fAllowUpdate;
1022                 BOOL       fAging;
1023                 DWORD       dwFlags;
1024
1025                 /*   Database info */
1026
1027                 [string, charset(UTF8)] char *       pszDataFile;
1028                 DWORD       fDsIntegrated;
1029                 DWORD       fLoadExisting;
1030
1031                 /*   Admin name (if auto-create SOA) */
1032
1033                 [string, charset(UTF8)] char *            pszAdmin;
1034
1035                 /*   Masters (if secondary) */
1036
1037                 PIP4_ARRAY    aipMasters;
1038
1039                 /*   Secondaries */
1040
1041                 PIP4_ARRAY    aipSecondaries;
1042                 DNS_ZONE_SECONDARY_SECURITY         fSecureSecondaries;
1043                 DNS_ZONE_NOTIFY_LEVEL         fNotifyLevel;
1044
1045                 /*   Forwarder zones */
1046
1047                 DWORD         dwTimeout;
1048                 DWORD         fRecurseAfterForwarding;
1049
1050                 /*   Directory partition */
1051
1052                 DWORD       dwDpFlags;      /* specify built-in DP or */
1053                 [string, charset(UTF8)] char *       pszDpFqdn;     /*      UTF8 FQDN of partition */
1054
1055                 DWORD       dwReserved[ 32 ];
1056         }
1057         DNS_RPC_ZONE_CREATE_INFO_DOTNET;
1058
1059         typedef struct {
1060                 DWORD                  dwRpcStructureVersion;
1061                 DWORD                  dwReserved0;
1062
1063                 [string, charset(UTF8)] char *                  pszZoneName;
1064                 DWORD                  dwZoneType;
1065                 dns_zone_update                  fAllowUpdate;
1066                 BOOL                  fAging;
1067                 DWORD                  dwFlags;
1068
1069                 /*   Database info */
1070
1071                 [string, charset(UTF8)] char *                  pszDataFile;
1072                 DWORD                  fDsIntegrated;
1073                 DWORD                  fLoadExisting;
1074
1075                 /*   Admin name (if auto-create SOA) */
1076
1077                 [string, charset(UTF8)] char *                    pszAdmin;
1078
1079                 /*   Masters (if secondary) */
1080
1081                 PDNS_ADDR_ARRAY        aipMasters;
1082
1083                 /*   Secondaries */
1084
1085                 PDNS_ADDR_ARRAY        aipSecondaries;
1086                 DNS_ZONE_SECONDARY_SECURITY                  fSecureSecondaries;
1087                 DNS_ZONE_NOTIFY_LEVEL                  fNotifyLevel;
1088
1089                 /*   Forwarder zones */
1090
1091                 DWORD                  dwTimeout;
1092                 DWORD                  fRecurseAfterForwarding;
1093
1094                 /*   Directory partition */
1095
1096                 DWORD                  dwDpFlags;      /* specify built-in DP or */
1097                 [string, charset(UTF8)] char *                  pszDpFqdn;     /*      UTF8 FQDN of partition */
1098
1099                 DWORD               dwReserved[ 32 ];
1100         }
1101         DNS_RPC_ZONE_CREATE_INFO_LONGHORN;
1102 #define DNS_RPC_ZONE_CREATE_INFO DNS_RPC_ZONE_CREATE_INFO_LONGHORN
1103
1104         /* Zone export */
1105         typedef struct {
1106                 DWORD       dwRpcStructureVersion;
1107                 DWORD       dwReserved0;
1108
1109                 [string, charset(UTF8)] char * pszZoneExportFile;
1110         }
1111         DNS_RPC_ZONE_EXPORT_INFO;
1112
1113         typedef struct {
1114                 DWORD       dwRpcStructureVersion;
1115                 DWORD       dwReserved0;
1116
1117                 DWORD       dwFilter;
1118                 [string, charset(UTF8)] char *       pszPartitionFqdn;
1119                 [string, charset(UTF8)] char *       pszQueryString;
1120
1121                 DNS_EXTENSION     pszReserved[ 6 ];
1122         }
1123         DNS_RPC_ENUM_ZONES_FILTER;
1124
1125         /* Forwarders information */
1126         typedef struct {
1127                 DWORD       fRecurseAfterForwarding;
1128                 DWORD       dwForwardTimeout;
1129                 PIP4_ARRAY aipForwarders;
1130         }
1131         DNS_RPC_FORWARDERS_W2K;
1132
1133         typedef struct {
1134                 DWORD       dwRpcStructureVersion;
1135                 DWORD       dwReserved0;
1136                 DWORD       fRecurseAfterForwarding;
1137                 DWORD       dwForwardTimeout;
1138                 PIP4_ARRAY aipForwarders;
1139         }
1140         DNS_RPC_FORWARDERS_DOTNET;
1141
1142         typedef struct {
1143                 DWORD               dwRpcStructureVersion;
1144                 DWORD               dwReserved0;
1145                 DWORD               fRecurseAfterForwarding;
1146                 DWORD               dwForwardTimeout;
1147                 PDNS_ADDR_ARRAY     aipForwarders;
1148         }
1149         DNS_RPC_FORWARDERS_LONGHORN;
1150 #define DNS_RPC_FORWARDERS DNS_RPC_FORWARDERS_LONGHORN
1151
1152
1153         /* */
1154         /*   DNS autoconfig data types */
1155         /* */
1156
1157         typedef [v1_enum] enum {
1158                 DNS_RPC_AUTOCONFIG_INTERNAL_ROOTHINTS                   = 0x00000001,
1159                 DNS_RPC_AUTOCONFIG_INTERNAL_FORWARDERS                  = 0x00000002,
1160                 DNS_RPC_AUTOCONFIG_INTERNAL_ZONES                               = 0x00000004,
1161                 DNS_RPC_AUTOCONFIG_INTERNAL_SELFPOINT                   = 0x00000010,
1162                 DNS_RPC_AUTOCONFIG_INTERNAL_SELFPOINT_PREPEND   = 0x00000020,
1163                 DNS_RPC_AUTOCONFIG_INTERNAL_SELFPOINT_APPEND    = 0x00000040,
1164                 DNS_RPC_AUTOCONFIG_INTERNAL_RETURN_ERROR                = 0x00008000,
1165                 DNS_RPC_AUTOCONFIG_ALL                                                  = 0xFFFFFFFF
1166         }
1167         DNS_RPC_AUTOCONFIG;
1168
1169         typedef struct {
1170                 DWORD                  dwRpcStructureVersion;
1171                 DWORD                  dwReserved0;
1172                 DNS_RPC_AUTOCONFIG     dwAutoConfigFlags;
1173                 DWORD                  dwReserved1;
1174                 [string, charset(UTF8)] char * pszNewDomainName;
1175         }
1176         DNS_RPC_AUTOCONFIGURE;
1177
1178
1179         /* */
1180         /*   DNS logging data types */
1181         /* */
1182
1183         typedef [bitmap32bit] bitmap {
1184                 DNS_EVENT_LOG_SUCCESS                   = 0x00000000,
1185                 DNS_EVENT_LOG_ERROR_TYPE                = 0x00000001,
1186                 DNS_EVENT_LOG_WARNING_TYPE              = 0x00000002,
1187                 DNS_EVENT_LOG_INFORMATION_TYPE  = 0x00000004
1188         }
1189         DNS_EVENT_LOG_TYPES;
1190
1191         typedef [bitmap32bit] bitmap {
1192                 DNS_RPC_VIEW_AUTHORITY_DATA             = 0x00000001,
1193                 DNS_RPC_VIEW_CACHE_DATA                 = 0x00000002,
1194                 DNS_RPC_VIEW_GLUE_DATA                  = 0x00000004,
1195                 DNS_RPC_VIEW_ROOT_HINT_DATA             = 0x00000008,
1196                 DNS_RPC_VIEW_ADDITIONAL_DATA    = 0x00000010,
1197                 DNS_RPC_VIEW_NO_CHILDREN                = 0x00010000,
1198                 DNS_RPC_VIEW_ONLY_CHILDREN              = 0x00020000
1199         }
1200         DNS_SELECT_FLAGS;
1201
1202
1203         /* */
1204         /*   DNS statistics data types */
1205         /* */
1206
1207         typedef struct {
1208                 DWORD       StatId;
1209                 WORD        wLength;
1210                 BOOLEAN     fClear;
1211                 UCHAR       fReserved;
1212         }
1213         DNSSRV_STAT_HEADER;
1214
1215         typedef struct {
1216                 DNSSRV_STAT_HEADER Header;
1217                 BYTE                Buffer[1];
1218         }
1219         DNSSRV_STAT;
1220
1221
1222         /* */
1223         /*   DNS Typid and Union of all RPC data types */
1224         /* */
1225
1226         typedef [v1_enum] enum {
1227                 DNSSRV_TYPEID_NULL                      = 0,
1228                 DNSSRV_TYPEID_DWORD                     = 1,
1229                 DNSSRV_TYPEID_LPSTR                     = 2,
1230                 DNSSRV_TYPEID_LPWSTR                    = 3,
1231                 DNSSRV_TYPEID_IPARRAY                   = 4,
1232                 DNSSRV_TYPEID_BUFFER                    = 5,
1233                 DNSSRV_TYPEID_SERVER_INFO_W2K           = 6,
1234                 DNSSRV_TYPEID_STATS                     = 7,
1235                 DNSSRV_TYPEID_FORWARDERS_W2K            = 8,
1236                 DNSSRV_TYPEID_ZONE_W2K                  = 9,
1237                 DNSSRV_TYPEID_ZONE_INFO_W2K             = 10,
1238                 DNSSRV_TYPEID_ZONE_SECONDARIES_W2K      = 11,
1239                 DNSSRV_TYPEID_ZONE_DATABASE_W2K         = 12,
1240                 DNSSRV_TYPEID_ZONE_TYPE_RESET_W2K       = 13,
1241                 DNSSRV_TYPEID_ZONE_CREATE_W2K           = 14,
1242                 DNSSRV_TYPEID_NAME_AND_PARAM            = 15,
1243                 DNSSRV_TYPEID_ZONE_LIST_W2K             = 16,
1244                 DNSSRV_TYPEID_ZONE_RENAME               = 17,
1245                 DNSSRV_TYPEID_ZONE_EXPORT               = 18,
1246                 DNSSRV_TYPEID_SERVER_INFO_DOTNET        = 19,
1247                 DNSSRV_TYPEID_FORWARDERS_DOTNET         = 20,
1248                 DNSSRV_TYPEID_ZONE                      = 21,
1249                 DNSSRV_TYPEID_ZONE_INFO_DOTNET          = 22,
1250                 DNSSRV_TYPEID_ZONE_SECONDARIES_DOTNET   = 23,
1251                 DNSSRV_TYPEID_ZONE_DATABASE             = 24,
1252                 DNSSRV_TYPEID_ZONE_TYPE_RESET_DOTNET    = 25,
1253                 DNSSRV_TYPEID_ZONE_CREATE_DOTNET        = 26,
1254                 DNSSRV_TYPEID_ZONE_LIST                 = 27,
1255                 DNSSRV_TYPEID_DP_ENUM                   = 28,
1256                 DNSSRV_TYPEID_DP_INFO                   = 29,
1257                 DNSSRV_TYPEID_DP_LIST                   = 30,
1258                 DNSSRV_TYPEID_ENLIST_DP                 = 31,
1259                 DNSSRV_TYPEID_ZONE_CHANGE_DP            = 32,
1260                 DNSSRV_TYPEID_ENUM_ZONES_FILTER         = 33,
1261                 DNSSRV_TYPEID_ADDRARRAY                 = 34,
1262                 DNSSRV_TYPEID_SERVER_INFO               = 35,
1263                 DNSSRV_TYPEID_ZONE_INFO                 = 36,
1264                 DNSSRV_TYPEID_FORWARDERS                = 37,
1265                 DNSSRV_TYPEID_ZONE_SECONDARIES          = 38,
1266                 DNSSRV_TYPEID_ZONE_TYPE_RESET           = 39,
1267                 DNSSRV_TYPEID_ZONE_CREATE               = 40,
1268                 DNSSRV_TYPEID_IP_VALIDATE               = 41,
1269                 DNSSRV_TYPEID_AUTOCONFIGURE             = 42,
1270                 DNSSRV_TYPEID_UTF8_STRING_LIST          = 43,
1271                 DNSSRV_TYPEID_UNICODE_STRING_LIST       = 44
1272         }
1273         DNS_RPC_TYPEID;
1274
1275         typedef [switch_type(uint3264)] union {
1276                 [case(DNSSRV_TYPEID_NULL)]      PBYTE       Null;
1277
1278                 [case(DNSSRV_TYPEID_DWORD)]         DWORD        Dword;
1279
1280                 [case(DNSSRV_TYPEID_LPSTR)]         [string, charset(UTF8)] char *        String;
1281
1282                 [case(DNSSRV_TYPEID_LPWSTR)]        [string, charset(UTF16)] wchar_t *     WideString;
1283
1284                 [case(DNSSRV_TYPEID_IPARRAY)]       IP4_ARRAY   *IpArray;
1285
1286                 [case(DNSSRV_TYPEID_BUFFER)]
1287                 DNS_RPC_BUFFER                              *Buffer;
1288
1289                 [case(DNSSRV_TYPEID_SERVER_INFO_W2K)]
1290                 DNS_RPC_SERVER_INFO_W2K                     *ServerInfoW2K;
1291
1292                 [case(DNSSRV_TYPEID_STATS)]
1293                 DNSSRV_STAT                                 *Stats;
1294
1295                 [case(DNSSRV_TYPEID_FORWARDERS_W2K)]
1296                 DNS_RPC_FORWARDERS_W2K                      *ForwardersW2K;
1297
1298                 [case(DNSSRV_TYPEID_ZONE_W2K)]
1299                 DNS_RPC_ZONE_W2K                            *ZoneW2K;
1300
1301                 [case(DNSSRV_TYPEID_ZONE_INFO_W2K)]
1302                 DNS_RPC_ZONE_INFO_W2K                       *ZoneInfoW2K;
1303
1304                 [case(DNSSRV_TYPEID_ZONE_SECONDARIES_W2K)]
1305                 DNS_RPC_ZONE_SECONDARIES_W2K                *SecondariesW2K;
1306
1307                 [case(DNSSRV_TYPEID_ZONE_DATABASE_W2K)]
1308                 DNS_RPC_ZONE_DATABASE_W2K                   *DatabaseW2K;
1309
1310                 [case(DNSSRV_TYPEID_ZONE_CREATE_W2K)]
1311                 DNS_RPC_ZONE_CREATE_INFO_W2K                *ZoneCreateW2K;
1312
1313                 [case(DNSSRV_TYPEID_NAME_AND_PARAM)]
1314                 DNS_RPC_NAME_AND_PARAM                      *NameAndParam;
1315
1316                 [case(DNSSRV_TYPEID_ZONE_LIST_W2K)]
1317                 DNS_RPC_ZONE_LIST_W2K                       *ZoneListW2K;
1318
1319                 [case(DNSSRV_TYPEID_SERVER_INFO_DOTNET)]
1320                 DNS_RPC_SERVER_INFO_DOTNET                  *ServerInfoDotNet;
1321
1322                 [case(DNSSRV_TYPEID_FORWARDERS_DOTNET)]
1323                 DNS_RPC_FORWARDERS_DOTNET                   *ForwardersDotNet;
1324
1325                 [case(DNSSRV_TYPEID_ZONE)]
1326                 DNS_RPC_ZONE                                *Zone;
1327
1328                 [case(DNSSRV_TYPEID_ZONE_INFO_DOTNET)]
1329                 DNS_RPC_ZONE_INFO_DOTNET                    *ZoneInfoDotNet;
1330
1331                 [case(DNSSRV_TYPEID_ZONE_SECONDARIES_DOTNET)]
1332                 DNS_RPC_ZONE_SECONDARIES_DOTNET        *SecondariesDotNet;
1333
1334                 [case(DNSSRV_TYPEID_ZONE_DATABASE)]
1335                 DNS_RPC_ZONE_DATABASE                       *Database;
1336
1337                 [case(DNSSRV_TYPEID_ZONE_CREATE_DOTNET)]
1338                 DNS_RPC_ZONE_CREATE_INFO_DOTNET             *ZoneCreateDotNet;
1339
1340                 [case(DNSSRV_TYPEID_ZONE_LIST)]
1341                 DNS_RPC_ZONE_LIST                           *ZoneList;
1342
1343                 [case(DNSSRV_TYPEID_ZONE_EXPORT)]
1344                 DNS_RPC_ZONE_EXPORT_INFO                    *ZoneExport;
1345
1346                 [case(DNSSRV_TYPEID_DP_INFO)]
1347                 DNS_RPC_DP_INFO                             *DirectoryPartition;
1348
1349                 [case(DNSSRV_TYPEID_DP_ENUM)]
1350                 DNS_RPC_DP_ENUM                             *DirectoryPartitionEnum;
1351
1352                 [case(DNSSRV_TYPEID_DP_LIST)]
1353                 DNS_RPC_DP_LIST                             *DirectoryPartitionList;
1354
1355                 [case(DNSSRV_TYPEID_ENLIST_DP)]
1356                 DNS_RPC_ENLIST_DP                           *EnlistDirectoryPartition;
1357
1358                 [case(DNSSRV_TYPEID_ZONE_CHANGE_DP)]
1359                 DNS_RPC_ZONE_CHANGE_DP                 *ZoneChangeDirectoryPartition;
1360
1361                 [case(DNSSRV_TYPEID_ENUM_ZONES_FILTER)]
1362                 DNS_RPC_ENUM_ZONES_FILTER                   *EnumZonesFilter;
1363
1364                 [case(DNSSRV_TYPEID_ADDRARRAY)]
1365                 DNS_ADDR_ARRAY                              *AddrArray;
1366
1367                 [case(DNSSRV_TYPEID_SERVER_INFO)]
1368                 DNS_RPC_SERVER_INFO                         *ServerInfo;
1369
1370                 [case(DNSSRV_TYPEID_ZONE_CREATE)]
1371                 DNS_RPC_ZONE_CREATE_INFO                    *ZoneCreate;
1372
1373                 [case(DNSSRV_TYPEID_FORWARDERS)]
1374                 DNS_RPC_FORWARDERS                          *Forwarders;
1375
1376                 [case(DNSSRV_TYPEID_ZONE_SECONDARIES)]
1377                 DNS_RPC_ZONE_SECONDARIES                    *Secondaries;
1378
1379                 [case(DNSSRV_TYPEID_IP_VALIDATE)]
1380                 DNS_RPC_IP_VALIDATE                         *IpValidate;
1381
1382                 [case(DNSSRV_TYPEID_ZONE_INFO)]
1383                 DNS_RPC_ZONE_INFO                           *ZoneInfo;
1384
1385                 [case(DNSSRV_TYPEID_AUTOCONFIGURE)]
1386                 DNS_RPC_AUTOCONFIGURE                       *AutoConfigure;
1387
1388                 [case(DNSSRV_TYPEID_UTF8_STRING_LIST)]
1389                 DNS_RPC_UTF8_STRING_LIST                    *Utf8StringList;
1390         } DNSSRV_RPC_UNION;
1391
1392
1393         /* */
1394         /*   DNS RPC interface */
1395         /* */
1396
1397         typedef [public,gensize] struct {
1398                 [value((12+ndr_size_DNS_RPC_NAME(&dnsNodeName,0)+3) & ~3)]  uint16 wLength;
1399                 uint16 wRecordCount;
1400                 uint32 dwFlags;
1401                 uint32 dwChildCount;
1402                 DNS_RPC_NAME dnsNodeName;
1403                 DNS_RPC_RECORD records[wRecordCount];
1404         } DNS_RPC_RECORDS;
1405
1406         typedef [public,nopull,nopush,gensize] struct {
1407                 uint32 count;
1408                 DNS_RPC_RECORDS rec[count];
1409         } DNS_RPC_RECORDS_ARRAY;
1410
1411         WERROR DnssrvOperation(
1412                 [in,unique,string,charset(UTF16)] uint16        *pwszServerName,
1413                 [in,unique,string,charset(UTF8)] uint8          *pszZone,
1414                 [in]                      DWORD                  dwContext,
1415                 [in,unique,string,charset(UTF8)] uint8          *pszOperation,
1416                 [in]                      DNS_RPC_TYPEID         dwTypeId,
1417                 [in, switch_is(dwTypeId)] DNSSRV_RPC_UNION       pData
1418         );
1419
1420         WERROR DnssrvQuery(
1421                 [in,unique,string,charset(UTF16)] uint16       *pwszServerName,
1422                 [in,unique,string,charset(UTF8)] uint8         *pszZone,
1423                 [in,unique,string,charset(UTF8)] uint8         *pszOperation,
1424                 [out]                         DNS_RPC_TYPEID   *pdwTypeId,
1425                 [out, switch_is(*pdwTypeId)]  DNSSRV_RPC_UNION *ppData
1426         );
1427
1428         WERROR DnssrvComplexOperation(
1429                 [in,unique,string,charset(UTF16)] uint16       *pwszServerName,
1430                 [in,unique,string,charset(UTF8)] uint8         *pszZone,
1431                 [in,unique,string,charset(UTF8)] uint8         *pszOperation,
1432                 [in]                          DNS_RPC_TYPEID    dwTypeIn,
1433                 [in, switch_is(dwTypeIn)]     DNSSRV_RPC_UNION  pDataIn,
1434                 [out]                         DNS_RPC_TYPEID   *pdwTypeOut,
1435                 [out, switch_is(*pdwTypeOut)] DNSSRV_RPC_UNION *ppDataOut
1436         );
1437
1438         WERROR DnssrvEnumRecords(
1439                 [in,unique,string,charset(UTF16)] uint16       *pwszServerName,
1440                 [in,unique,string,charset(UTF8)] uint8         *pszZone,
1441                 [in,unique,string,charset(UTF8)]  uint8        *pszNodeName,
1442                 [in,unique,string,charset(UTF8)]  uint8        *pszStartChild,
1443                 [in]                           dns_record_type          wRecordType,
1444                 [in]                           DNS_SELECT_FLAGS        fSelectFlag,
1445                 [in,unique,string,charset(UTF8)]  uint8        *pszFilterStart,
1446                 [in,unique,string,charset(UTF8)]  uint8        *pszFilterStop,
1447                 [out]                          DWORD           *pdwBufferLength,
1448                 [out,ref,subcontext(4),subcontext_size(*pdwBufferLength)] DNS_RPC_RECORDS_ARRAY **pBuffer
1449         );
1450
1451         WERROR DnssrvUpdateRecord(
1452                 [in,unique,string,charset(UTF16)] uint16     *pwszServerName,
1453                 [in,unique,string,charset(UTF8)]  uint8      *pszZone,
1454                 [in,unique,string,charset(UTF8)]  uint8      *pszNodeName,
1455                 [in, unique]    DNS_RPC_RECORD_BUF           *pAddRecord,
1456                 [in, unique]    DNS_RPC_RECORD_BUF           *pDeleteRecord
1457         );
1458
1459         WERROR DnssrvOperation2(
1460                 [in]            DNS_RPC_CLIENT_VERSION     dwClientVersion,
1461                 [in]            uint32                     dwSettingFlags,
1462                 [in,unique,string,charset(UTF16)] uint16  *pwszServerName,
1463                 [in,unique,string,charset(UTF8)] uint8    *pszZone,
1464                 [in]            DWORD                      dwContext,
1465                 [in,unique,string,charset(UTF8)] uint8    *pszOperation,
1466                 [in]            DNS_RPC_TYPEID             dwTypeId,
1467                 [in, switch_is(dwTypeId)] DNSSRV_RPC_UNION pData
1468         );
1469
1470         WERROR DnssrvQuery2(
1471                 [in]            DNS_RPC_CLIENT_VERSION   dwClientVersion,
1472                 [in]            uint32                   dwSettingFlags,
1473                 [in,unique,string,charset(UTF16)] uint16        *pwszServerName,
1474                 [in,unique,string,charset(UTF8)] uint8         *pszZone,
1475                 [in,unique,string,charset(UTF8)] uint8         *pszOperation,
1476                 [out]                         DNS_RPC_TYPEID          *pdwTypeId,
1477                 [out, switch_is(*pdwTypeId)]  DNSSRV_RPC_UNION        *ppData
1478         );
1479
1480         WERROR DnssrvComplexOperation2(
1481                 [in]            DNS_RPC_CLIENT_VERSION          dwClientVersion,
1482                 [in]            uint32                          dwSettingFlags,
1483                 [in,unique,string,charset(UTF16)] uint16       *pwszServerName,
1484                 [in,unique,string,charset(UTF8)] uint8         *pszZone,
1485                 [in,unique,string,charset(UTF8)] uint8         *pszOperation,
1486                 [in]                          DNS_RPC_TYPEID    dwTypeIn,
1487                 [in, switch_is(dwTypeIn)]     DNSSRV_RPC_UNION  pDataIn,
1488                 [out]                         DNS_RPC_TYPEID   *pdwTypeOut,
1489                 [out, switch_is(*pdwTypeOut)] DNSSRV_RPC_UNION *ppDataOut
1490         );
1491
1492         WERROR DnssrvEnumRecords2(
1493                 [in]                           DNS_RPC_CLIENT_VERSION   dwClientVersion,
1494                 [in]                           DWORD                    dwSettingFlags,
1495                 [in,unique,string,charset(UTF16)] uint16               *pwszServerName,
1496                 [in,unique,string,charset(UTF8)]  uint8                *pszZone,
1497                 [in,unique,string,charset(UTF8)]  uint8                *pszNodeName,
1498                 [in,unique,string,charset(UTF8)]  uint8                *pszStartChild,
1499                 [in]                           dns_record_type          wRecordType,
1500                 [in]                           DNS_SELECT_FLAGS         fSelectFlag,
1501                 [in,unique,string,charset(UTF8)]  uint8                *pszFilterStart,
1502                 [in,unique,string,charset(UTF8)]  uint8                *pszFilterStop,
1503                 [out]                             uint32               *pdwBufferLength,
1504                 [out,ref,subcontext(4),subcontext_size(*pdwBufferLength)] DNS_RPC_RECORDS_ARRAY **pBuffer
1505         );
1506
1507         WERROR DnssrvUpdateRecord2(
1508                 [in]            DNS_RPC_CLIENT_VERSION    dwClientVersion,
1509                 [in]            uint32                    dwSettingFlags,
1510                 [in,unique,string,charset(UTF16)] uint16 *pwszServerName,
1511                 [in,unique,string,charset(UTF8)]  uint8  *pszZone,
1512                 [in,string,charset(UTF8)]         uint8  *pszNodeName,
1513                 [in, unique]    DNS_RPC_RECORD_BUF       *pAddRecord,
1514                 [in, unique]    DNS_RPC_RECORD_BUF       *pDeleteRecord
1515         );
1516 }