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