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