librpc/gen_ndr/cli_netlogon.c

   1 /*
   2  * Unix SMB/CIFS implementation.
   3  * client auto-generated by pidl. DO NOT MODIFY!
   4  */
   5
   6 #include "includes.h"
   7 #include "../librpc/gen_ndr/cli_netlogon.h"
   8
   9 NTSTATUS rpccli_netr_LogonUasLogon(struct rpc_pipe_client *cli,
  10                                    TALLOC_CTX *mem_ctx,
  11                                    const char *server_name /* [in] [unique,charset(UTF16)] */,
  12                                    const char *account_name /* [in] [charset(UTF16)] */,
  13                                    const char *workstation /* [in] [charset(UTF16)] */,
  14                                    struct netr_UasInfo **info /* [out] [ref] */,
  15                                    WERROR *werror)
  16 {
  17         struct netr_LogonUasLogon r;
  18         NTSTATUS status;
  19
  20         /* In parameters */
  21         r.in.server_name = server_name;
  22         r.in.account_name = account_name;
  23         r.in.workstation = workstation;
  24
  25         if (DEBUGLEVEL >= 10) {
  26                 NDR_PRINT_IN_DEBUG(netr_LogonUasLogon, &r);
  27         }
  28
  29         status = cli->dispatch(cli,
  30                                 mem_ctx,
  31                                 &ndr_table_netlogon,
  32                                 NDR_NETR_LOGONUASLOGON,
  33                                 &r);
  34
  35         if (!NT_STATUS_IS_OK(status)) {
  36                 return status;
  37         }
  38
  39         if (DEBUGLEVEL >= 10) {
  40                 NDR_PRINT_OUT_DEBUG(netr_LogonUasLogon, &r);
  41         }
  42
  43         if (NT_STATUS_IS_ERR(status)) {
  44                 return status;
  45         }
  46
  47         /* Return variables */
  48         *info = *r.out.info;
  49
  50         /* Return result */
  51         if (werror) {
  52                 *werror = r.out.result;
  53         }
  54
  55         return werror_to_ntstatus(r.out.result);
  56 }
  57
  58 NTSTATUS rpccli_netr_LogonUasLogoff(struct rpc_pipe_client *cli,
  59                                     TALLOC_CTX *mem_ctx,
  60                                     const char *server_name /* [in] [unique,charset(UTF16)] */,
  61                                     const char *account_name /* [in] [charset(UTF16)] */,
  62                                     const char *workstation /* [in] [charset(UTF16)] */,
  63                                     struct netr_UasLogoffInfo *info /* [out] [ref] */,
  64                                     WERROR *werror)
  65 {
  66         struct netr_LogonUasLogoff r;
  67         NTSTATUS status;
  68
  69         /* In parameters */
  70         r.in.server_name = server_name;
  71         r.in.account_name = account_name;
  72         r.in.workstation = workstation;
  73
  74         if (DEBUGLEVEL >= 10) {
  75                 NDR_PRINT_IN_DEBUG(netr_LogonUasLogoff, &r);
  76         }
  77
  78         status = cli->dispatch(cli,
  79                                 mem_ctx,
  80                                 &ndr_table_netlogon,
  81                                 NDR_NETR_LOGONUASLOGOFF,
  82                                 &r);
  83
  84         if (!NT_STATUS_IS_OK(status)) {
  85                 return status;
  86         }
  87
  88         if (DEBUGLEVEL >= 10) {
  89                 NDR_PRINT_OUT_DEBUG(netr_LogonUasLogoff, &r);
  90         }
  91
  92         if (NT_STATUS_IS_ERR(status)) {
  93                 return status;
  94         }
  95
  96         /* Return variables */
  97         *info = *r.out.info;
  98
  99         /* Return result */
 100         if (werror) {
 101                 *werror = r.out.result;
 102         }
 103
 104         return werror_to_ntstatus(r.out.result);
 105 }
 106
 107 NTSTATUS rpccli_netr_LogonSamLogon(struct rpc_pipe_client *cli,
 108                                    TALLOC_CTX *mem_ctx,
 109                                    const char *server_name /* [in] [unique,charset(UTF16)] */,
 110                                    const char *computer_name /* [in] [unique,charset(UTF16)] */,
 111                                    struct netr_Authenticator *credential /* [in] [unique] */,
 112                                    struct netr_Authenticator *return_authenticator /* [in,out] [unique] */,
 113                                    enum netr_LogonInfoClass logon_level /* [in]  */,
 114                                    union netr_LogonLevel *logon /* [in] [ref,switch_is(logon_level)] */,
 115                                    uint16_t validation_level /* [in]  */,
 116                                    union netr_Validation *validation /* [out] [ref,switch_is(validation_level)] */,
 117                                    uint8_t *authoritative /* [out] [ref] */)
 118 {
 119         struct netr_LogonSamLogon r;
 120         NTSTATUS status;
 121
 122         /* In parameters */
 123         r.in.server_name = server_name;
 124         r.in.computer_name = computer_name;
 125         r.in.credential = credential;
 126         r.in.return_authenticator = return_authenticator;
 127         r.in.logon_level = logon_level;
 128         r.in.logon = logon;
 129         r.in.validation_level = validation_level;
 130
 131         if (DEBUGLEVEL >= 10) {
 132                 NDR_PRINT_IN_DEBUG(netr_LogonSamLogon, &r);
 133         }
 134
 135         status = cli->dispatch(cli,
 136                                 mem_ctx,
 137                                 &ndr_table_netlogon,
 138                                 NDR_NETR_LOGONSAMLOGON,
 139                                 &r);
 140
 141         if (!NT_STATUS_IS_OK(status)) {
 142                 return status;
 143         }
 144
 145         if (DEBUGLEVEL >= 10) {
 146                 NDR_PRINT_OUT_DEBUG(netr_LogonSamLogon, &r);
 147         }
 148
 149         if (NT_STATUS_IS_ERR(status)) {
 150                 return status;
 151         }
 152
 153         /* Return variables */
 154         if (return_authenticator && r.out.return_authenticator) {
 155                 *return_authenticator = *r.out.return_authenticator;
 156         }
 157         *validation = *r.out.validation;
 158         *authoritative = *r.out.authoritative;
 159
 160         /* Return result */
 161         return r.out.result;
 162 }
 163
 164 NTSTATUS rpccli_netr_LogonSamLogoff(struct rpc_pipe_client *cli,
 165                                     TALLOC_CTX *mem_ctx,
 166                                     const char *server_name /* [in] [unique,charset(UTF16)] */,
 167                                     const char *computer_name /* [in] [unique,charset(UTF16)] */,
 168                                     struct netr_Authenticator *credential /* [in] [unique] */,
 169                                     struct netr_Authenticator *return_authenticator /* [in,out] [unique] */,
 170                                     enum netr_LogonInfoClass logon_level /* [in]  */,
 171                                     union netr_LogonLevel logon /* [in] [switch_is(logon_level)] */)
 172 {
 173         struct netr_LogonSamLogoff r;
 174         NTSTATUS status;
 175
 176         /* In parameters */
 177         r.in.server_name = server_name;
 178         r.in.computer_name = computer_name;
 179         r.in.credential = credential;
 180         r.in.return_authenticator = return_authenticator;
 181         r.in.logon_level = logon_level;
 182         r.in.logon = logon;
 183
 184         if (DEBUGLEVEL >= 10) {
 185                 NDR_PRINT_IN_DEBUG(netr_LogonSamLogoff, &r);
 186         }
 187
 188         status = cli->dispatch(cli,
 189                                 mem_ctx,
 190                                 &ndr_table_netlogon,
 191                                 NDR_NETR_LOGONSAMLOGOFF,
 192                                 &r);
 193
 194         if (!NT_STATUS_IS_OK(status)) {
 195                 return status;
 196         }
 197
 198         if (DEBUGLEVEL >= 10) {
 199                 NDR_PRINT_OUT_DEBUG(netr_LogonSamLogoff, &r);
 200         }
 201
 202         if (NT_STATUS_IS_ERR(status)) {
 203                 return status;
 204         }
 205
 206         /* Return variables */
 207         if (return_authenticator && r.out.return_authenticator) {
 208                 *return_authenticator = *r.out.return_authenticator;
 209         }
 210
 211         /* Return result */
 212         return r.out.result;
 213 }
 214
 215 NTSTATUS rpccli_netr_ServerReqChallenge(struct rpc_pipe_client *cli,
 216                                         TALLOC_CTX *mem_ctx,
 217                                         const char *server_name /* [in] [unique,charset(UTF16)] */,
 218                                         const char *computer_name /* [in] [charset(UTF16)] */,
 219                                         struct netr_Credential *credentials /* [in] [ref] */,
 220                                         struct netr_Credential *return_credentials /* [out] [ref] */)
 221 {
 222         struct netr_ServerReqChallenge r;
 223         NTSTATUS status;
 224
 225         /* In parameters */
 226         r.in.server_name = server_name;
 227         r.in.computer_name = computer_name;
 228         r.in.credentials = credentials;
 229
 230         if (DEBUGLEVEL >= 10) {
 231                 NDR_PRINT_IN_DEBUG(netr_ServerReqChallenge, &r);
 232         }
 233
 234         status = cli->dispatch(cli,
 235                                 mem_ctx,
 236                                 &ndr_table_netlogon,
 237                                 NDR_NETR_SERVERREQCHALLENGE,
 238                                 &r);
 239
 240         if (!NT_STATUS_IS_OK(status)) {
 241                 return status;
 242         }
 243
 244         if (DEBUGLEVEL >= 10) {
 245                 NDR_PRINT_OUT_DEBUG(netr_ServerReqChallenge, &r);
 246         }
 247
 248         if (NT_STATUS_IS_ERR(status)) {
 249                 return status;
 250         }
 251
 252         /* Return variables */
 253         *return_credentials = *r.out.return_credentials;
 254
 255         /* Return result */
 256         return r.out.result;
 257 }
 258
 259 NTSTATUS rpccli_netr_ServerAuthenticate(struct rpc_pipe_client *cli,
 260                                         TALLOC_CTX *mem_ctx,
 261                                         const char *server_name /* [in] [unique,charset(UTF16)] */,
 262                                         const char *account_name /* [in] [charset(UTF16)] */,
 263                                         enum netr_SchannelType secure_channel_type /* [in]  */,
 264                                         const char *computer_name /* [in] [charset(UTF16)] */,
 265                                         struct netr_Credential *credentials /* [in] [ref] */,
 266                                         struct netr_Credential *return_credentials /* [out] [ref] */)
 267 {
 268         struct netr_ServerAuthenticate r;
 269         NTSTATUS status;
 270
 271         /* In parameters */
 272         r.in.server_name = server_name;
 273         r.in.account_name = account_name;
 274         r.in.secure_channel_type = secure_channel_type;
 275         r.in.computer_name = computer_name;
 276         r.in.credentials = credentials;
 277
 278         if (DEBUGLEVEL >= 10) {
 279                 NDR_PRINT_IN_DEBUG(netr_ServerAuthenticate, &r);
 280         }
 281
 282         status = cli->dispatch(cli,
 283                                 mem_ctx,
 284                                 &ndr_table_netlogon,
 285                                 NDR_NETR_SERVERAUTHENTICATE,
 286                                 &r);
 287
 288         if (!NT_STATUS_IS_OK(status)) {
 289                 return status;
 290         }
 291
 292         if (DEBUGLEVEL >= 10) {
 293                 NDR_PRINT_OUT_DEBUG(netr_ServerAuthenticate, &r);
 294         }
 295
 296         if (NT_STATUS_IS_ERR(status)) {
 297                 return status;
 298         }
 299
 300         /* Return variables */
 301         *return_credentials = *r.out.return_credentials;
 302
 303         /* Return result */
 304         return r.out.result;
 305 }
 306
 307 NTSTATUS rpccli_netr_ServerPasswordSet(struct rpc_pipe_client *cli,
 308                                        TALLOC_CTX *mem_ctx,
 309                                        const char *server_name /* [in] [unique,charset(UTF16)] */,
 310                                        const char *account_name /* [in] [charset(UTF16)] */,
 311                                        enum netr_SchannelType secure_channel_type /* [in]  */,
 312                                        const char *computer_name /* [in] [charset(UTF16)] */,
 313                                        struct netr_Authenticator *credential /* [in] [ref] */,
 314                                        struct netr_Authenticator *return_authenticator /* [out] [ref] */,
 315                                        struct samr_Password *new_password /* [in] [ref] */)
 316 {
 317         struct netr_ServerPasswordSet r;
 318         NTSTATUS status;
 319
 320         /* In parameters */
 321         r.in.server_name = server_name;
 322         r.in.account_name = account_name;
 323         r.in.secure_channel_type = secure_channel_type;
 324         r.in.computer_name = computer_name;
 325         r.in.credential = credential;
 326         r.in.new_password = new_password;
 327
 328         if (DEBUGLEVEL >= 10) {
 329                 NDR_PRINT_IN_DEBUG(netr_ServerPasswordSet, &r);
 330         }
 331
 332         status = cli->dispatch(cli,
 333                                 mem_ctx,
 334                                 &ndr_table_netlogon,
 335                                 NDR_NETR_SERVERPASSWORDSET,
 336                                 &r);
 337
 338         if (!NT_STATUS_IS_OK(status)) {
 339                 return status;
 340         }
 341
 342         if (DEBUGLEVEL >= 10) {
 343                 NDR_PRINT_OUT_DEBUG(netr_ServerPasswordSet, &r);
 344         }
 345
 346         if (NT_STATUS_IS_ERR(status)) {
 347                 return status;
 348         }
 349
 350         /* Return variables */
 351         *return_authenticator = *r.out.return_authenticator;
 352
 353         /* Return result */
 354         return r.out.result;
 355 }
 356
 357 NTSTATUS rpccli_netr_DatabaseDeltas(struct rpc_pipe_client *cli,
 358                                     TALLOC_CTX *mem_ctx,
 359                                     const char *logon_server /* [in] [charset(UTF16)] */,
 360                                     const char *computername /* [in] [charset(UTF16)] */,
 361                                     struct netr_Authenticator *credential /* [in] [ref] */,
 362                                     struct netr_Authenticator *return_authenticator /* [in,out] [ref] */,
 363                                     enum netr_SamDatabaseID database_id /* [in]  */,
 364                                     uint64_t *sequence_num /* [in,out] [ref] */,
 365                                     struct netr_DELTA_ENUM_ARRAY **delta_enum_array /* [out] [ref] */,
 366                                     uint32_t preferredmaximumlength /* [in]  */)
 367 {
 368         struct netr_DatabaseDeltas r;
 369         NTSTATUS status;
 370
 371         /* In parameters */
 372         r.in.logon_server = logon_server;
 373         r.in.computername = computername;
 374         r.in.credential = credential;
 375         r.in.return_authenticator = return_authenticator;
 376         r.in.database_id = database_id;
 377         r.in.sequence_num = sequence_num;
 378         r.in.preferredmaximumlength = preferredmaximumlength;
 379
 380         if (DEBUGLEVEL >= 10) {
 381                 NDR_PRINT_IN_DEBUG(netr_DatabaseDeltas, &r);
 382         }
 383
 384         status = cli->dispatch(cli,
 385                                 mem_ctx,
 386                                 &ndr_table_netlogon,
 387                                 NDR_NETR_DATABASEDELTAS,
 388                                 &r);
 389
 390         if (!NT_STATUS_IS_OK(status)) {
 391                 return status;
 392         }
 393
 394         if (DEBUGLEVEL >= 10) {
 395                 NDR_PRINT_OUT_DEBUG(netr_DatabaseDeltas, &r);
 396         }
 397
 398         if (NT_STATUS_IS_ERR(status)) {
 399                 return status;
 400         }
 401
 402         /* Return variables */
 403         *return_authenticator = *r.out.return_authenticator;
 404         *sequence_num = *r.out.sequence_num;
 405         *delta_enum_array = *r.out.delta_enum_array;
 406
 407         /* Return result */
 408         return r.out.result;
 409 }
 410
 411 NTSTATUS rpccli_netr_DatabaseSync(struct rpc_pipe_client *cli,
 412                                   TALLOC_CTX *mem_ctx,
 413                                   const char *logon_server /* [in] [charset(UTF16)] */,
 414                                   const char *computername /* [in] [charset(UTF16)] */,
 415                                   struct netr_Authenticator *credential /* [in] [ref] */,
 416                                   struct netr_Authenticator *return_authenticator /* [in,out] [ref] */,
 417                                   enum netr_SamDatabaseID database_id /* [in]  */,
 418                                   uint32_t *sync_context /* [in,out] [ref] */,
 419                                   struct netr_DELTA_ENUM_ARRAY **delta_enum_array /* [out] [ref] */,
 420                                   uint32_t preferredmaximumlength /* [in]  */)
 421 {
 422         struct netr_DatabaseSync r;
 423         NTSTATUS status;
 424
 425         /* In parameters */
 426         r.in.logon_server = logon_server;
 427         r.in.computername = computername;
 428         r.in.credential = credential;
 429         r.in.return_authenticator = return_authenticator;
 430         r.in.database_id = database_id;
 431         r.in.sync_context = sync_context;
 432         r.in.preferredmaximumlength = preferredmaximumlength;
 433
 434         if (DEBUGLEVEL >= 10) {
 435                 NDR_PRINT_IN_DEBUG(netr_DatabaseSync, &r);
 436         }
 437
 438         status = cli->dispatch(cli,
 439                                 mem_ctx,
 440                                 &ndr_table_netlogon,
 441                                 NDR_NETR_DATABASESYNC,
 442                                 &r);
 443
 444         if (!NT_STATUS_IS_OK(status)) {
 445                 return status;
 446         }
 447
 448         if (DEBUGLEVEL >= 10) {
 449                 NDR_PRINT_OUT_DEBUG(netr_DatabaseSync, &r);
 450         }
 451
 452         if (NT_STATUS_IS_ERR(status)) {
 453                 return status;
 454         }
 455
 456         /* Return variables */
 457         *return_authenticator = *r.out.return_authenticator;
 458         *sync_context = *r.out.sync_context;
 459         *delta_enum_array = *r.out.delta_enum_array;
 460
 461         /* Return result */
 462         return r.out.result;
 463 }
 464
 465 NTSTATUS rpccli_netr_AccountDeltas(struct rpc_pipe_client *cli,
 466                                    TALLOC_CTX *mem_ctx,
 467                                    const char *logon_server /* [in] [unique,charset(UTF16)] */,
 468                                    const char *computername /* [in] [charset(UTF16)] */,
 469                                    struct netr_Authenticator credential /* [in]  */,
 470                                    struct netr_Authenticator *return_authenticator /* [in,out] [ref] */,
 471                                    struct netr_UAS_INFO_0 uas /* [in]  */,
 472                                    uint32_t count /* [in]  */,
 473                                    uint32_t level /* [in]  */,
 474                                    uint32_t buffersize /* [in]  */,
 475                                    struct netr_AccountBuffer *buffer /* [out] [ref,subcontext(4)] */,
 476                                    uint32_t *count_returned /* [out] [ref] */,
 477                                    uint32_t *total_entries /* [out] [ref] */,
 478                                    struct netr_UAS_INFO_0 *recordid /* [out] [ref] */)
 479 {
 480         struct netr_AccountDeltas r;
 481         NTSTATUS status;
 482
 483         /* In parameters */
 484         r.in.logon_server = logon_server;
 485         r.in.computername = computername;
 486         r.in.credential = credential;
 487         r.in.return_authenticator = return_authenticator;
 488         r.in.uas = uas;
 489         r.in.count = count;
 490         r.in.level = level;
 491         r.in.buffersize = buffersize;
 492
 493         if (DEBUGLEVEL >= 10) {
 494                 NDR_PRINT_IN_DEBUG(netr_AccountDeltas, &r);
 495         }
 496
 497         status = cli->dispatch(cli,
 498                                 mem_ctx,
 499                                 &ndr_table_netlogon,
 500                                 NDR_NETR_ACCOUNTDELTAS,
 501                                 &r);
 502
 503         if (!NT_STATUS_IS_OK(status)) {
 504                 return status;
 505         }
 506
 507         if (DEBUGLEVEL >= 10) {
 508                 NDR_PRINT_OUT_DEBUG(netr_AccountDeltas, &r);
 509         }
 510
 511         if (NT_STATUS_IS_ERR(status)) {
 512                 return status;
 513         }
 514
 515         /* Return variables */
 516         *return_authenticator = *r.out.return_authenticator;
 517         *buffer = *r.out.buffer;
 518         *count_returned = *r.out.count_returned;
 519         *total_entries = *r.out.total_entries;
 520         *recordid = *r.out.recordid;
 521
 522         /* Return result */
 523         return r.out.result;
 524 }
 525
 526 NTSTATUS rpccli_netr_AccountSync(struct rpc_pipe_client *cli,
 527                                  TALLOC_CTX *mem_ctx,
 528                                  const char *logon_server /* [in] [unique,charset(UTF16)] */,
 529                                  const char *computername /* [in] [charset(UTF16)] */,
 530                                  struct netr_Authenticator credential /* [in]  */,
 531                                  struct netr_Authenticator *return_authenticator /* [in,out] [ref] */,
 532                                  uint32_t reference /* [in]  */,
 533                                  uint32_t level /* [in]  */,
 534                                  uint32_t buffersize /* [in]  */,
 535                                  struct netr_AccountBuffer *buffer /* [out] [ref,subcontext(4)] */,
 536                                  uint32_t *count_returned /* [out] [ref] */,
 537                                  uint32_t *total_entries /* [out] [ref] */,
 538                                  uint32_t *next_reference /* [out] [ref] */,
 539                                  struct netr_UAS_INFO_0 *recordid /* [in,out] [ref] */)
 540 {
 541         struct netr_AccountSync r;
 542         NTSTATUS status;
 543
 544         /* In parameters */
 545         r.in.logon_server = logon_server;
 546         r.in.computername = computername;
 547         r.in.credential = credential;
 548         r.in.return_authenticator = return_authenticator;
 549         r.in.reference = reference;
 550         r.in.level = level;
 551         r.in.buffersize = buffersize;
 552         r.in.recordid = recordid;
 553
 554         if (DEBUGLEVEL >= 10) {
 555                 NDR_PRINT_IN_DEBUG(netr_AccountSync, &r);
 556         }
 557
 558         status = cli->dispatch(cli,
 559                                 mem_ctx,
 560                                 &ndr_table_netlogon,
 561                                 NDR_NETR_ACCOUNTSYNC,
 562                                 &r);
 563
 564         if (!NT_STATUS_IS_OK(status)) {
 565                 return status;
 566         }
 567
 568         if (DEBUGLEVEL >= 10) {
 569                 NDR_PRINT_OUT_DEBUG(netr_AccountSync, &r);
 570         }
 571
 572         if (NT_STATUS_IS_ERR(status)) {
 573                 return status;
 574         }
 575
 576         /* Return variables */
 577         *return_authenticator = *r.out.return_authenticator;
 578         *buffer = *r.out.buffer;
 579         *count_returned = *r.out.count_returned;
 580         *total_entries = *r.out.total_entries;
 581         *next_reference = *r.out.next_reference;
 582         *recordid = *r.out.recordid;
 583
 584         /* Return result */
 585         return r.out.result;
 586 }
 587
 588 NTSTATUS rpccli_netr_GetDcName(struct rpc_pipe_client *cli,
 589                                TALLOC_CTX *mem_ctx,
 590                                const char *logon_server /* [in] [charset(UTF16)] */,
 591                                const char *domainname /* [in] [unique,charset(UTF16)] */,
 592                                const char **dcname /* [out] [ref,charset(UTF16)] */,
 593                                WERROR *werror)
 594 {
 595         struct netr_GetDcName r;
 596         NTSTATUS status;
 597
 598         /* In parameters */
 599         r.in.logon_server = logon_server;
 600         r.in.domainname = domainname;
 601
 602         if (DEBUGLEVEL >= 10) {
 603                 NDR_PRINT_IN_DEBUG(netr_GetDcName, &r);
 604         }
 605
 606         status = cli->dispatch(cli,
 607                                 mem_ctx,
 608                                 &ndr_table_netlogon,
 609                                 NDR_NETR_GETDCNAME,
 610                                 &r);
 611
 612         if (!NT_STATUS_IS_OK(status)) {
 613                 return status;
 614         }
 615
 616         if (DEBUGLEVEL >= 10) {
 617                 NDR_PRINT_OUT_DEBUG(netr_GetDcName, &r);
 618         }
 619
 620         if (NT_STATUS_IS_ERR(status)) {
 621                 return status;
 622         }
 623
 624         /* Return variables */
 625         *dcname = *r.out.dcname;
 626
 627         /* Return result */
 628         if (werror) {
 629                 *werror = r.out.result;
 630         }
 631
 632         return werror_to_ntstatus(r.out.result);
 633 }
 634
 635 NTSTATUS rpccli_netr_LogonControl(struct rpc_pipe_client *cli,
 636                                   TALLOC_CTX *mem_ctx,
 637                                   const char *logon_server /* [in] [unique,charset(UTF16)] */,
 638                                   enum netr_LogonControlCode function_code /* [in]  */,
 639                                   uint32_t level /* [in]  */,
 640                                   union netr_CONTROL_QUERY_INFORMATION *info /* [out] [ref,switch_is(level)] */,
 641                                   WERROR *werror)
 642 {
 643         struct netr_LogonControl r;
 644         NTSTATUS status;
 645
 646         /* In parameters */
 647         r.in.logon_server = logon_server;
 648         r.in.function_code = function_code;
 649         r.in.level = level;
 650
 651         if (DEBUGLEVEL >= 10) {
 652                 NDR_PRINT_IN_DEBUG(netr_LogonControl, &r);
 653         }
 654
 655         status = cli->dispatch(cli,
 656                                 mem_ctx,
 657                                 &ndr_table_netlogon,
 658                                 NDR_NETR_LOGONCONTROL,
 659                                 &r);
 660
 661         if (!NT_STATUS_IS_OK(status)) {
 662                 return status;
 663         }
 664
 665         if (DEBUGLEVEL >= 10) {
 666                 NDR_PRINT_OUT_DEBUG(netr_LogonControl, &r);
 667         }
 668
 669         if (NT_STATUS_IS_ERR(status)) {
 670                 return status;
 671         }
 672
 673         /* Return variables */
 674         *info = *r.out.info;
 675
 676         /* Return result */
 677         if (werror) {
 678                 *werror = r.out.result;
 679         }
 680
 681         return werror_to_ntstatus(r.out.result);
 682 }
 683
 684 NTSTATUS rpccli_netr_GetAnyDCName(struct rpc_pipe_client *cli,
 685                                   TALLOC_CTX *mem_ctx,
 686                                   const char *logon_server /* [in] [unique,charset(UTF16)] */,
 687                                   const char *domainname /* [in] [unique,charset(UTF16)] */,
 688                                   const char **dcname /* [out] [ref,charset(UTF16)] */,
 689                                   WERROR *werror)
 690 {
 691         struct netr_GetAnyDCName r;
 692         NTSTATUS status;
 693
 694         /* In parameters */
 695         r.in.logon_server = logon_server;
 696         r.in.domainname = domainname;
 697
 698         if (DEBUGLEVEL >= 10) {
 699                 NDR_PRINT_IN_DEBUG(netr_GetAnyDCName, &r);
 700         }
 701
 702         status = cli->dispatch(cli,
 703                                 mem_ctx,
 704                                 &ndr_table_netlogon,
 705                                 NDR_NETR_GETANYDCNAME,
 706                                 &r);
 707
 708         if (!NT_STATUS_IS_OK(status)) {
 709                 return status;
 710         }
 711
 712         if (DEBUGLEVEL >= 10) {
 713                 NDR_PRINT_OUT_DEBUG(netr_GetAnyDCName, &r);
 714         }
 715
 716         if (NT_STATUS_IS_ERR(status)) {
 717                 return status;
 718         }
 719
 720         /* Return variables */
 721         *dcname = *r.out.dcname;
 722
 723         /* Return result */
 724         if (werror) {
 725                 *werror = r.out.result;
 726         }
 727
 728         return werror_to_ntstatus(r.out.result);
 729 }
 730
 731 NTSTATUS rpccli_netr_LogonControl2(struct rpc_pipe_client *cli,
 732                                    TALLOC_CTX *mem_ctx,
 733                                    const char *logon_server /* [in] [unique,charset(UTF16)] */,
 734                                    enum netr_LogonControlCode function_code /* [in]  */,
 735                                    uint32_t level /* [in]  */,
 736                                    union netr_CONTROL_DATA_INFORMATION *data /* [in] [ref,switch_is(function_code)] */,
 737                                    union netr_CONTROL_QUERY_INFORMATION *query /* [out] [ref,switch_is(level)] */,
 738                                    WERROR *werror)
 739 {
 740         struct netr_LogonControl2 r;
 741         NTSTATUS status;
 742
 743         /* In parameters */
 744         r.in.logon_server = logon_server;
 745         r.in.function_code = function_code;
 746         r.in.level = level;
 747         r.in.data = data;
 748
 749         if (DEBUGLEVEL >= 10) {
 750                 NDR_PRINT_IN_DEBUG(netr_LogonControl2, &r);
 751         }
 752
 753         status = cli->dispatch(cli,
 754                                 mem_ctx,
 755                                 &ndr_table_netlogon,
 756                                 NDR_NETR_LOGONCONTROL2,
 757                                 &r);
 758
 759         if (!NT_STATUS_IS_OK(status)) {
 760                 return status;
 761         }
 762
 763         if (DEBUGLEVEL >= 10) {
 764                 NDR_PRINT_OUT_DEBUG(netr_LogonControl2, &r);
 765         }
 766
 767         if (NT_STATUS_IS_ERR(status)) {
 768                 return status;
 769         }
 770
 771         /* Return variables */
 772         *query = *r.out.query;
 773
 774         /* Return result */
 775         if (werror) {
 776                 *werror = r.out.result;
 777         }
 778
 779         return werror_to_ntstatus(r.out.result);
 780 }
 781
 782 NTSTATUS rpccli_netr_ServerAuthenticate2(struct rpc_pipe_client *cli,
 783                                          TALLOC_CTX *mem_ctx,
 784                                          const char *server_name /* [in] [unique,charset(UTF16)] */,
 785                                          const char *account_name /* [in] [charset(UTF16)] */,
 786                                          enum netr_SchannelType secure_channel_type /* [in]  */,
 787                                          const char *computer_name /* [in] [charset(UTF16)] */,
 788                                          struct netr_Credential *credentials /* [in] [ref] */,
 789                                          struct netr_Credential *return_credentials /* [out] [ref] */,
 790                                          uint32_t *negotiate_flags /* [in,out] [ref] */)
 791 {
 792         struct netr_ServerAuthenticate2 r;
 793         NTSTATUS status;
 794
 795         /* In parameters */
 796         r.in.server_name = server_name;
 797         r.in.account_name = account_name;
 798         r.in.secure_channel_type = secure_channel_type;
 799         r.in.computer_name = computer_name;
 800         r.in.credentials = credentials;
 801         r.in.negotiate_flags = negotiate_flags;
 802
 803         if (DEBUGLEVEL >= 10) {
 804                 NDR_PRINT_IN_DEBUG(netr_ServerAuthenticate2, &r);
 805         }
 806
 807         status = cli->dispatch(cli,
 808                                 mem_ctx,
 809                                 &ndr_table_netlogon,
 810                                 NDR_NETR_SERVERAUTHENTICATE2,
 811                                 &r);
 812
 813         if (!NT_STATUS_IS_OK(status)) {
 814                 return status;
 815         }
 816
 817         if (DEBUGLEVEL >= 10) {
 818                 NDR_PRINT_OUT_DEBUG(netr_ServerAuthenticate2, &r);
 819         }
 820
 821         if (NT_STATUS_IS_ERR(status)) {
 822                 return status;
 823         }
 824
 825         /* Return variables */
 826         *return_credentials = *r.out.return_credentials;
 827         *negotiate_flags = *r.out.negotiate_flags;
 828
 829         /* Return result */
 830         return r.out.result;
 831 }
 832
 833 NTSTATUS rpccli_netr_DatabaseSync2(struct rpc_pipe_client *cli,
 834                                    TALLOC_CTX *mem_ctx,
 835                                    const char *logon_server /* [in] [charset(UTF16)] */,
 836                                    const char *computername /* [in] [charset(UTF16)] */,
 837                                    struct netr_Authenticator *credential /* [in] [ref] */,
 838                                    struct netr_Authenticator *return_authenticator /* [in,out] [ref] */,
 839                                    enum netr_SamDatabaseID database_id /* [in]  */,
 840                                    uint16_t restart_state /* [in]  */,
 841                                    uint32_t *sync_context /* [in,out] [ref] */,
 842                                    struct netr_DELTA_ENUM_ARRAY **delta_enum_array /* [out] [ref] */,
 843                                    uint32_t preferredmaximumlength /* [in]  */)
 844 {
 845         struct netr_DatabaseSync2 r;
 846         NTSTATUS status;
 847
 848         /* In parameters */
 849         r.in.logon_server = logon_server;
 850         r.in.computername = computername;
 851         r.in.credential = credential;
 852         r.in.return_authenticator = return_authenticator;
 853         r.in.database_id = database_id;
 854         r.in.restart_state = restart_state;
 855         r.in.sync_context = sync_context;
 856         r.in.preferredmaximumlength = preferredmaximumlength;
 857
 858         if (DEBUGLEVEL >= 10) {
 859                 NDR_PRINT_IN_DEBUG(netr_DatabaseSync2, &r);
 860         }
 861
 862         status = cli->dispatch(cli,
 863                                 mem_ctx,
 864                                 &ndr_table_netlogon,
 865                                 NDR_NETR_DATABASESYNC2,
 866                                 &r);
 867
 868         if (!NT_STATUS_IS_OK(status)) {
 869                 return status;
 870         }
 871
 872         if (DEBUGLEVEL >= 10) {
 873                 NDR_PRINT_OUT_DEBUG(netr_DatabaseSync2, &r);
 874         }
 875
 876         if (NT_STATUS_IS_ERR(status)) {
 877                 return status;
 878         }
 879
 880         /* Return variables */
 881         *return_authenticator = *r.out.return_authenticator;
 882         *sync_context = *r.out.sync_context;
 883         *delta_enum_array = *r.out.delta_enum_array;
 884
 885         /* Return result */
 886         return r.out.result;
 887 }
 888
 889 NTSTATUS rpccli_netr_DatabaseRedo(struct rpc_pipe_client *cli,
 890                                   TALLOC_CTX *mem_ctx,
 891                                   const char *logon_server /* [in] [charset(UTF16)] */,
 892                                   const char *computername /* [in] [charset(UTF16)] */,
 893                                   struct netr_Authenticator *credential /* [in] [ref] */,
 894                                   struct netr_Authenticator *return_authenticator /* [in,out] [ref] */,
 895                                   struct netr_ChangeLogEntry change_log_entry /* [in] [subcontext_size(change_log_entry_size),subcontext(4)] */,
 896                                   uint32_t change_log_entry_size /* [in] [value(ndr_size_netr_ChangeLogEntry(&change_log_entry,ndr->iconv_convenience,ndr->flags))] */,
 897                                   struct netr_DELTA_ENUM_ARRAY **delta_enum_array /* [out] [ref] */)
 898 {
 899         struct netr_DatabaseRedo r;
 900         NTSTATUS status;
 901
 902         /* In parameters */
 903         r.in.logon_server = logon_server;
 904         r.in.computername = computername;
 905         r.in.credential = credential;
 906         r.in.return_authenticator = return_authenticator;
 907         r.in.change_log_entry = change_log_entry;
 908         r.in.change_log_entry_size = change_log_entry_size;
 909
 910         if (DEBUGLEVEL >= 10) {
 911                 NDR_PRINT_IN_DEBUG(netr_DatabaseRedo, &r);
 912         }
 913
 914         status = cli->dispatch(cli,
 915                                 mem_ctx,
 916                                 &ndr_table_netlogon,
 917                                 NDR_NETR_DATABASEREDO,
 918                                 &r);
 919
 920         if (!NT_STATUS_IS_OK(status)) {
 921                 return status;
 922         }
 923
 924         if (DEBUGLEVEL >= 10) {
 925                 NDR_PRINT_OUT_DEBUG(netr_DatabaseRedo, &r);
 926         }
 927
 928         if (NT_STATUS_IS_ERR(status)) {
 929                 return status;
 930         }
 931
 932         /* Return variables */
 933         *return_authenticator = *r.out.return_authenticator;
 934         *delta_enum_array = *r.out.delta_enum_array;
 935
 936         /* Return result */
 937         return r.out.result;
 938 }
 939
 940 NTSTATUS rpccli_netr_LogonControl2Ex(struct rpc_pipe_client *cli,
 941                                      TALLOC_CTX *mem_ctx,
 942                                      const char *logon_server /* [in] [unique,charset(UTF16)] */,
 943                                      enum netr_LogonControlCode function_code /* [in]  */,
 944                                      uint32_t level /* [in]  */,
 945                                      union netr_CONTROL_DATA_INFORMATION *data /* [in] [ref,switch_is(function_code)] */,
 946                                      union netr_CONTROL_QUERY_INFORMATION *query /* [out] [ref,switch_is(level)] */,
 947                                      WERROR *werror)
 948 {
 949         struct netr_LogonControl2Ex r;
 950         NTSTATUS status;
 951
 952         /* In parameters */
 953         r.in.logon_server = logon_server;
 954         r.in.function_code = function_code;
 955         r.in.level = level;
 956         r.in.data = data;
 957
 958         if (DEBUGLEVEL >= 10) {
 959                 NDR_PRINT_IN_DEBUG(netr_LogonControl2Ex, &r);
 960         }
 961
 962         status = cli->dispatch(cli,
 963                                 mem_ctx,
 964                                 &ndr_table_netlogon,
 965                                 NDR_NETR_LOGONCONTROL2EX,
 966                                 &r);
 967
 968         if (!NT_STATUS_IS_OK(status)) {
 969                 return status;
 970         }
 971
 972         if (DEBUGLEVEL >= 10) {
 973                 NDR_PRINT_OUT_DEBUG(netr_LogonControl2Ex, &r);
 974         }
 975
 976         if (NT_STATUS_IS_ERR(status)) {
 977                 return status;
 978         }
 979
 980         /* Return variables */
 981         *query = *r.out.query;
 982
 983         /* Return result */
 984         if (werror) {
 985                 *werror = r.out.result;
 986         }
 987
 988         return werror_to_ntstatus(r.out.result);
 989 }
 990
 991 NTSTATUS rpccli_netr_NetrEnumerateTrustedDomains(struct rpc_pipe_client *cli,
 992                                                  TALLOC_CTX *mem_ctx,
 993                                                  const char *server_name /* [in] [unique,charset(UTF16)] */,
 994                                                  struct netr_Blob *trusted_domains_blob /* [out] [ref] */,
 995                                                  WERROR *werror)
 996 {
 997         struct netr_NetrEnumerateTrustedDomains r;
 998         NTSTATUS status;
 999
1000         /* In parameters */
1001         r.in.server_name = server_name;
1002
1003         if (DEBUGLEVEL >= 10) {
1004                 NDR_PRINT_IN_DEBUG(netr_NetrEnumerateTrustedDomains, &r);
1005         }
1006
1007         status = cli->dispatch(cli,
1008                                 mem_ctx,
1009                                 &ndr_table_netlogon,
1010                                 NDR_NETR_NETRENUMERATETRUSTEDDOMAINS,
1011                                 &r);
1012
1013         if (!NT_STATUS_IS_OK(status)) {
1014                 return status;
1015         }
1016
1017         if (DEBUGLEVEL >= 10) {
1018                 NDR_PRINT_OUT_DEBUG(netr_NetrEnumerateTrustedDomains, &r);
1019         }
1020
1021         if (NT_STATUS_IS_ERR(status)) {
1022                 return status;
1023         }
1024
1025         /* Return variables */
1026         *trusted_domains_blob = *r.out.trusted_domains_blob;
1027
1028         /* Return result */
1029         if (werror) {
1030                 *werror = r.out.result;
1031         }
1032
1033         return werror_to_ntstatus(r.out.result);
1034 }
1035
1036 NTSTATUS rpccli_netr_DsRGetDCName(struct rpc_pipe_client *cli,
1037                                   TALLOC_CTX *mem_ctx,
1038                                   const char *server_unc /* [in] [unique,charset(UTF16)] */,
1039                                   const char *domain_name /* [in] [unique,charset(UTF16)] */,
1040                                   struct GUID *domain_guid /* [in] [unique] */,
1041                                   struct GUID *site_guid /* [in] [unique] */,
1042                                   uint32_t flags /* [in]  */,
1043                                   struct netr_DsRGetDCNameInfo **info /* [out] [ref] */,
1044                                   WERROR *werror)
1045 {
1046         struct netr_DsRGetDCName r;
1047         NTSTATUS status;
1048
1049         /* In parameters */
1050         r.in.server_unc = server_unc;
1051         r.in.domain_name = domain_name;
1052         r.in.domain_guid = domain_guid;
1053         r.in.site_guid = site_guid;
1054         r.in.flags = flags;
1055
1056         if (DEBUGLEVEL >= 10) {
1057                 NDR_PRINT_IN_DEBUG(netr_DsRGetDCName, &r);
1058         }
1059
1060         status = cli->dispatch(cli,
1061                                 mem_ctx,
1062                                 &ndr_table_netlogon,
1063                                 NDR_NETR_DSRGETDCNAME,
1064                                 &r);
1065
1066         if (!NT_STATUS_IS_OK(status)) {
1067                 return status;
1068         }
1069
1070         if (DEBUGLEVEL >= 10) {
1071                 NDR_PRINT_OUT_DEBUG(netr_DsRGetDCName, &r);
1072         }
1073
1074         if (NT_STATUS_IS_ERR(status)) {
1075                 return status;
1076         }
1077
1078         /* Return variables */
1079         *info = *r.out.info;
1080
1081         /* Return result */
1082         if (werror) {
1083                 *werror = r.out.result;
1084         }
1085
1086         return werror_to_ntstatus(r.out.result);
1087 }
1088
1089 NTSTATUS rpccli_netr_NETRLOGONDUMMYROUTINE1(struct rpc_pipe_client *cli,
1090                                             TALLOC_CTX *mem_ctx,
1091                                             WERROR *werror)
1092 {
1093         struct netr_NETRLOGONDUMMYROUTINE1 r;
1094         NTSTATUS status;
1095
1096         /* In parameters */
1097
1098         if (DEBUGLEVEL >= 10) {
1099                 NDR_PRINT_IN_DEBUG(netr_NETRLOGONDUMMYROUTINE1, &r);
1100         }
1101
1102         status = cli->dispatch(cli,
1103                                 mem_ctx,
1104                                 &ndr_table_netlogon,
1105                                 NDR_NETR_NETRLOGONDUMMYROUTINE1,
1106                                 &r);
1107
1108         if (!NT_STATUS_IS_OK(status)) {
1109                 return status;
1110         }
1111
1112         if (DEBUGLEVEL >= 10) {
1113                 NDR_PRINT_OUT_DEBUG(netr_NETRLOGONDUMMYROUTINE1, &r);
1114         }
1115
1116         if (NT_STATUS_IS_ERR(status)) {
1117                 return status;
1118         }
1119
1120         /* Return variables */
1121
1122         /* Return result */
1123         if (werror) {
1124                 *werror = r.out.result;
1125         }
1126
1127         return werror_to_ntstatus(r.out.result);
1128 }
1129
1130 NTSTATUS rpccli_netr_NETRLOGONSETSERVICEBITS(struct rpc_pipe_client *cli,
1131                                              TALLOC_CTX *mem_ctx,
1132                                              WERROR *werror)
1133 {
1134         struct netr_NETRLOGONSETSERVICEBITS r;
1135         NTSTATUS status;
1136
1137         /* In parameters */
1138
1139         if (DEBUGLEVEL >= 10) {
1140                 NDR_PRINT_IN_DEBUG(netr_NETRLOGONSETSERVICEBITS, &r);
1141         }
1142
1143         status = cli->dispatch(cli,
1144                                 mem_ctx,
1145                                 &ndr_table_netlogon,
1146                                 NDR_NETR_NETRLOGONSETSERVICEBITS,
1147                                 &r);
1148
1149         if (!NT_STATUS_IS_OK(status)) {
1150                 return status;
1151         }
1152
1153         if (DEBUGLEVEL >= 10) {
1154                 NDR_PRINT_OUT_DEBUG(netr_NETRLOGONSETSERVICEBITS, &r);
1155         }
1156
1157         if (NT_STATUS_IS_ERR(status)) {
1158                 return status;
1159         }
1160
1161         /* Return variables */
1162
1163         /* Return result */
1164         if (werror) {
1165                 *werror = r.out.result;
1166         }
1167
1168         return werror_to_ntstatus(r.out.result);
1169 }
1170
1171 NTSTATUS rpccli_netr_LogonGetTrustRid(struct rpc_pipe_client *cli,
1172                                       TALLOC_CTX *mem_ctx,
1173                                       const char *server_name /* [in] [unique,charset(UTF16)] */,
1174                                       const char *domain_name /* [in] [unique,charset(UTF16)] */,
1175                                       uint32_t *rid /* [out] [ref] */,
1176                                       WERROR *werror)
1177 {
1178         struct netr_LogonGetTrustRid r;
1179         NTSTATUS status;
1180
1181         /* In parameters */
1182         r.in.server_name = server_name;
1183         r.in.domain_name = domain_name;
1184
1185         if (DEBUGLEVEL >= 10) {
1186                 NDR_PRINT_IN_DEBUG(netr_LogonGetTrustRid, &r);
1187         }
1188
1189         status = cli->dispatch(cli,
1190                                 mem_ctx,
1191                                 &ndr_table_netlogon,
1192                                 NDR_NETR_LOGONGETTRUSTRID,
1193                                 &r);
1194
1195         if (!NT_STATUS_IS_OK(status)) {
1196                 return status;
1197         }
1198
1199         if (DEBUGLEVEL >= 10) {
1200                 NDR_PRINT_OUT_DEBUG(netr_LogonGetTrustRid, &r);
1201         }
1202
1203         if (NT_STATUS_IS_ERR(status)) {
1204                 return status;
1205         }
1206
1207         /* Return variables */
1208         *rid = *r.out.rid;
1209
1210         /* Return result */
1211         if (werror) {
1212                 *werror = r.out.result;
1213         }
1214
1215         return werror_to_ntstatus(r.out.result);
1216 }
1217
1218 NTSTATUS rpccli_netr_NETRLOGONCOMPUTESERVERDIGEST(struct rpc_pipe_client *cli,
1219                                                   TALLOC_CTX *mem_ctx,
1220                                                   WERROR *werror)
1221 {
1222         struct netr_NETRLOGONCOMPUTESERVERDIGEST r;
1223         NTSTATUS status;
1224
1225         /* In parameters */
1226
1227         if (DEBUGLEVEL >= 10) {
1228                 NDR_PRINT_IN_DEBUG(netr_NETRLOGONCOMPUTESERVERDIGEST, &r);
1229         }
1230
1231         status = cli->dispatch(cli,
1232                                 mem_ctx,
1233                                 &ndr_table_netlogon,
1234                                 NDR_NETR_NETRLOGONCOMPUTESERVERDIGEST,
1235                                 &r);
1236
1237         if (!NT_STATUS_IS_OK(status)) {
1238                 return status;
1239         }
1240
1241         if (DEBUGLEVEL >= 10) {
1242                 NDR_PRINT_OUT_DEBUG(netr_NETRLOGONCOMPUTESERVERDIGEST, &r);
1243         }
1244
1245         if (NT_STATUS_IS_ERR(status)) {
1246                 return status;
1247         }
1248
1249         /* Return variables */
1250
1251         /* Return result */
1252         if (werror) {
1253                 *werror = r.out.result;
1254         }
1255
1256         return werror_to_ntstatus(r.out.result);
1257 }
1258
1259 NTSTATUS rpccli_netr_NETRLOGONCOMPUTECLIENTDIGEST(struct rpc_pipe_client *cli,
1260                                                   TALLOC_CTX *mem_ctx,
1261                                                   WERROR *werror)
1262 {
1263         struct netr_NETRLOGONCOMPUTECLIENTDIGEST r;
1264         NTSTATUS status;
1265
1266         /* In parameters */
1267
1268         if (DEBUGLEVEL >= 10) {
1269                 NDR_PRINT_IN_DEBUG(netr_NETRLOGONCOMPUTECLIENTDIGEST, &r);
1270         }
1271
1272         status = cli->dispatch(cli,
1273                                 mem_ctx,
1274                                 &ndr_table_netlogon,
1275                                 NDR_NETR_NETRLOGONCOMPUTECLIENTDIGEST,
1276                                 &r);
1277
1278         if (!NT_STATUS_IS_OK(status)) {
1279                 return status;
1280         }
1281
1282         if (DEBUGLEVEL >= 10) {
1283                 NDR_PRINT_OUT_DEBUG(netr_NETRLOGONCOMPUTECLIENTDIGEST, &r);
1284         }
1285
1286         if (NT_STATUS_IS_ERR(status)) {
1287                 return status;
1288         }
1289
1290         /* Return variables */
1291
1292         /* Return result */
1293         if (werror) {
1294                 *werror = r.out.result;
1295         }
1296
1297         return werror_to_ntstatus(r.out.result);
1298 }
1299
1300 NTSTATUS rpccli_netr_ServerAuthenticate3(struct rpc_pipe_client *cli,
1301                                          TALLOC_CTX *mem_ctx,
1302                                          const char *server_name /* [in] [unique,charset(UTF16)] */,
1303                                          const char *account_name /* [in] [charset(UTF16)] */,
1304                                          enum netr_SchannelType secure_channel_type /* [in]  */,
1305                                          const char *computer_name /* [in] [charset(UTF16)] */,
1306                                          struct netr_Credential *credentials /* [in] [ref] */,
1307                                          struct netr_Credential *return_credentials /* [out] [ref] */,
1308                                          uint32_t *negotiate_flags /* [in,out] [ref] */,
1309                                          uint32_t *rid /* [out] [ref] */)
1310 {
1311         struct netr_ServerAuthenticate3 r;
1312         NTSTATUS status;
1313
1314         /* In parameters */
1315         r.in.server_name = server_name;
1316         r.in.account_name = account_name;
1317         r.in.secure_channel_type = secure_channel_type;
1318         r.in.computer_name = computer_name;
1319         r.in.credentials = credentials;
1320         r.in.negotiate_flags = negotiate_flags;
1321
1322         if (DEBUGLEVEL >= 10) {
1323                 NDR_PRINT_IN_DEBUG(netr_ServerAuthenticate3, &r);
1324         }
1325
1326         status = cli->dispatch(cli,
1327                                 mem_ctx,
1328                                 &ndr_table_netlogon,
1329                                 NDR_NETR_SERVERAUTHENTICATE3,
1330                                 &r);
1331
1332         if (!NT_STATUS_IS_OK(status)) {
1333                 return status;
1334         }
1335
1336         if (DEBUGLEVEL >= 10) {
1337                 NDR_PRINT_OUT_DEBUG(netr_ServerAuthenticate3, &r);
1338         }
1339
1340         if (NT_STATUS_IS_ERR(status)) {
1341                 return status;
1342         }
1343
1344         /* Return variables */
1345         *return_credentials = *r.out.return_credentials;
1346         *negotiate_flags = *r.out.negotiate_flags;
1347         *rid = *r.out.rid;
1348
1349         /* Return result */
1350         return r.out.result;
1351 }
1352
1353 NTSTATUS rpccli_netr_DsRGetDCNameEx(struct rpc_pipe_client *cli,
1354                                     TALLOC_CTX *mem_ctx,
1355                                     const char *server_unc /* [in] [unique,charset(UTF16)] */,
1356                                     const char *domain_name /* [in] [unique,charset(UTF16)] */,
1357                                     struct GUID *domain_guid /* [in] [unique] */,
1358                                     const char *site_name /* [in] [unique,charset(UTF16)] */,
1359                                     uint32_t flags /* [in]  */,
1360                                     struct netr_DsRGetDCNameInfo **info /* [out] [ref] */,
1361                                     WERROR *werror)
1362 {
1363         struct netr_DsRGetDCNameEx r;
1364         NTSTATUS status;
1365
1366         /* In parameters */
1367         r.in.server_unc = server_unc;
1368         r.in.domain_name = domain_name;
1369         r.in.domain_guid = domain_guid;
1370         r.in.site_name = site_name;
1371         r.in.flags = flags;
1372
1373         if (DEBUGLEVEL >= 10) {
1374                 NDR_PRINT_IN_DEBUG(netr_DsRGetDCNameEx, &r);
1375         }
1376
1377         status = cli->dispatch(cli,
1378                                 mem_ctx,
1379                                 &ndr_table_netlogon,
1380                                 NDR_NETR_DSRGETDCNAMEEX,
1381                                 &r);
1382
1383         if (!NT_STATUS_IS_OK(status)) {
1384                 return status;
1385         }
1386
1387         if (DEBUGLEVEL >= 10) {
1388                 NDR_PRINT_OUT_DEBUG(netr_DsRGetDCNameEx, &r);
1389         }
1390
1391         if (NT_STATUS_IS_ERR(status)) {
1392                 return status;
1393         }
1394
1395         /* Return variables */
1396         *info = *r.out.info;
1397
1398         /* Return result */
1399         if (werror) {
1400                 *werror = r.out.result;
1401         }
1402
1403         return werror_to_ntstatus(r.out.result);
1404 }
1405
1406 NTSTATUS rpccli_netr_DsRGetSiteName(struct rpc_pipe_client *cli,
1407                                     TALLOC_CTX *mem_ctx,
1408                                     const char *computer_name /* [in] [unique,charset(UTF16)] */,
1409                                     const char **site /* [out] [ref,charset(UTF16)] */,
1410                                     WERROR *werror)
1411 {
1412         struct netr_DsRGetSiteName r;
1413         NTSTATUS status;
1414
1415         /* In parameters */
1416         r.in.computer_name = computer_name;
1417
1418         if (DEBUGLEVEL >= 10) {
1419                 NDR_PRINT_IN_DEBUG(netr_DsRGetSiteName, &r);
1420         }
1421
1422         status = cli->dispatch(cli,
1423                                 mem_ctx,
1424                                 &ndr_table_netlogon,
1425                                 NDR_NETR_DSRGETSITENAME,
1426                                 &r);
1427
1428         if (!NT_STATUS_IS_OK(status)) {
1429                 return status;
1430         }
1431
1432         if (DEBUGLEVEL >= 10) {
1433                 NDR_PRINT_OUT_DEBUG(netr_DsRGetSiteName, &r);
1434         }
1435
1436         if (NT_STATUS_IS_ERR(status)) {
1437                 return status;
1438         }
1439
1440         /* Return variables */
1441         *site = *r.out.site;
1442
1443         /* Return result */
1444         if (werror) {
1445                 *werror = r.out.result;
1446         }
1447
1448         return werror_to_ntstatus(r.out.result);
1449 }
1450
1451 NTSTATUS rpccli_netr_LogonGetDomainInfo(struct rpc_pipe_client *cli,
1452                                         TALLOC_CTX *mem_ctx,
1453                                         const char *server_name /* [in] [charset(UTF16)] */,
1454                                         const char *computer_name /* [in] [unique,charset(UTF16)] */,
1455                                         struct netr_Authenticator *credential /* [in] [ref] */,
1456                                         struct netr_Authenticator *return_authenticator /* [in,out] [ref] */,
1457                                         uint32_t level /* [in]  */,
1458                                         union netr_DomainQuery query /* [in] [switch_is(level)] */,
1459                                         union netr_DomainInfo *info /* [out] [ref,switch_is(level)] */)
1460 {
1461         struct netr_LogonGetDomainInfo r;
1462         NTSTATUS status;
1463
1464         /* In parameters */
1465         r.in.server_name = server_name;
1466         r.in.computer_name = computer_name;
1467         r.in.credential = credential;
1468         r.in.return_authenticator = return_authenticator;
1469         r.in.level = level;
1470         r.in.query = query;
1471
1472         if (DEBUGLEVEL >= 10) {
1473                 NDR_PRINT_IN_DEBUG(netr_LogonGetDomainInfo, &r);
1474         }
1475
1476         status = cli->dispatch(cli,
1477                                 mem_ctx,
1478                                 &ndr_table_netlogon,
1479                                 NDR_NETR_LOGONGETDOMAININFO,
1480                                 &r);
1481
1482         if (!NT_STATUS_IS_OK(status)) {
1483                 return status;
1484         }
1485
1486         if (DEBUGLEVEL >= 10) {
1487                 NDR_PRINT_OUT_DEBUG(netr_LogonGetDomainInfo, &r);
1488         }
1489
1490         if (NT_STATUS_IS_ERR(status)) {
1491                 return status;
1492         }
1493
1494         /* Return variables */
1495         *return_authenticator = *r.out.return_authenticator;
1496         *info = *r.out.info;
1497
1498         /* Return result */
1499         return r.out.result;
1500 }
1501
1502 NTSTATUS rpccli_netr_ServerPasswordSet2(struct rpc_pipe_client *cli,
1503                                         TALLOC_CTX *mem_ctx,
1504                                         const char *server_name /* [in] [unique,charset(UTF16)] */,
1505                                         const char *account_name /* [in] [charset(UTF16)] */,
1506                                         enum netr_SchannelType secure_channel_type /* [in]  */,
1507                                         const char *computer_name /* [in] [charset(UTF16)] */,
1508                                         struct netr_Authenticator *credential /* [in] [ref] */,
1509                                         struct netr_Authenticator *return_authenticator /* [out] [ref] */,
1510                                         struct netr_CryptPassword *new_password /* [in] [ref] */)
1511 {
1512         struct netr_ServerPasswordSet2 r;
1513         NTSTATUS status;
1514
1515         /* In parameters */
1516         r.in.server_name = server_name;
1517         r.in.account_name = account_name;
1518         r.in.secure_channel_type = secure_channel_type;
1519         r.in.computer_name = computer_name;
1520         r.in.credential = credential;
1521         r.in.new_password = new_password;
1522
1523         if (DEBUGLEVEL >= 10) {
1524                 NDR_PRINT_IN_DEBUG(netr_ServerPasswordSet2, &r);
1525         }
1526
1527         status = cli->dispatch(cli,
1528                                 mem_ctx,
1529                                 &ndr_table_netlogon,
1530                                 NDR_NETR_SERVERPASSWORDSET2,
1531                                 &r);
1532
1533         if (!NT_STATUS_IS_OK(status)) {
1534                 return status;
1535         }
1536
1537         if (DEBUGLEVEL >= 10) {
1538                 NDR_PRINT_OUT_DEBUG(netr_ServerPasswordSet2, &r);
1539         }
1540
1541         if (NT_STATUS_IS_ERR(status)) {
1542                 return status;
1543         }
1544
1545         /* Return variables */
1546         *return_authenticator = *r.out.return_authenticator;
1547
1548         /* Return result */
1549         return r.out.result;
1550 }
1551
1552 NTSTATUS rpccli_netr_ServerPasswordGet(struct rpc_pipe_client *cli,
1553                                        TALLOC_CTX *mem_ctx,
1554                                        const char *server_name /* [in] [unique,charset(UTF16)] */,
1555                                        const char *account_name /* [in] [charset(UTF16)] */,
1556                                        enum netr_SchannelType secure_channel_type /* [in]  */,
1557                                        const char *computer_name /* [in] [charset(UTF16)] */,
1558                                        struct netr_Authenticator *credential /* [in] [ref] */,
1559                                        struct netr_Authenticator *return_authenticator /* [out] [ref] */,
1560                                        struct samr_Password *password /* [out] [ref] */,
1561                                        WERROR *werror)
1562 {
1563         struct netr_ServerPasswordGet r;
1564         NTSTATUS status;
1565
1566         /* In parameters */
1567         r.in.server_name = server_name;
1568         r.in.account_name = account_name;
1569         r.in.secure_channel_type = secure_channel_type;
1570         r.in.computer_name = computer_name;
1571         r.in.credential = credential;
1572
1573         if (DEBUGLEVEL >= 10) {
1574                 NDR_PRINT_IN_DEBUG(netr_ServerPasswordGet, &r);
1575         }
1576
1577         status = cli->dispatch(cli,
1578                                 mem_ctx,
1579                                 &ndr_table_netlogon,
1580                                 NDR_NETR_SERVERPASSWORDGET,
1581                                 &r);
1582
1583         if (!NT_STATUS_IS_OK(status)) {
1584                 return status;
1585         }
1586
1587         if (DEBUGLEVEL >= 10) {
1588                 NDR_PRINT_OUT_DEBUG(netr_ServerPasswordGet, &r);
1589         }
1590
1591         if (NT_STATUS_IS_ERR(status)) {
1592                 return status;
1593         }
1594
1595         /* Return variables */
1596         *return_authenticator = *r.out.return_authenticator;
1597         *password = *r.out.password;
1598
1599         /* Return result */
1600         if (werror) {
1601                 *werror = r.out.result;
1602         }
1603
1604         return werror_to_ntstatus(r.out.result);
1605 }
1606
1607 NTSTATUS rpccli_netr_NETRLOGONSENDTOSAM(struct rpc_pipe_client *cli,
1608                                         TALLOC_CTX *mem_ctx,
1609                                         WERROR *werror)
1610 {
1611         struct netr_NETRLOGONSENDTOSAM r;
1612         NTSTATUS status;
1613
1614         /* In parameters */
1615
1616         if (DEBUGLEVEL >= 10) {
1617                 NDR_PRINT_IN_DEBUG(netr_NETRLOGONSENDTOSAM, &r);
1618         }
1619
1620         status = cli->dispatch(cli,
1621                                 mem_ctx,
1622                                 &ndr_table_netlogon,
1623                                 NDR_NETR_NETRLOGONSENDTOSAM,
1624                                 &r);
1625
1626         if (!NT_STATUS_IS_OK(status)) {
1627                 return status;
1628         }
1629
1630         if (DEBUGLEVEL >= 10) {
1631                 NDR_PRINT_OUT_DEBUG(netr_NETRLOGONSENDTOSAM, &r);
1632         }
1633
1634         if (NT_STATUS_IS_ERR(status)) {
1635                 return status;
1636         }
1637
1638         /* Return variables */
1639
1640         /* Return result */
1641         if (werror) {
1642                 *werror = r.out.result;
1643         }
1644
1645         return werror_to_ntstatus(r.out.result);
1646 }
1647
1648 NTSTATUS rpccli_netr_DsRAddressToSitenamesW(struct rpc_pipe_client *cli,
1649                                             TALLOC_CTX *mem_ctx,
1650                                             const char *server_name /* [in] [unique,charset(UTF16)] */,
1651                                             uint32_t count /* [in] [range(0,32000)] */,
1652                                             struct netr_DsRAddress *addresses /* [in] [ref,size_is(count)] */,
1653                                             struct netr_DsRAddressToSitenamesWCtr **ctr /* [out] [ref] */,
1654                                             WERROR *werror)
1655 {
1656         struct netr_DsRAddressToSitenamesW r;
1657         NTSTATUS status;
1658
1659         /* In parameters */
1660         r.in.server_name = server_name;
1661         r.in.count = count;
1662         r.in.addresses = addresses;
1663
1664         if (DEBUGLEVEL >= 10) {
1665                 NDR_PRINT_IN_DEBUG(netr_DsRAddressToSitenamesW, &r);
1666         }
1667
1668         status = cli->dispatch(cli,
1669                                 mem_ctx,
1670                                 &ndr_table_netlogon,
1671                                 NDR_NETR_DSRADDRESSTOSITENAMESW,
1672                                 &r);
1673
1674         if (!NT_STATUS_IS_OK(status)) {
1675                 return status;
1676         }
1677
1678         if (DEBUGLEVEL >= 10) {
1679                 NDR_PRINT_OUT_DEBUG(netr_DsRAddressToSitenamesW, &r);
1680         }
1681
1682         if (NT_STATUS_IS_ERR(status)) {
1683                 return status;
1684         }
1685
1686         /* Return variables */
1687         *ctr = *r.out.ctr;
1688
1689         /* Return result */
1690         if (werror) {
1691                 *werror = r.out.result;
1692         }
1693
1694         return werror_to_ntstatus(r.out.result);
1695 }
1696
1697 NTSTATUS rpccli_netr_DsRGetDCNameEx2(struct rpc_pipe_client *cli,
1698                                      TALLOC_CTX *mem_ctx,
1699                                      const char *server_unc /* [in] [unique,charset(UTF16)] */,
1700                                      const char *client_account /* [in] [unique,charset(UTF16)] */,
1701                                      uint32_t mask /* [in]  */,
1702                                      const char *domain_name /* [in] [unique,charset(UTF16)] */,
1703                                      struct GUID *domain_guid /* [in] [unique] */,
1704                                      const char *site_name /* [in] [unique,charset(UTF16)] */,
1705                                      uint32_t flags /* [in]  */,
1706                                      struct netr_DsRGetDCNameInfo **info /* [out] [ref] */,
1707                                      WERROR *werror)
1708 {
1709         struct netr_DsRGetDCNameEx2 r;
1710         NTSTATUS status;
1711
1712         /* In parameters */
1713         r.in.server_unc = server_unc;
1714         r.in.client_account = client_account;
1715         r.in.mask = mask;
1716         r.in.domain_name = domain_name;
1717         r.in.domain_guid = domain_guid;
1718         r.in.site_name = site_name;
1719         r.in.flags = flags;
1720
1721         if (DEBUGLEVEL >= 10) {
1722                 NDR_PRINT_IN_DEBUG(netr_DsRGetDCNameEx2, &r);
1723         }
1724
1725         status = cli->dispatch(cli,
1726                                 mem_ctx,
1727                                 &ndr_table_netlogon,
1728                                 NDR_NETR_DSRGETDCNAMEEX2,
1729                                 &r);
1730
1731         if (!NT_STATUS_IS_OK(status)) {
1732                 return status;
1733         }
1734
1735         if (DEBUGLEVEL >= 10) {
1736                 NDR_PRINT_OUT_DEBUG(netr_DsRGetDCNameEx2, &r);
1737         }
1738
1739         if (NT_STATUS_IS_ERR(status)) {
1740                 return status;
1741         }
1742
1743         /* Return variables */
1744         *info = *r.out.info;
1745
1746         /* Return result */
1747         if (werror) {
1748                 *werror = r.out.result;
1749         }
1750
1751         return werror_to_ntstatus(r.out.result);
1752 }
1753
1754 NTSTATUS rpccli_netr_NETRLOGONGETTIMESERVICEPARENTDOMAIN(struct rpc_pipe_client *cli,
1755                                                          TALLOC_CTX *mem_ctx,
1756                                                          WERROR *werror)
1757 {
1758         struct netr_NETRLOGONGETTIMESERVICEPARENTDOMAIN r;
1759         NTSTATUS status;
1760
1761         /* In parameters */
1762
1763         if (DEBUGLEVEL >= 10) {
1764                 NDR_PRINT_IN_DEBUG(netr_NETRLOGONGETTIMESERVICEPARENTDOMAIN, &r);
1765         }
1766
1767         status = cli->dispatch(cli,
1768                                 mem_ctx,
1769                                 &ndr_table_netlogon,
1770                                 NDR_NETR_NETRLOGONGETTIMESERVICEPARENTDOMAIN,
1771                                 &r);
1772
1773         if (!NT_STATUS_IS_OK(status)) {
1774                 return status;
1775         }
1776
1777         if (DEBUGLEVEL >= 10) {
1778                 NDR_PRINT_OUT_DEBUG(netr_NETRLOGONGETTIMESERVICEPARENTDOMAIN, &r);
1779         }
1780
1781         if (NT_STATUS_IS_ERR(status)) {
1782                 return status;
1783         }
1784
1785         /* Return variables */
1786
1787         /* Return result */
1788         if (werror) {
1789                 *werror = r.out.result;
1790         }
1791
1792         return werror_to_ntstatus(r.out.result);
1793 }
1794
1795 NTSTATUS rpccli_netr_NetrEnumerateTrustedDomainsEx(struct rpc_pipe_client *cli,
1796                                                    TALLOC_CTX *mem_ctx,
1797                                                    const char *server_name /* [in] [unique,charset(UTF16)] */,
1798                                                    struct netr_DomainTrustList *dom_trust_list /* [out] [ref] */,
1799                                                    WERROR *werror)
1800 {
1801         struct netr_NetrEnumerateTrustedDomainsEx r;
1802         NTSTATUS status;
1803
1804         /* In parameters */
1805         r.in.server_name = server_name;
1806
1807         if (DEBUGLEVEL >= 10) {
1808                 NDR_PRINT_IN_DEBUG(netr_NetrEnumerateTrustedDomainsEx, &r);
1809         }
1810
1811         status = cli->dispatch(cli,
1812                                 mem_ctx,
1813                                 &ndr_table_netlogon,
1814                                 NDR_NETR_NETRENUMERATETRUSTEDDOMAINSEX,
1815                                 &r);
1816
1817         if (!NT_STATUS_IS_OK(status)) {
1818                 return status;
1819         }
1820
1821         if (DEBUGLEVEL >= 10) {
1822                 NDR_PRINT_OUT_DEBUG(netr_NetrEnumerateTrustedDomainsEx, &r);
1823         }
1824
1825         if (NT_STATUS_IS_ERR(status)) {
1826                 return status;
1827         }
1828
1829         /* Return variables */
1830         *dom_trust_list = *r.out.dom_trust_list;
1831
1832         /* Return result */
1833         if (werror) {
1834                 *werror = r.out.result;
1835         }
1836
1837         return werror_to_ntstatus(r.out.result);
1838 }
1839
1840 NTSTATUS rpccli_netr_DsRAddressToSitenamesExW(struct rpc_pipe_client *cli,
1841                                               TALLOC_CTX *mem_ctx,
1842                                               const char *server_name /* [in] [unique,charset(UTF16)] */,
1843                                               uint32_t count /* [in] [range(0,32000)] */,
1844                                               struct netr_DsRAddress *addresses /* [in] [ref,size_is(count)] */,
1845                                               struct netr_DsRAddressToSitenamesExWCtr **ctr /* [out] [ref] */,
1846                                               WERROR *werror)
1847 {
1848         struct netr_DsRAddressToSitenamesExW r;
1849         NTSTATUS status;
1850
1851         /* In parameters */
1852         r.in.server_name = server_name;
1853         r.in.count = count;
1854         r.in.addresses = addresses;
1855
1856         if (DEBUGLEVEL >= 10) {
1857                 NDR_PRINT_IN_DEBUG(netr_DsRAddressToSitenamesExW, &r);
1858         }
1859
1860         status = cli->dispatch(cli,
1861                                 mem_ctx,
1862                                 &ndr_table_netlogon,
1863                                 NDR_NETR_DSRADDRESSTOSITENAMESEXW,
1864                                 &r);
1865
1866         if (!NT_STATUS_IS_OK(status)) {
1867                 return status;
1868         }
1869
1870         if (DEBUGLEVEL >= 10) {
1871                 NDR_PRINT_OUT_DEBUG(netr_DsRAddressToSitenamesExW, &r);
1872         }
1873
1874         if (NT_STATUS_IS_ERR(status)) {
1875                 return status;
1876         }
1877
1878         /* Return variables */
1879         *ctr = *r.out.ctr;
1880
1881         /* Return result */
1882         if (werror) {
1883                 *werror = r.out.result;
1884         }
1885
1886         return werror_to_ntstatus(r.out.result);
1887 }
1888
1889 NTSTATUS rpccli_netr_DsrGetDcSiteCoverageW(struct rpc_pipe_client *cli,
1890                                            TALLOC_CTX *mem_ctx,
1891                                            const char *server_name /* [in] [unique,charset(UTF16)] */,
1892                                            struct DcSitesCtr **ctr /* [out] [ref] */,
1893                                            WERROR *werror)
1894 {
1895         struct netr_DsrGetDcSiteCoverageW r;
1896         NTSTATUS status;
1897
1898         /* In parameters */
1899         r.in.server_name = server_name;
1900
1901         if (DEBUGLEVEL >= 10) {
1902                 NDR_PRINT_IN_DEBUG(netr_DsrGetDcSiteCoverageW, &r);
1903         }
1904
1905         status = cli->dispatch(cli,
1906                                 mem_ctx,
1907                                 &ndr_table_netlogon,
1908                                 NDR_NETR_DSRGETDCSITECOVERAGEW,
1909                                 &r);
1910
1911         if (!NT_STATUS_IS_OK(status)) {
1912                 return status;
1913         }
1914
1915         if (DEBUGLEVEL >= 10) {
1916                 NDR_PRINT_OUT_DEBUG(netr_DsrGetDcSiteCoverageW, &r);
1917         }
1918
1919         if (NT_STATUS_IS_ERR(status)) {
1920                 return status;
1921         }
1922
1923         /* Return variables */
1924         *ctr = *r.out.ctr;
1925
1926         /* Return result */
1927         if (werror) {
1928                 *werror = r.out.result;
1929         }
1930
1931         return werror_to_ntstatus(r.out.result);
1932 }
1933
1934 NTSTATUS rpccli_netr_LogonSamLogonEx(struct rpc_pipe_client *cli,
1935                                      TALLOC_CTX *mem_ctx,
1936                                      const char *server_name /* [in] [unique,charset(UTF16)] */,
1937                                      const char *computer_name /* [in] [unique,charset(UTF16)] */,
1938                                      enum netr_LogonInfoClass logon_level /* [in]  */,
1939                                      union netr_LogonLevel *logon /* [in] [ref,switch_is(logon_level)] */,
1940                                      uint16_t validation_level /* [in]  */,
1941                                      union netr_Validation *validation /* [out] [ref,switch_is(validation_level)] */,
1942                                      uint8_t *authoritative /* [out] [ref] */,
1943                                      uint32_t *flags /* [in,out] [ref] */)
1944 {
1945         struct netr_LogonSamLogonEx r;
1946         NTSTATUS status;
1947
1948         /* In parameters */
1949         r.in.server_name = server_name;
1950         r.in.computer_name = computer_name;
1951         r.in.logon_level = logon_level;
1952         r.in.logon = logon;
1953         r.in.validation_level = validation_level;
1954         r.in.flags = flags;
1955
1956         if (DEBUGLEVEL >= 10) {
1957                 NDR_PRINT_IN_DEBUG(netr_LogonSamLogonEx, &r);
1958         }
1959
1960         status = cli->dispatch(cli,
1961                                 mem_ctx,
1962                                 &ndr_table_netlogon,
1963                                 NDR_NETR_LOGONSAMLOGONEX,
1964                                 &r);
1965
1966         if (!NT_STATUS_IS_OK(status)) {
1967                 return status;
1968         }
1969
1970         if (DEBUGLEVEL >= 10) {
1971                 NDR_PRINT_OUT_DEBUG(netr_LogonSamLogonEx, &r);
1972         }
1973
1974         if (NT_STATUS_IS_ERR(status)) {
1975                 return status;
1976         }
1977
1978         /* Return variables */
1979         *validation = *r.out.validation;
1980         *authoritative = *r.out.authoritative;
1981         *flags = *r.out.flags;
1982
1983         /* Return result */
1984         return r.out.result;
1985 }
1986
1987 NTSTATUS rpccli_netr_DsrEnumerateDomainTrusts(struct rpc_pipe_client *cli,
1988                                               TALLOC_CTX *mem_ctx,
1989                                               const char *server_name /* [in] [unique,charset(UTF16)] */,
1990                                               uint32_t trust_flags /* [in]  */,
1991                                               struct netr_DomainTrustList *trusts /* [out] [ref] */,
1992                                               WERROR *werror)
1993 {
1994         struct netr_DsrEnumerateDomainTrusts r;
1995         NTSTATUS status;
1996
1997         /* In parameters */
1998         r.in.server_name = server_name;
1999         r.in.trust_flags = trust_flags;
2000
2001         if (DEBUGLEVEL >= 10) {
2002                 NDR_PRINT_IN_DEBUG(netr_DsrEnumerateDomainTrusts, &r);
2003         }
2004
2005         status = cli->dispatch(cli,
2006                                 mem_ctx,
2007                                 &ndr_table_netlogon,
2008                                 NDR_NETR_DSRENUMERATEDOMAINTRUSTS,
2009                                 &r);
2010
2011         if (!NT_STATUS_IS_OK(status)) {
2012                 return status;
2013         }
2014
2015         if (DEBUGLEVEL >= 10) {
2016                 NDR_PRINT_OUT_DEBUG(netr_DsrEnumerateDomainTrusts, &r);
2017         }
2018
2019         if (NT_STATUS_IS_ERR(status)) {
2020                 return status;
2021         }
2022
2023         /* Return variables */
2024         *trusts = *r.out.trusts;
2025
2026         /* Return result */
2027         if (werror) {
2028                 *werror = r.out.result;
2029         }
2030
2031         return werror_to_ntstatus(r.out.result);
2032 }
2033
2034 NTSTATUS rpccli_netr_DsrDeregisterDNSHostRecords(struct rpc_pipe_client *cli,
2035                                                  TALLOC_CTX *mem_ctx,
2036                                                  const char *server_name /* [in] [unique,charset(UTF16)] */,
2037                                                  const char *domain /* [in] [unique,charset(UTF16)] */,
2038                                                  struct GUID *domain_guid /* [in] [unique] */,
2039                                                  struct GUID *dsa_guid /* [in] [unique] */,
2040                                                  const char *dns_host /* [in] [ref,charset(UTF16)] */,
2041                                                  WERROR *werror)
2042 {
2043         struct netr_DsrDeregisterDNSHostRecords r;
2044         NTSTATUS status;
2045
2046         /* In parameters */
2047         r.in.server_name = server_name;
2048         r.in.domain = domain;
2049         r.in.domain_guid = domain_guid;
2050         r.in.dsa_guid = dsa_guid;
2051         r.in.dns_host = dns_host;
2052
2053         if (DEBUGLEVEL >= 10) {
2054                 NDR_PRINT_IN_DEBUG(netr_DsrDeregisterDNSHostRecords, &r);
2055         }
2056
2057         status = cli->dispatch(cli,
2058                                 mem_ctx,
2059                                 &ndr_table_netlogon,
2060                                 NDR_NETR_DSRDEREGISTERDNSHOSTRECORDS,
2061                                 &r);
2062
2063         if (!NT_STATUS_IS_OK(status)) {
2064                 return status;
2065         }
2066
2067         if (DEBUGLEVEL >= 10) {
2068                 NDR_PRINT_OUT_DEBUG(netr_DsrDeregisterDNSHostRecords, &r);
2069         }
2070
2071         if (NT_STATUS_IS_ERR(status)) {
2072                 return status;
2073         }
2074
2075         /* Return variables */
2076
2077         /* Return result */
2078         if (werror) {
2079                 *werror = r.out.result;
2080         }
2081
2082         return werror_to_ntstatus(r.out.result);
2083 }
2084
2085 NTSTATUS rpccli_netr_ServerTrustPasswordsGet(struct rpc_pipe_client *cli,
2086                                              TALLOC_CTX *mem_ctx,
2087                                              const char *server_name /* [in] [unique,charset(UTF16)] */,
2088                                              const char *account_name /* [in] [charset(UTF16)] */,
2089                                              enum netr_SchannelType secure_channel_type /* [in]  */,
2090                                              const char *computer_name /* [in] [charset(UTF16)] */,
2091                                              struct netr_Authenticator *credential /* [in] [ref] */,
2092                                              struct netr_Authenticator *return_authenticator /* [out] [ref] */,
2093                                              struct samr_Password *password /* [out] [ref] */,
2094                                              struct samr_Password *password2 /* [out] [ref] */)
2095 {
2096         struct netr_ServerTrustPasswordsGet r;
2097         NTSTATUS status;
2098
2099         /* In parameters */
2100         r.in.server_name = server_name;
2101         r.in.account_name = account_name;
2102         r.in.secure_channel_type = secure_channel_type;
2103         r.in.computer_name = computer_name;
2104         r.in.credential = credential;
2105
2106         if (DEBUGLEVEL >= 10) {
2107                 NDR_PRINT_IN_DEBUG(netr_ServerTrustPasswordsGet, &r);
2108         }
2109
2110         status = cli->dispatch(cli,
2111                                 mem_ctx,
2112                                 &ndr_table_netlogon,
2113                                 NDR_NETR_SERVERTRUSTPASSWORDSGET,
2114                                 &r);
2115
2116         if (!NT_STATUS_IS_OK(status)) {
2117                 return status;
2118         }
2119
2120         if (DEBUGLEVEL >= 10) {
2121                 NDR_PRINT_OUT_DEBUG(netr_ServerTrustPasswordsGet, &r);
2122         }
2123
2124         if (NT_STATUS_IS_ERR(status)) {
2125                 return status;
2126         }
2127
2128         /* Return variables */
2129         *return_authenticator = *r.out.return_authenticator;
2130         *password = *r.out.password;
2131         *password2 = *r.out.password2;
2132
2133         /* Return result */
2134         return r.out.result;
2135 }
2136
2137 NTSTATUS rpccli_netr_DsRGetForestTrustInformation(struct rpc_pipe_client *cli,
2138                                                   TALLOC_CTX *mem_ctx,
2139                                                   const char *server_name /* [in] [unique,charset(UTF16)] */,
2140                                                   const char *trusted_domain_name /* [in] [unique,charset(UTF16)] */,
2141                                                   uint32_t flags /* [in]  */,
2142                                                   struct lsa_ForestTrustInformation **forest_trust_info /* [out] [ref] */,
2143                                                   WERROR *werror)
2144 {
2145         struct netr_DsRGetForestTrustInformation r;
2146         NTSTATUS status;
2147
2148         /* In parameters */
2149         r.in.server_name = server_name;
2150         r.in.trusted_domain_name = trusted_domain_name;
2151         r.in.flags = flags;
2152
2153         if (DEBUGLEVEL >= 10) {
2154                 NDR_PRINT_IN_DEBUG(netr_DsRGetForestTrustInformation, &r);
2155         }
2156
2157         status = cli->dispatch(cli,
2158                                 mem_ctx,
2159                                 &ndr_table_netlogon,
2160                                 NDR_NETR_DSRGETFORESTTRUSTINFORMATION,
2161                                 &r);
2162
2163         if (!NT_STATUS_IS_OK(status)) {
2164                 return status;
2165         }
2166
2167         if (DEBUGLEVEL >= 10) {
2168                 NDR_PRINT_OUT_DEBUG(netr_DsRGetForestTrustInformation, &r);
2169         }
2170
2171         if (NT_STATUS_IS_ERR(status)) {
2172                 return status;
2173         }
2174
2175         /* Return variables */
2176         *forest_trust_info = *r.out.forest_trust_info;
2177
2178         /* Return result */
2179         if (werror) {
2180                 *werror = r.out.result;
2181         }
2182
2183         return werror_to_ntstatus(r.out.result);
2184 }
2185
2186 NTSTATUS rpccli_netr_GetForestTrustInformation(struct rpc_pipe_client *cli,
2187                                                TALLOC_CTX *mem_ctx,
2188                                                const char *server_name /* [in] [unique,charset(UTF16)] */,
2189                                                const char *trusted_domain_name /* [in] [ref,charset(UTF16)] */,
2190                                                struct netr_Authenticator *credential /* [in] [ref] */,
2191                                                struct netr_Authenticator *return_authenticator /* [out] [ref] */,
2192                                                uint32_t flags /* [in]  */,
2193                                                struct lsa_ForestTrustInformation **forest_trust_info /* [out] [ref] */,
2194                                                WERROR *werror)
2195 {
2196         struct netr_GetForestTrustInformation r;
2197         NTSTATUS status;
2198
2199         /* In parameters */
2200         r.in.server_name = server_name;
2201         r.in.trusted_domain_name = trusted_domain_name;
2202         r.in.credential = credential;
2203         r.in.flags = flags;
2204
2205         if (DEBUGLEVEL >= 10) {
2206                 NDR_PRINT_IN_DEBUG(netr_GetForestTrustInformation, &r);
2207         }
2208
2209         status = cli->dispatch(cli,
2210                                 mem_ctx,
2211                                 &ndr_table_netlogon,
2212                                 NDR_NETR_GETFORESTTRUSTINFORMATION,
2213                                 &r);
2214
2215         if (!NT_STATUS_IS_OK(status)) {
2216                 return status;
2217         }
2218
2219         if (DEBUGLEVEL >= 10) {
2220                 NDR_PRINT_OUT_DEBUG(netr_GetForestTrustInformation, &r);
2221         }
2222
2223         if (NT_STATUS_IS_ERR(status)) {
2224                 return status;
2225         }
2226
2227         /* Return variables */
2228         *return_authenticator = *r.out.return_authenticator;
2229         *forest_trust_info = *r.out.forest_trust_info;
2230
2231         /* Return result */
2232         if (werror) {
2233                 *werror = r.out.result;
2234         }
2235
2236         return werror_to_ntstatus(r.out.result);
2237 }
2238
2239 NTSTATUS rpccli_netr_LogonSamLogonWithFlags(struct rpc_pipe_client *cli,
2240                                             TALLOC_CTX *mem_ctx,
2241                                             const char *server_name /* [in] [unique,charset(UTF16)] */,
2242                                             const char *computer_name /* [in] [unique,charset(UTF16)] */,
2243                                             struct netr_Authenticator *credential /* [in] [unique] */,
2244                                             struct netr_Authenticator *return_authenticator /* [in,out] [unique] */,
2245                                             enum netr_LogonInfoClass logon_level /* [in]  */,
2246                                             union netr_LogonLevel *logon /* [in] [ref,switch_is(logon_level)] */,
2247                                             uint16_t validation_level /* [in]  */,
2248                                             union netr_Validation *validation /* [out] [ref,switch_is(validation_level)] */,
2249                                             uint8_t *authoritative /* [out] [ref] */,
2250                                             uint32_t *flags /* [in,out] [ref] */)
2251 {
2252         struct netr_LogonSamLogonWithFlags r;
2253         NTSTATUS status;
2254
2255         /* In parameters */
2256         r.in.server_name = server_name;
2257         r.in.computer_name = computer_name;
2258         r.in.credential = credential;
2259         r.in.return_authenticator = return_authenticator;
2260         r.in.logon_level = logon_level;
2261         r.in.logon = logon;
2262         r.in.validation_level = validation_level;
2263         r.in.flags = flags;
2264
2265         if (DEBUGLEVEL >= 10) {
2266                 NDR_PRINT_IN_DEBUG(netr_LogonSamLogonWithFlags, &r);
2267         }
2268
2269         status = cli->dispatch(cli,
2270                                 mem_ctx,
2271                                 &ndr_table_netlogon,
2272                                 NDR_NETR_LOGONSAMLOGONWITHFLAGS,
2273                                 &r);
2274
2275         if (!NT_STATUS_IS_OK(status)) {
2276                 return status;
2277         }
2278
2279         if (DEBUGLEVEL >= 10) {
2280                 NDR_PRINT_OUT_DEBUG(netr_LogonSamLogonWithFlags, &r);
2281         }
2282
2283         if (NT_STATUS_IS_ERR(status)) {
2284                 return status;
2285         }
2286
2287         /* Return variables */
2288         if (return_authenticator && r.out.return_authenticator) {
2289                 *return_authenticator = *r.out.return_authenticator;
2290         }
2291         *validation = *r.out.validation;
2292         *authoritative = *r.out.authoritative;
2293         *flags = *r.out.flags;
2294
2295         /* Return result */
2296         return r.out.result;
2297 }
2298
2299 NTSTATUS rpccli_netr_ServerGetTrustInfo(struct rpc_pipe_client *cli,
2300                                         TALLOC_CTX *mem_ctx,
2301                                         const char *server_name /* [in] [unique,charset(UTF16)] */,
2302                                         const char *account_name /* [in] [ref,charset(UTF16)] */,
2303                                         enum netr_SchannelType secure_channel_type /* [in]  */,
2304                                         const char *computer_name /* [in] [ref,charset(UTF16)] */,
2305                                         struct netr_Authenticator *credential /* [in] [ref] */,
2306                                         struct netr_Authenticator *return_authenticator /* [out] [ref] */,
2307                                         struct samr_Password *new_owf_password /* [out] [ref] */,
2308                                         struct samr_Password *old_owf_password /* [out] [ref] */,
2309                                         struct netr_TrustInfo **trust_info /* [out] [ref] */)
2310 {
2311         struct netr_ServerGetTrustInfo r;
2312         NTSTATUS status;
2313
2314         /* In parameters */
2315         r.in.server_name = server_name;
2316         r.in.account_name = account_name;
2317         r.in.secure_channel_type = secure_channel_type;
2318         r.in.computer_name = computer_name;
2319         r.in.credential = credential;
2320
2321         if (DEBUGLEVEL >= 10) {
2322                 NDR_PRINT_IN_DEBUG(netr_ServerGetTrustInfo, &r);
2323         }
2324
2325         status = cli->dispatch(cli,
2326                                 mem_ctx,
2327                                 &ndr_table_netlogon,
2328                                 NDR_NETR_SERVERGETTRUSTINFO,
2329                                 &r);
2330
2331         if (!NT_STATUS_IS_OK(status)) {
2332                 return status;
2333         }
2334
2335         if (DEBUGLEVEL >= 10) {
2336                 NDR_PRINT_OUT_DEBUG(netr_ServerGetTrustInfo, &r);
2337         }
2338
2339         if (NT_STATUS_IS_ERR(status)) {
2340                 return status;
2341         }
2342
2343         /* Return variables */
2344         *return_authenticator = *r.out.return_authenticator;
2345         *new_owf_password = *r.out.new_owf_password;
2346         *old_owf_password = *r.out.old_owf_password;
2347         *trust_info = *r.out.trust_info;
2348
2349         /* Return result */
2350         return r.out.result;
2351 }
2352