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 {
 603         struct netr_GetDcName r;
 604         NTSTATUS status;
 605
 606         /* In parameters */
 607         r.in.logon_server = logon_server;
 608         r.in.domainname = domainname;
 609
 610         if (DEBUGLEVEL >= 10) {
 611                 NDR_PRINT_IN_DEBUG(netr_GetDcName, &r);
 612         }
 613
 614         status = cli_do_rpc_ndr(cli,
 615                                 mem_ctx,
 616                                 PI_NETLOGON,
 617                                 &ndr_table_netlogon,
 618                                 NDR_NETR_GETDCNAME,
 619                                 &r);
 620
 621         if (!NT_STATUS_IS_OK(status)) {
 622                 return status;
 623         }
 624
 625         if (DEBUGLEVEL >= 10) {
 626                 NDR_PRINT_OUT_DEBUG(netr_GetDcName, &r);
 627         }
 628
 629         if (NT_STATUS_IS_ERR(status)) {
 630                 return status;
 631         }
 632
 633         /* Return variables */
 634         *dcname = *r.out.dcname;
 635
 636         /* Return result */
 637         return r.out.result;
 638 }
 639
 640 NTSTATUS rpccli_netr_LogonControl(struct rpc_pipe_client *cli,
 641                                   TALLOC_CTX *mem_ctx,
 642                                   const char *logon_server,
 643                                   enum netr_LogonControlCode function_code,
 644                                   uint32_t level,
 645                                   union netr_CONTROL_QUERY_INFORMATION *info,
 646                                   WERROR *werror)
 647 {
 648         struct netr_LogonControl r;
 649         NTSTATUS status;
 650
 651         /* In parameters */
 652         r.in.logon_server = logon_server;
 653         r.in.function_code = function_code;
 654         r.in.level = level;
 655
 656         if (DEBUGLEVEL >= 10) {
 657                 NDR_PRINT_IN_DEBUG(netr_LogonControl, &r);
 658         }
 659
 660         status = cli_do_rpc_ndr(cli,
 661                                 mem_ctx,
 662                                 PI_NETLOGON,
 663                                 &ndr_table_netlogon,
 664                                 NDR_NETR_LOGONCONTROL,
 665                                 &r);
 666
 667         if (!NT_STATUS_IS_OK(status)) {
 668                 return status;
 669         }
 670
 671         if (DEBUGLEVEL >= 10) {
 672                 NDR_PRINT_OUT_DEBUG(netr_LogonControl, &r);
 673         }
 674
 675         if (NT_STATUS_IS_ERR(status)) {
 676                 return status;
 677         }
 678
 679         /* Return variables */
 680         *info = *r.out.info;
 681
 682         /* Return result */
 683         if (werror) {
 684                 *werror = r.out.result;
 685         }
 686
 687         return werror_to_ntstatus(r.out.result);
 688 }
 689
 690 NTSTATUS rpccli_netr_GetAnyDCName(struct rpc_pipe_client *cli,
 691                                   TALLOC_CTX *mem_ctx,
 692                                   const char *logon_server,
 693                                   const char *domainname,
 694                                   const char **dcname,
 695                                   WERROR *werror)
 696 {
 697         struct netr_GetAnyDCName r;
 698         NTSTATUS status;
 699
 700         /* In parameters */
 701         r.in.logon_server = logon_server;
 702         r.in.domainname = domainname;
 703
 704         if (DEBUGLEVEL >= 10) {
 705                 NDR_PRINT_IN_DEBUG(netr_GetAnyDCName, &r);
 706         }
 707
 708         status = cli_do_rpc_ndr(cli,
 709                                 mem_ctx,
 710                                 PI_NETLOGON,
 711                                 &ndr_table_netlogon,
 712                                 NDR_NETR_GETANYDCNAME,
 713                                 &r);
 714
 715         if (!NT_STATUS_IS_OK(status)) {
 716                 return status;
 717         }
 718
 719         if (DEBUGLEVEL >= 10) {
 720                 NDR_PRINT_OUT_DEBUG(netr_GetAnyDCName, &r);
 721         }
 722
 723         if (NT_STATUS_IS_ERR(status)) {
 724                 return status;
 725         }
 726
 727         /* Return variables */
 728         *dcname = *r.out.dcname;
 729
 730         /* Return result */
 731         if (werror) {
 732                 *werror = r.out.result;
 733         }
 734
 735         return werror_to_ntstatus(r.out.result);
 736 }
 737
 738 NTSTATUS rpccli_netr_LogonControl2(struct rpc_pipe_client *cli,
 739                                    TALLOC_CTX *mem_ctx,
 740                                    const char *logon_server,
 741                                    uint32_t function_code,
 742                                    uint32_t level,
 743                                    union netr_CONTROL_DATA_INFORMATION data,
 744                                    union netr_CONTROL_QUERY_INFORMATION *query,
 745                                    WERROR *werror)
 746 {
 747         struct netr_LogonControl2 r;
 748         NTSTATUS status;
 749
 750         /* In parameters */
 751         r.in.logon_server = logon_server;
 752         r.in.function_code = function_code;
 753         r.in.level = level;
 754         r.in.data = data;
 755
 756         if (DEBUGLEVEL >= 10) {
 757                 NDR_PRINT_IN_DEBUG(netr_LogonControl2, &r);
 758         }
 759
 760         status = cli_do_rpc_ndr(cli,
 761                                 mem_ctx,
 762                                 PI_NETLOGON,
 763                                 &ndr_table_netlogon,
 764                                 NDR_NETR_LOGONCONTROL2,
 765                                 &r);
 766
 767         if (!NT_STATUS_IS_OK(status)) {
 768                 return status;
 769         }
 770
 771         if (DEBUGLEVEL >= 10) {
 772                 NDR_PRINT_OUT_DEBUG(netr_LogonControl2, &r);
 773         }
 774
 775         if (NT_STATUS_IS_ERR(status)) {
 776                 return status;
 777         }
 778
 779         /* Return variables */
 780         *query = *r.out.query;
 781
 782         /* Return result */
 783         if (werror) {
 784                 *werror = r.out.result;
 785         }
 786
 787         return werror_to_ntstatus(r.out.result);
 788 }
 789
 790 NTSTATUS rpccli_netr_ServerAuthenticate2(struct rpc_pipe_client *cli,
 791                                          TALLOC_CTX *mem_ctx,
 792                                          const char *server_name,
 793                                          const char *account_name,
 794                                          enum netr_SchannelType secure_channel_type,
 795                                          const char *computer_name,
 796                                          struct netr_Credential *credentials,
 797                                          uint32_t *negotiate_flags)
 798 {
 799         struct netr_ServerAuthenticate2 r;
 800         NTSTATUS status;
 801
 802         /* In parameters */
 803         r.in.server_name = server_name;
 804         r.in.account_name = account_name;
 805         r.in.secure_channel_type = secure_channel_type;
 806         r.in.computer_name = computer_name;
 807         r.in.credentials = credentials;
 808         r.in.negotiate_flags = negotiate_flags;
 809
 810         if (DEBUGLEVEL >= 10) {
 811                 NDR_PRINT_IN_DEBUG(netr_ServerAuthenticate2, &r);
 812         }
 813
 814         status = cli_do_rpc_ndr(cli,
 815                                 mem_ctx,
 816                                 PI_NETLOGON,
 817                                 &ndr_table_netlogon,
 818                                 NDR_NETR_SERVERAUTHENTICATE2,
 819                                 &r);
 820
 821         if (!NT_STATUS_IS_OK(status)) {
 822                 return status;
 823         }
 824
 825         if (DEBUGLEVEL >= 10) {
 826                 NDR_PRINT_OUT_DEBUG(netr_ServerAuthenticate2, &r);
 827         }
 828
 829         if (NT_STATUS_IS_ERR(status)) {
 830                 return status;
 831         }
 832
 833         /* Return variables */
 834         *credentials = *r.out.credentials;
 835         *negotiate_flags = *r.out.negotiate_flags;
 836
 837         /* Return result */
 838         return r.out.result;
 839 }
 840
 841 NTSTATUS rpccli_netr_DatabaseSync2(struct rpc_pipe_client *cli,
 842                                    TALLOC_CTX *mem_ctx,
 843                                    const char *logon_server,
 844                                    const char *computername,
 845                                    struct netr_Authenticator credential,
 846                                    struct netr_Authenticator *return_authenticator,
 847                                    enum netr_SamDatabaseID database_id,
 848                                    uint16_t restart_state,
 849                                    uint32_t *sync_context,
 850                                    uint32_t preferredmaximumlength,
 851                                    struct netr_DELTA_ENUM_ARRAY *delta_enum_array)
 852 {
 853         struct netr_DatabaseSync2 r;
 854         NTSTATUS status;
 855
 856         /* In parameters */
 857         r.in.logon_server = logon_server;
 858         r.in.computername = computername;
 859         r.in.credential = credential;
 860         r.in.return_authenticator = return_authenticator;
 861         r.in.database_id = database_id;
 862         r.in.restart_state = restart_state;
 863         r.in.sync_context = sync_context;
 864         r.in.preferredmaximumlength = preferredmaximumlength;
 865
 866         if (DEBUGLEVEL >= 10) {
 867                 NDR_PRINT_IN_DEBUG(netr_DatabaseSync2, &r);
 868         }
 869
 870         status = cli_do_rpc_ndr(cli,
 871                                 mem_ctx,
 872                                 PI_NETLOGON,
 873                                 &ndr_table_netlogon,
 874                                 NDR_NETR_DATABASESYNC2,
 875                                 &r);
 876
 877         if (!NT_STATUS_IS_OK(status)) {
 878                 return status;
 879         }
 880
 881         if (DEBUGLEVEL >= 10) {
 882                 NDR_PRINT_OUT_DEBUG(netr_DatabaseSync2, &r);
 883         }
 884
 885         if (NT_STATUS_IS_ERR(status)) {
 886                 return status;
 887         }
 888
 889         /* Return variables */
 890         *return_authenticator = *r.out.return_authenticator;
 891         *sync_context = *r.out.sync_context;
 892         *delta_enum_array = *r.out.delta_enum_array;
 893
 894         /* Return result */
 895         return r.out.result;
 896 }
 897
 898 NTSTATUS rpccli_netr_DatabaseRedo(struct rpc_pipe_client *cli,
 899                                   TALLOC_CTX *mem_ctx,
 900                                   const char *logon_server,
 901                                   const char *computername,
 902                                   struct netr_Authenticator credential,
 903                                   struct netr_Authenticator *return_authenticator,
 904                                   uint8_t *change_log_entry,
 905                                   uint32_t change_log_entry_size,
 906                                   struct netr_DELTA_ENUM_ARRAY *delta_enum_array)
 907 {
 908         struct netr_DatabaseRedo r;
 909         NTSTATUS status;
 910
 911         /* In parameters */
 912         r.in.logon_server = logon_server;
 913         r.in.computername = computername;
 914         r.in.credential = credential;
 915         r.in.return_authenticator = return_authenticator;
 916         r.in.change_log_entry = change_log_entry;
 917         r.in.change_log_entry_size = change_log_entry_size;
 918
 919         if (DEBUGLEVEL >= 10) {
 920                 NDR_PRINT_IN_DEBUG(netr_DatabaseRedo, &r);
 921         }
 922
 923         status = cli_do_rpc_ndr(cli,
 924                                 mem_ctx,
 925                                 PI_NETLOGON,
 926                                 &ndr_table_netlogon,
 927                                 NDR_NETR_DATABASEREDO,
 928                                 &r);
 929
 930         if (!NT_STATUS_IS_OK(status)) {
 931                 return status;
 932         }
 933
 934         if (DEBUGLEVEL >= 10) {
 935                 NDR_PRINT_OUT_DEBUG(netr_DatabaseRedo, &r);
 936         }
 937
 938         if (NT_STATUS_IS_ERR(status)) {
 939                 return status;
 940         }
 941
 942         /* Return variables */
 943         *return_authenticator = *r.out.return_authenticator;
 944         *delta_enum_array = *r.out.delta_enum_array;
 945
 946         /* Return result */
 947         return r.out.result;
 948 }
 949
 950 NTSTATUS rpccli_netr_LogonControl2Ex(struct rpc_pipe_client *cli,
 951                                      TALLOC_CTX *mem_ctx,
 952                                      const char *logon_server,
 953                                      uint32_t function_code,
 954                                      uint32_t level,
 955                                      union netr_CONTROL_DATA_INFORMATION data,
 956                                      union netr_CONTROL_QUERY_INFORMATION *query,
 957                                      WERROR *werror)
 958 {
 959         struct netr_LogonControl2Ex r;
 960         NTSTATUS status;
 961
 962         /* In parameters */
 963         r.in.logon_server = logon_server;
 964         r.in.function_code = function_code;
 965         r.in.level = level;
 966         r.in.data = data;
 967
 968         if (DEBUGLEVEL >= 10) {
 969                 NDR_PRINT_IN_DEBUG(netr_LogonControl2Ex, &r);
 970         }
 971
 972         status = cli_do_rpc_ndr(cli,
 973                                 mem_ctx,
 974                                 PI_NETLOGON,
 975                                 &ndr_table_netlogon,
 976                                 NDR_NETR_LOGONCONTROL2EX,
 977                                 &r);
 978
 979         if (!NT_STATUS_IS_OK(status)) {
 980                 return status;
 981         }
 982
 983         if (DEBUGLEVEL >= 10) {
 984                 NDR_PRINT_OUT_DEBUG(netr_LogonControl2Ex, &r);
 985         }
 986
 987         if (NT_STATUS_IS_ERR(status)) {
 988                 return status;
 989         }
 990
 991         /* Return variables */
 992         *query = *r.out.query;
 993
 994         /* Return result */
 995         if (werror) {
 996                 *werror = r.out.result;
 997         }
 998
 999         return werror_to_ntstatus(r.out.result);
1000 }
1001
1002 NTSTATUS rpccli_netr_NetrEnumerateTrustedDomains(struct rpc_pipe_client *cli,
1003                                                  TALLOC_CTX *mem_ctx,
1004                                                  const char *server_name,
1005                                                  struct netr_Blob *trusted_domains_blob,
1006                                                  WERROR *werror)
1007 {
1008         struct netr_NetrEnumerateTrustedDomains r;
1009         NTSTATUS status;
1010
1011         /* In parameters */
1012         r.in.server_name = server_name;
1013
1014         if (DEBUGLEVEL >= 10) {
1015                 NDR_PRINT_IN_DEBUG(netr_NetrEnumerateTrustedDomains, &r);
1016         }
1017
1018         status = cli_do_rpc_ndr(cli,
1019                                 mem_ctx,
1020                                 PI_NETLOGON,
1021                                 &ndr_table_netlogon,
1022                                 NDR_NETR_NETRENUMERATETRUSTEDDOMAINS,
1023                                 &r);
1024
1025         if (!NT_STATUS_IS_OK(status)) {
1026                 return status;
1027         }
1028
1029         if (DEBUGLEVEL >= 10) {
1030                 NDR_PRINT_OUT_DEBUG(netr_NetrEnumerateTrustedDomains, &r);
1031         }
1032
1033         if (NT_STATUS_IS_ERR(status)) {
1034                 return status;
1035         }
1036
1037         /* Return variables */
1038         *trusted_domains_blob = *r.out.trusted_domains_blob;
1039
1040         /* Return result */
1041         if (werror) {
1042                 *werror = r.out.result;
1043         }
1044
1045         return werror_to_ntstatus(r.out.result);
1046 }
1047
1048 NTSTATUS rpccli_netr_DsRGetDCName(struct rpc_pipe_client *cli,
1049                                   TALLOC_CTX *mem_ctx,
1050                                   const char *server_unc,
1051                                   const char *domain_name,
1052                                   struct GUID *domain_guid,
1053                                   struct GUID *site_guid,
1054                                   uint32_t flags,
1055                                   struct netr_DsRGetDCNameInfo *info,
1056                                   WERROR *werror)
1057 {
1058         struct netr_DsRGetDCName r;
1059         NTSTATUS status;
1060
1061         /* In parameters */
1062         r.in.server_unc = server_unc;
1063         r.in.domain_name = domain_name;
1064         r.in.domain_guid = domain_guid;
1065         r.in.site_guid = site_guid;
1066         r.in.flags = flags;
1067
1068         if (DEBUGLEVEL >= 10) {
1069                 NDR_PRINT_IN_DEBUG(netr_DsRGetDCName, &r);
1070         }
1071
1072         status = cli_do_rpc_ndr(cli,
1073                                 mem_ctx,
1074                                 PI_NETLOGON,
1075                                 &ndr_table_netlogon,
1076                                 NDR_NETR_DSRGETDCNAME,
1077                                 &r);
1078
1079         if (!NT_STATUS_IS_OK(status)) {
1080                 return status;
1081         }
1082
1083         if (DEBUGLEVEL >= 10) {
1084                 NDR_PRINT_OUT_DEBUG(netr_DsRGetDCName, &r);
1085         }
1086
1087         if (NT_STATUS_IS_ERR(status)) {
1088                 return status;
1089         }
1090
1091         /* Return variables */
1092         *info = *r.out.info;
1093
1094         /* Return result */
1095         if (werror) {
1096                 *werror = r.out.result;
1097         }
1098
1099         return werror_to_ntstatus(r.out.result);
1100 }
1101
1102 NTSTATUS rpccli_netr_NETRLOGONDUMMYROUTINE1(struct rpc_pipe_client *cli,
1103                                             TALLOC_CTX *mem_ctx,
1104                                             WERROR *werror)
1105 {
1106         struct netr_NETRLOGONDUMMYROUTINE1 r;
1107         NTSTATUS status;
1108
1109         /* In parameters */
1110
1111         if (DEBUGLEVEL >= 10) {
1112                 NDR_PRINT_IN_DEBUG(netr_NETRLOGONDUMMYROUTINE1, &r);
1113         }
1114
1115         status = cli_do_rpc_ndr(cli,
1116                                 mem_ctx,
1117                                 PI_NETLOGON,
1118                                 &ndr_table_netlogon,
1119                                 NDR_NETR_NETRLOGONDUMMYROUTINE1,
1120                                 &r);
1121
1122         if (!NT_STATUS_IS_OK(status)) {
1123                 return status;
1124         }
1125
1126         if (DEBUGLEVEL >= 10) {
1127                 NDR_PRINT_OUT_DEBUG(netr_NETRLOGONDUMMYROUTINE1, &r);
1128         }
1129
1130         if (NT_STATUS_IS_ERR(status)) {
1131                 return status;
1132         }
1133
1134         /* Return variables */
1135
1136         /* Return result */
1137         if (werror) {
1138                 *werror = r.out.result;
1139         }
1140
1141         return werror_to_ntstatus(r.out.result);
1142 }
1143
1144 NTSTATUS rpccli_netr_NETRLOGONSETSERVICEBITS(struct rpc_pipe_client *cli,
1145                                              TALLOC_CTX *mem_ctx,
1146                                              WERROR *werror)
1147 {
1148         struct netr_NETRLOGONSETSERVICEBITS r;
1149         NTSTATUS status;
1150
1151         /* In parameters */
1152
1153         if (DEBUGLEVEL >= 10) {
1154                 NDR_PRINT_IN_DEBUG(netr_NETRLOGONSETSERVICEBITS, &r);
1155         }
1156
1157         status = cli_do_rpc_ndr(cli,
1158                                 mem_ctx,
1159                                 PI_NETLOGON,
1160                                 &ndr_table_netlogon,
1161                                 NDR_NETR_NETRLOGONSETSERVICEBITS,
1162                                 &r);
1163
1164         if (!NT_STATUS_IS_OK(status)) {
1165                 return status;
1166         }
1167
1168         if (DEBUGLEVEL >= 10) {
1169                 NDR_PRINT_OUT_DEBUG(netr_NETRLOGONSETSERVICEBITS, &r);
1170         }
1171
1172         if (NT_STATUS_IS_ERR(status)) {
1173                 return status;
1174         }
1175
1176         /* Return variables */
1177
1178         /* Return result */
1179         if (werror) {
1180                 *werror = r.out.result;
1181         }
1182
1183         return werror_to_ntstatus(r.out.result);
1184 }
1185
1186 NTSTATUS rpccli_netr_NETRLOGONGETTRUSTRID(struct rpc_pipe_client *cli,
1187                                           TALLOC_CTX *mem_ctx,
1188                                           WERROR *werror)
1189 {
1190         struct netr_NETRLOGONGETTRUSTRID r;
1191         NTSTATUS status;
1192
1193         /* In parameters */
1194
1195         if (DEBUGLEVEL >= 10) {
1196                 NDR_PRINT_IN_DEBUG(netr_NETRLOGONGETTRUSTRID, &r);
1197         }
1198
1199         status = cli_do_rpc_ndr(cli,
1200                                 mem_ctx,
1201                                 PI_NETLOGON,
1202                                 &ndr_table_netlogon,
1203                                 NDR_NETR_NETRLOGONGETTRUSTRID,
1204                                 &r);
1205
1206         if (!NT_STATUS_IS_OK(status)) {
1207                 return status;
1208         }
1209
1210         if (DEBUGLEVEL >= 10) {
1211                 NDR_PRINT_OUT_DEBUG(netr_NETRLOGONGETTRUSTRID, &r);
1212         }
1213
1214         if (NT_STATUS_IS_ERR(status)) {
1215                 return status;
1216         }
1217
1218         /* Return variables */
1219
1220         /* Return result */
1221         if (werror) {
1222                 *werror = r.out.result;
1223         }
1224
1225         return werror_to_ntstatus(r.out.result);
1226 }
1227
1228 NTSTATUS rpccli_netr_NETRLOGONCOMPUTESERVERDIGEST(struct rpc_pipe_client *cli,
1229                                                   TALLOC_CTX *mem_ctx,
1230                                                   WERROR *werror)
1231 {
1232         struct netr_NETRLOGONCOMPUTESERVERDIGEST r;
1233         NTSTATUS status;
1234
1235         /* In parameters */
1236
1237         if (DEBUGLEVEL >= 10) {
1238                 NDR_PRINT_IN_DEBUG(netr_NETRLOGONCOMPUTESERVERDIGEST, &r);
1239         }
1240
1241         status = cli_do_rpc_ndr(cli,
1242                                 mem_ctx,
1243                                 PI_NETLOGON,
1244                                 &ndr_table_netlogon,
1245                                 NDR_NETR_NETRLOGONCOMPUTESERVERDIGEST,
1246                                 &r);
1247
1248         if (!NT_STATUS_IS_OK(status)) {
1249                 return status;
1250         }
1251
1252         if (DEBUGLEVEL >= 10) {
1253                 NDR_PRINT_OUT_DEBUG(netr_NETRLOGONCOMPUTESERVERDIGEST, &r);
1254         }
1255
1256         if (NT_STATUS_IS_ERR(status)) {
1257                 return status;
1258         }
1259
1260         /* Return variables */
1261
1262         /* Return result */
1263         if (werror) {
1264                 *werror = r.out.result;
1265         }
1266
1267         return werror_to_ntstatus(r.out.result);
1268 }
1269
1270 NTSTATUS rpccli_netr_NETRLOGONCOMPUTECLIENTDIGEST(struct rpc_pipe_client *cli,
1271                                                   TALLOC_CTX *mem_ctx,
1272                                                   WERROR *werror)
1273 {
1274         struct netr_NETRLOGONCOMPUTECLIENTDIGEST r;
1275         NTSTATUS status;
1276
1277         /* In parameters */
1278
1279         if (DEBUGLEVEL >= 10) {
1280                 NDR_PRINT_IN_DEBUG(netr_NETRLOGONCOMPUTECLIENTDIGEST, &r);
1281         }
1282
1283         status = cli_do_rpc_ndr(cli,
1284                                 mem_ctx,
1285                                 PI_NETLOGON,
1286                                 &ndr_table_netlogon,
1287                                 NDR_NETR_NETRLOGONCOMPUTECLIENTDIGEST,
1288                                 &r);
1289
1290         if (!NT_STATUS_IS_OK(status)) {
1291                 return status;
1292         }
1293
1294         if (DEBUGLEVEL >= 10) {
1295                 NDR_PRINT_OUT_DEBUG(netr_NETRLOGONCOMPUTECLIENTDIGEST, &r);
1296         }
1297
1298         if (NT_STATUS_IS_ERR(status)) {
1299                 return status;
1300         }
1301
1302         /* Return variables */
1303
1304         /* Return result */
1305         if (werror) {
1306                 *werror = r.out.result;
1307         }
1308
1309         return werror_to_ntstatus(r.out.result);
1310 }
1311
1312 NTSTATUS rpccli_netr_ServerAuthenticate3(struct rpc_pipe_client *cli,
1313                                          TALLOC_CTX *mem_ctx,
1314                                          const char *server_name,
1315                                          const char *account_name,
1316                                          enum netr_SchannelType secure_channel_type,
1317                                          const char *computer_name,
1318                                          struct netr_Credential *credentials,
1319                                          uint32_t *negotiate_flags,
1320                                          uint32_t *rid)
1321 {
1322         struct netr_ServerAuthenticate3 r;
1323         NTSTATUS status;
1324
1325         /* In parameters */
1326         r.in.server_name = server_name;
1327         r.in.account_name = account_name;
1328         r.in.secure_channel_type = secure_channel_type;
1329         r.in.computer_name = computer_name;
1330         r.in.credentials = credentials;
1331         r.in.negotiate_flags = negotiate_flags;
1332
1333         if (DEBUGLEVEL >= 10) {
1334                 NDR_PRINT_IN_DEBUG(netr_ServerAuthenticate3, &r);
1335         }
1336
1337         status = cli_do_rpc_ndr(cli,
1338                                 mem_ctx,
1339                                 PI_NETLOGON,
1340                                 &ndr_table_netlogon,
1341                                 NDR_NETR_SERVERAUTHENTICATE3,
1342                                 &r);
1343
1344         if (!NT_STATUS_IS_OK(status)) {
1345                 return status;
1346         }
1347
1348         if (DEBUGLEVEL >= 10) {
1349                 NDR_PRINT_OUT_DEBUG(netr_ServerAuthenticate3, &r);
1350         }
1351
1352         if (NT_STATUS_IS_ERR(status)) {
1353                 return status;
1354         }
1355
1356         /* Return variables */
1357         *credentials = *r.out.credentials;
1358         *negotiate_flags = *r.out.negotiate_flags;
1359         *rid = *r.out.rid;
1360
1361         /* Return result */
1362         return r.out.result;
1363 }
1364
1365 NTSTATUS rpccli_netr_DsRGetDCNameEx(struct rpc_pipe_client *cli,
1366                                     TALLOC_CTX *mem_ctx,
1367                                     const char *server_unc,
1368                                     const char *domain_name,
1369                                     struct GUID *domain_guid,
1370                                     const char *site_name,
1371                                     uint32_t flags,
1372                                     struct netr_DsRGetDCNameInfo *info,
1373                                     WERROR *werror)
1374 {
1375         struct netr_DsRGetDCNameEx r;
1376         NTSTATUS status;
1377
1378         /* In parameters */
1379         r.in.server_unc = server_unc;
1380         r.in.domain_name = domain_name;
1381         r.in.domain_guid = domain_guid;
1382         r.in.site_name = site_name;
1383         r.in.flags = flags;
1384
1385         if (DEBUGLEVEL >= 10) {
1386                 NDR_PRINT_IN_DEBUG(netr_DsRGetDCNameEx, &r);
1387         }
1388
1389         status = cli_do_rpc_ndr(cli,
1390                                 mem_ctx,
1391                                 PI_NETLOGON,
1392                                 &ndr_table_netlogon,
1393                                 NDR_NETR_DSRGETDCNAMEEX,
1394                                 &r);
1395
1396         if (!NT_STATUS_IS_OK(status)) {
1397                 return status;
1398         }
1399
1400         if (DEBUGLEVEL >= 10) {
1401                 NDR_PRINT_OUT_DEBUG(netr_DsRGetDCNameEx, &r);
1402         }
1403
1404         if (NT_STATUS_IS_ERR(status)) {
1405                 return status;
1406         }
1407
1408         /* Return variables */
1409         *info = *r.out.info;
1410
1411         /* Return result */
1412         if (werror) {
1413                 *werror = r.out.result;
1414         }
1415
1416         return werror_to_ntstatus(r.out.result);
1417 }
1418
1419 NTSTATUS rpccli_netr_DsRGetSiteName(struct rpc_pipe_client *cli,
1420                                     TALLOC_CTX *mem_ctx,
1421                                     const char *computer_name,
1422                                     const char **site,
1423                                     WERROR *werror)
1424 {
1425         struct netr_DsRGetSiteName r;
1426         NTSTATUS status;
1427
1428         /* In parameters */
1429         r.in.computer_name = computer_name;
1430
1431         if (DEBUGLEVEL >= 10) {
1432                 NDR_PRINT_IN_DEBUG(netr_DsRGetSiteName, &r);
1433         }
1434
1435         status = cli_do_rpc_ndr(cli,
1436                                 mem_ctx,
1437                                 PI_NETLOGON,
1438                                 &ndr_table_netlogon,
1439                                 NDR_NETR_DSRGETSITENAME,
1440                                 &r);
1441
1442         if (!NT_STATUS_IS_OK(status)) {
1443                 return status;
1444         }
1445
1446         if (DEBUGLEVEL >= 10) {
1447                 NDR_PRINT_OUT_DEBUG(netr_DsRGetSiteName, &r);
1448         }
1449
1450         if (NT_STATUS_IS_ERR(status)) {
1451                 return status;
1452         }
1453
1454         /* Return variables */
1455         *site = *r.out.site;
1456
1457         /* Return result */
1458         if (werror) {
1459                 *werror = r.out.result;
1460         }
1461
1462         return werror_to_ntstatus(r.out.result);
1463 }
1464
1465 NTSTATUS rpccli_netr_LogonGetDomainInfo(struct rpc_pipe_client *cli,
1466                                         TALLOC_CTX *mem_ctx,
1467                                         const char *server_name,
1468                                         const char *computer_name,
1469                                         struct netr_Authenticator *credential,
1470                                         struct netr_Authenticator *return_authenticator,
1471                                         uint32_t level,
1472                                         union netr_DomainQuery query,
1473                                         union netr_DomainInfo *info)
1474 {
1475         struct netr_LogonGetDomainInfo r;
1476         NTSTATUS status;
1477
1478         /* In parameters */
1479         r.in.server_name = server_name;
1480         r.in.computer_name = computer_name;
1481         r.in.credential = credential;
1482         r.in.return_authenticator = return_authenticator;
1483         r.in.level = level;
1484         r.in.query = query;
1485
1486         if (DEBUGLEVEL >= 10) {
1487                 NDR_PRINT_IN_DEBUG(netr_LogonGetDomainInfo, &r);
1488         }
1489
1490         status = cli_do_rpc_ndr(cli,
1491                                 mem_ctx,
1492                                 PI_NETLOGON,
1493                                 &ndr_table_netlogon,
1494                                 NDR_NETR_LOGONGETDOMAININFO,
1495                                 &r);
1496
1497         if (!NT_STATUS_IS_OK(status)) {
1498                 return status;
1499         }
1500
1501         if (DEBUGLEVEL >= 10) {
1502                 NDR_PRINT_OUT_DEBUG(netr_LogonGetDomainInfo, &r);
1503         }
1504
1505         if (NT_STATUS_IS_ERR(status)) {
1506                 return status;
1507         }
1508
1509         /* Return variables */
1510         *return_authenticator = *r.out.return_authenticator;
1511         *info = *r.out.info;
1512
1513         /* Return result */
1514         return r.out.result;
1515 }
1516
1517 NTSTATUS rpccli_netr_ServerPasswordSet2(struct rpc_pipe_client *cli,
1518                                         TALLOC_CTX *mem_ctx,
1519                                         const char *server_name,
1520                                         const char *account_name,
1521                                         enum netr_SchannelType secure_channel_type,
1522                                         const char *computer_name,
1523                                         struct netr_Authenticator credential,
1524                                         struct netr_CryptPassword new_password,
1525                                         struct netr_Authenticator *return_authenticator)
1526 {
1527         struct netr_ServerPasswordSet2 r;
1528         NTSTATUS status;
1529
1530         /* In parameters */
1531         r.in.server_name = server_name;
1532         r.in.account_name = account_name;
1533         r.in.secure_channel_type = secure_channel_type;
1534         r.in.computer_name = computer_name;
1535         r.in.credential = credential;
1536         r.in.new_password = new_password;
1537
1538         if (DEBUGLEVEL >= 10) {
1539                 NDR_PRINT_IN_DEBUG(netr_ServerPasswordSet2, &r);
1540         }
1541
1542         status = cli_do_rpc_ndr(cli,
1543                                 mem_ctx,
1544                                 PI_NETLOGON,
1545                                 &ndr_table_netlogon,
1546                                 NDR_NETR_SERVERPASSWORDSET2,
1547                                 &r);
1548
1549         if (!NT_STATUS_IS_OK(status)) {
1550                 return status;
1551         }
1552
1553         if (DEBUGLEVEL >= 10) {
1554                 NDR_PRINT_OUT_DEBUG(netr_ServerPasswordSet2, &r);
1555         }
1556
1557         if (NT_STATUS_IS_ERR(status)) {
1558                 return status;
1559         }
1560
1561         /* Return variables */
1562         *return_authenticator = *r.out.return_authenticator;
1563
1564         /* Return result */
1565         return r.out.result;
1566 }
1567
1568 NTSTATUS rpccli_netr_ServerPasswordGet(struct rpc_pipe_client *cli,
1569                                        TALLOC_CTX *mem_ctx,
1570                                        const char *server_name,
1571                                        const char *account_name,
1572                                        enum netr_SchannelType secure_channel_type,
1573                                        const char *computer_name,
1574                                        struct netr_Authenticator *credential,
1575                                        struct netr_Authenticator *return_authenticator,
1576                                        struct samr_Password *password,
1577                                        WERROR *werror)
1578 {
1579         struct netr_ServerPasswordGet r;
1580         NTSTATUS status;
1581
1582         /* In parameters */
1583         r.in.server_name = server_name;
1584         r.in.account_name = account_name;
1585         r.in.secure_channel_type = secure_channel_type;
1586         r.in.computer_name = computer_name;
1587         r.in.credential = credential;
1588
1589         if (DEBUGLEVEL >= 10) {
1590                 NDR_PRINT_IN_DEBUG(netr_ServerPasswordGet, &r);
1591         }
1592
1593         status = cli_do_rpc_ndr(cli,
1594                                 mem_ctx,
1595                                 PI_NETLOGON,
1596                                 &ndr_table_netlogon,
1597                                 NDR_NETR_SERVERPASSWORDGET,
1598                                 &r);
1599
1600         if (!NT_STATUS_IS_OK(status)) {
1601                 return status;
1602         }
1603
1604         if (DEBUGLEVEL >= 10) {
1605                 NDR_PRINT_OUT_DEBUG(netr_ServerPasswordGet, &r);
1606         }
1607
1608         if (NT_STATUS_IS_ERR(status)) {
1609                 return status;
1610         }
1611
1612         /* Return variables */
1613         *return_authenticator = *r.out.return_authenticator;
1614         *password = *r.out.password;
1615
1616         /* Return result */
1617         if (werror) {
1618                 *werror = r.out.result;
1619         }
1620
1621         return werror_to_ntstatus(r.out.result);
1622 }
1623
1624 NTSTATUS rpccli_netr_NETRLOGONSENDTOSAM(struct rpc_pipe_client *cli,
1625                                         TALLOC_CTX *mem_ctx,
1626                                         WERROR *werror)
1627 {
1628         struct netr_NETRLOGONSENDTOSAM r;
1629         NTSTATUS status;
1630
1631         /* In parameters */
1632
1633         if (DEBUGLEVEL >= 10) {
1634                 NDR_PRINT_IN_DEBUG(netr_NETRLOGONSENDTOSAM, &r);
1635         }
1636
1637         status = cli_do_rpc_ndr(cli,
1638                                 mem_ctx,
1639                                 PI_NETLOGON,
1640                                 &ndr_table_netlogon,
1641                                 NDR_NETR_NETRLOGONSENDTOSAM,
1642                                 &r);
1643
1644         if (!NT_STATUS_IS_OK(status)) {
1645                 return status;
1646         }
1647
1648         if (DEBUGLEVEL >= 10) {
1649                 NDR_PRINT_OUT_DEBUG(netr_NETRLOGONSENDTOSAM, &r);
1650         }
1651
1652         if (NT_STATUS_IS_ERR(status)) {
1653                 return status;
1654         }
1655
1656         /* Return variables */
1657
1658         /* Return result */
1659         if (werror) {
1660                 *werror = r.out.result;
1661         }
1662
1663         return werror_to_ntstatus(r.out.result);
1664 }
1665
1666 NTSTATUS rpccli_netr_DsRAddressToSitenamesW(struct rpc_pipe_client *cli,
1667                                             TALLOC_CTX *mem_ctx,
1668                                             const char *server_name,
1669                                             uint32_t count,
1670                                             struct netr_DsRAddress *addresses,
1671                                             struct netr_DsRAddressToSitenamesWCtr **ctr,
1672                                             WERROR *werror)
1673 {
1674         struct netr_DsRAddressToSitenamesW r;
1675         NTSTATUS status;
1676
1677         /* In parameters */
1678         r.in.server_name = server_name;
1679         r.in.count = count;
1680         r.in.addresses = addresses;
1681
1682         if (DEBUGLEVEL >= 10) {
1683                 NDR_PRINT_IN_DEBUG(netr_DsRAddressToSitenamesW, &r);
1684         }
1685
1686         status = cli_do_rpc_ndr(cli,
1687                                 mem_ctx,
1688                                 PI_NETLOGON,
1689                                 &ndr_table_netlogon,
1690                                 NDR_NETR_DSRADDRESSTOSITENAMESW,
1691                                 &r);
1692
1693         if (!NT_STATUS_IS_OK(status)) {
1694                 return status;
1695         }
1696
1697         if (DEBUGLEVEL >= 10) {
1698                 NDR_PRINT_OUT_DEBUG(netr_DsRAddressToSitenamesW, &r);
1699         }
1700
1701         if (NT_STATUS_IS_ERR(status)) {
1702                 return status;
1703         }
1704
1705         /* Return variables */
1706         *ctr = *r.out.ctr;
1707
1708         /* Return result */
1709         if (werror) {
1710                 *werror = r.out.result;
1711         }
1712
1713         return werror_to_ntstatus(r.out.result);
1714 }
1715
1716 NTSTATUS rpccli_netr_DsRGetDCNameEx2(struct rpc_pipe_client *cli,
1717                                      TALLOC_CTX *mem_ctx,
1718                                      const char *server_unc,
1719                                      const char *client_account,
1720                                      uint32_t mask,
1721                                      const char *domain_name,
1722                                      struct GUID *domain_guid,
1723                                      const char *site_name,
1724                                      uint32_t flags,
1725                                      struct netr_DsRGetDCNameInfo *info,
1726                                      WERROR *werror)
1727 {
1728         struct netr_DsRGetDCNameEx2 r;
1729         NTSTATUS status;
1730
1731         /* In parameters */
1732         r.in.server_unc = server_unc;
1733         r.in.client_account = client_account;
1734         r.in.mask = mask;
1735         r.in.domain_name = domain_name;
1736         r.in.domain_guid = domain_guid;
1737         r.in.site_name = site_name;
1738         r.in.flags = flags;
1739
1740         if (DEBUGLEVEL >= 10) {
1741                 NDR_PRINT_IN_DEBUG(netr_DsRGetDCNameEx2, &r);
1742         }
1743
1744         status = cli_do_rpc_ndr(cli,
1745                                 mem_ctx,
1746                                 PI_NETLOGON,
1747                                 &ndr_table_netlogon,
1748                                 NDR_NETR_DSRGETDCNAMEEX2,
1749                                 &r);
1750
1751         if (!NT_STATUS_IS_OK(status)) {
1752                 return status;
1753         }
1754
1755         if (DEBUGLEVEL >= 10) {
1756                 NDR_PRINT_OUT_DEBUG(netr_DsRGetDCNameEx2, &r);
1757         }
1758
1759         if (NT_STATUS_IS_ERR(status)) {
1760                 return status;
1761         }
1762
1763         /* Return variables */
1764         *info = *r.out.info;
1765
1766         /* Return result */
1767         if (werror) {
1768                 *werror = r.out.result;
1769         }
1770
1771         return werror_to_ntstatus(r.out.result);
1772 }
1773
1774 NTSTATUS rpccli_netr_NETRLOGONGETTIMESERVICEPARENTDOMAIN(struct rpc_pipe_client *cli,
1775                                                          TALLOC_CTX *mem_ctx,
1776                                                          WERROR *werror)
1777 {
1778         struct netr_NETRLOGONGETTIMESERVICEPARENTDOMAIN r;
1779         NTSTATUS status;
1780
1781         /* In parameters */
1782
1783         if (DEBUGLEVEL >= 10) {
1784                 NDR_PRINT_IN_DEBUG(netr_NETRLOGONGETTIMESERVICEPARENTDOMAIN, &r);
1785         }
1786
1787         status = cli_do_rpc_ndr(cli,
1788                                 mem_ctx,
1789                                 PI_NETLOGON,
1790                                 &ndr_table_netlogon,
1791                                 NDR_NETR_NETRLOGONGETTIMESERVICEPARENTDOMAIN,
1792                                 &r);
1793
1794         if (!NT_STATUS_IS_OK(status)) {
1795                 return status;
1796         }
1797
1798         if (DEBUGLEVEL >= 10) {
1799                 NDR_PRINT_OUT_DEBUG(netr_NETRLOGONGETTIMESERVICEPARENTDOMAIN, &r);
1800         }
1801
1802         if (NT_STATUS_IS_ERR(status)) {
1803                 return status;
1804         }
1805
1806         /* Return variables */
1807
1808         /* Return result */
1809         if (werror) {
1810                 *werror = r.out.result;
1811         }
1812
1813         return werror_to_ntstatus(r.out.result);
1814 }
1815
1816 NTSTATUS rpccli_netr_NetrEnumerateTrustedDomainsEx(struct rpc_pipe_client *cli,
1817                                                    TALLOC_CTX *mem_ctx,
1818                                                    const char *server_name,
1819                                                    struct netr_DomainTrustList *dom_trust_list,
1820                                                    WERROR *werror)
1821 {
1822         struct netr_NetrEnumerateTrustedDomainsEx r;
1823         NTSTATUS status;
1824
1825         /* In parameters */
1826         r.in.server_name = server_name;
1827
1828         if (DEBUGLEVEL >= 10) {
1829                 NDR_PRINT_IN_DEBUG(netr_NetrEnumerateTrustedDomainsEx, &r);
1830         }
1831
1832         status = cli_do_rpc_ndr(cli,
1833                                 mem_ctx,
1834                                 PI_NETLOGON,
1835                                 &ndr_table_netlogon,
1836                                 NDR_NETR_NETRENUMERATETRUSTEDDOMAINSEX,
1837                                 &r);
1838
1839         if (!NT_STATUS_IS_OK(status)) {
1840                 return status;
1841         }
1842
1843         if (DEBUGLEVEL >= 10) {
1844                 NDR_PRINT_OUT_DEBUG(netr_NetrEnumerateTrustedDomainsEx, &r);
1845         }
1846
1847         if (NT_STATUS_IS_ERR(status)) {
1848                 return status;
1849         }
1850
1851         /* Return variables */
1852         *dom_trust_list = *r.out.dom_trust_list;
1853
1854         /* Return result */
1855         if (werror) {
1856                 *werror = r.out.result;
1857         }
1858
1859         return werror_to_ntstatus(r.out.result);
1860 }
1861
1862 NTSTATUS rpccli_netr_DsRAddressToSitenamesExW(struct rpc_pipe_client *cli,
1863                                               TALLOC_CTX *mem_ctx,
1864                                               const char *server_name,
1865                                               uint32_t count,
1866                                               struct netr_DsRAddress *addresses,
1867                                               struct netr_DsRAddressToSitenamesExWCtr **ctr,
1868                                               WERROR *werror)
1869 {
1870         struct netr_DsRAddressToSitenamesExW r;
1871         NTSTATUS status;
1872
1873         /* In parameters */
1874         r.in.server_name = server_name;
1875         r.in.count = count;
1876         r.in.addresses = addresses;
1877
1878         if (DEBUGLEVEL >= 10) {
1879                 NDR_PRINT_IN_DEBUG(netr_DsRAddressToSitenamesExW, &r);
1880         }
1881
1882         status = cli_do_rpc_ndr(cli,
1883                                 mem_ctx,
1884                                 PI_NETLOGON,
1885                                 &ndr_table_netlogon,
1886                                 NDR_NETR_DSRADDRESSTOSITENAMESEXW,
1887                                 &r);
1888
1889         if (!NT_STATUS_IS_OK(status)) {
1890                 return status;
1891         }
1892
1893         if (DEBUGLEVEL >= 10) {
1894                 NDR_PRINT_OUT_DEBUG(netr_DsRAddressToSitenamesExW, &r);
1895         }
1896
1897         if (NT_STATUS_IS_ERR(status)) {
1898                 return status;
1899         }
1900
1901         /* Return variables */
1902         *ctr = *r.out.ctr;
1903
1904         /* Return result */
1905         if (werror) {
1906                 *werror = r.out.result;
1907         }
1908
1909         return werror_to_ntstatus(r.out.result);
1910 }
1911
1912 NTSTATUS rpccli_netr_DsrGetDcSiteCoverageW(struct rpc_pipe_client *cli,
1913                                            TALLOC_CTX *mem_ctx,
1914                                            const char *server_name,
1915                                            struct DcSitesCtr *ctr,
1916                                            WERROR *werror)
1917 {
1918         struct netr_DsrGetDcSiteCoverageW r;
1919         NTSTATUS status;
1920
1921         /* In parameters */
1922         r.in.server_name = server_name;
1923
1924         if (DEBUGLEVEL >= 10) {
1925                 NDR_PRINT_IN_DEBUG(netr_DsrGetDcSiteCoverageW, &r);
1926         }
1927
1928         status = cli_do_rpc_ndr(cli,
1929                                 mem_ctx,
1930                                 PI_NETLOGON,
1931                                 &ndr_table_netlogon,
1932                                 NDR_NETR_DSRGETDCSITECOVERAGEW,
1933                                 &r);
1934
1935         if (!NT_STATUS_IS_OK(status)) {
1936                 return status;
1937         }
1938
1939         if (DEBUGLEVEL >= 10) {
1940                 NDR_PRINT_OUT_DEBUG(netr_DsrGetDcSiteCoverageW, &r);
1941         }
1942
1943         if (NT_STATUS_IS_ERR(status)) {
1944                 return status;
1945         }
1946
1947         /* Return variables */
1948         *ctr = *r.out.ctr;
1949
1950         /* Return result */
1951         if (werror) {
1952                 *werror = r.out.result;
1953         }
1954
1955         return werror_to_ntstatus(r.out.result);
1956 }
1957
1958 NTSTATUS rpccli_netr_LogonSamLogonEx(struct rpc_pipe_client *cli,
1959                                      TALLOC_CTX *mem_ctx,
1960                                      const char *server_name,
1961                                      const char *computer_name,
1962                                      uint16_t logon_level,
1963                                      union netr_LogonLevel logon,
1964                                      uint16_t validation_level,
1965                                      union netr_Validation *validation,
1966                                      uint8_t *authoritative,
1967                                      uint32_t *flags)
1968 {
1969         struct netr_LogonSamLogonEx r;
1970         NTSTATUS status;
1971
1972         /* In parameters */
1973         r.in.server_name = server_name;
1974         r.in.computer_name = computer_name;
1975         r.in.logon_level = logon_level;
1976         r.in.logon = logon;
1977         r.in.validation_level = validation_level;
1978         r.in.flags = flags;
1979
1980         if (DEBUGLEVEL >= 10) {
1981                 NDR_PRINT_IN_DEBUG(netr_LogonSamLogonEx, &r);
1982         }
1983
1984         status = cli_do_rpc_ndr(cli,
1985                                 mem_ctx,
1986                                 PI_NETLOGON,
1987                                 &ndr_table_netlogon,
1988                                 NDR_NETR_LOGONSAMLOGONEX,
1989                                 &r);
1990
1991         if (!NT_STATUS_IS_OK(status)) {
1992                 return status;
1993         }
1994
1995         if (DEBUGLEVEL >= 10) {
1996                 NDR_PRINT_OUT_DEBUG(netr_LogonSamLogonEx, &r);
1997         }
1998
1999         if (NT_STATUS_IS_ERR(status)) {
2000                 return status;
2001         }
2002
2003         /* Return variables */
2004         *validation = *r.out.validation;
2005         *authoritative = *r.out.authoritative;
2006         *flags = *r.out.flags;
2007
2008         /* Return result */
2009         return r.out.result;
2010 }
2011
2012 NTSTATUS rpccli_netr_DsrEnumerateDomainTrusts(struct rpc_pipe_client *cli,
2013                                               TALLOC_CTX *mem_ctx,
2014                                               const char *server_name,
2015                                               uint32_t trust_flags,
2016                                               struct netr_DomainTrustList **trusts,
2017                                               WERROR *werror)
2018 {
2019         struct netr_DsrEnumerateDomainTrusts r;
2020         NTSTATUS status;
2021
2022         /* In parameters */
2023         r.in.server_name = server_name;
2024         r.in.trust_flags = trust_flags;
2025
2026         if (DEBUGLEVEL >= 10) {
2027                 NDR_PRINT_IN_DEBUG(netr_DsrEnumerateDomainTrusts, &r);
2028         }
2029
2030         status = cli_do_rpc_ndr(cli,
2031                                 mem_ctx,
2032                                 PI_NETLOGON,
2033                                 &ndr_table_netlogon,
2034                                 NDR_NETR_DSRENUMERATEDOMAINTRUSTS,
2035                                 &r);
2036
2037         if (!NT_STATUS_IS_OK(status)) {
2038                 return status;
2039         }
2040
2041         if (DEBUGLEVEL >= 10) {
2042                 NDR_PRINT_OUT_DEBUG(netr_DsrEnumerateDomainTrusts, &r);
2043         }
2044
2045         if (NT_STATUS_IS_ERR(status)) {
2046                 return status;
2047         }
2048
2049         /* Return variables */
2050         *trusts = *r.out.trusts;
2051
2052         /* Return result */
2053         if (werror) {
2054                 *werror = r.out.result;
2055         }
2056
2057         return werror_to_ntstatus(r.out.result);
2058 }
2059
2060 NTSTATUS rpccli_netr_DSRDEREGISTERDNSHOSTRECORDS(struct rpc_pipe_client *cli,
2061                                                  TALLOC_CTX *mem_ctx,
2062                                                  WERROR *werror)
2063 {
2064         struct netr_DSRDEREGISTERDNSHOSTRECORDS r;
2065         NTSTATUS status;
2066
2067         /* In parameters */
2068
2069         if (DEBUGLEVEL >= 10) {
2070                 NDR_PRINT_IN_DEBUG(netr_DSRDEREGISTERDNSHOSTRECORDS, &r);
2071         }
2072
2073         status = cli_do_rpc_ndr(cli,
2074                                 mem_ctx,
2075                                 PI_NETLOGON,
2076                                 &ndr_table_netlogon,
2077                                 NDR_NETR_DSRDEREGISTERDNSHOSTRECORDS,
2078                                 &r);
2079
2080         if (!NT_STATUS_IS_OK(status)) {
2081                 return status;
2082         }
2083
2084         if (DEBUGLEVEL >= 10) {
2085                 NDR_PRINT_OUT_DEBUG(netr_DSRDEREGISTERDNSHOSTRECORDS, &r);
2086         }
2087
2088         if (NT_STATUS_IS_ERR(status)) {
2089                 return status;
2090         }
2091
2092         /* Return variables */
2093
2094         /* Return result */
2095         if (werror) {
2096                 *werror = r.out.result;
2097         }
2098
2099         return werror_to_ntstatus(r.out.result);
2100 }
2101
2102 NTSTATUS rpccli_netr_ServerTrustPasswordsGet(struct rpc_pipe_client *cli,
2103                                              TALLOC_CTX *mem_ctx,
2104                                              const char *server_name,
2105                                              const char *account_name,
2106                                              enum netr_SchannelType secure_channel_type,
2107                                              const char *computer_name,
2108                                              struct netr_Authenticator *credential,
2109                                              struct netr_Authenticator *return_authenticator,
2110                                              struct samr_Password *password,
2111                                              struct samr_Password *password2)
2112 {
2113         struct netr_ServerTrustPasswordsGet r;
2114         NTSTATUS status;
2115
2116         /* In parameters */
2117         r.in.server_name = server_name;
2118         r.in.account_name = account_name;
2119         r.in.secure_channel_type = secure_channel_type;
2120         r.in.computer_name = computer_name;
2121         r.in.credential = credential;
2122
2123         if (DEBUGLEVEL >= 10) {
2124                 NDR_PRINT_IN_DEBUG(netr_ServerTrustPasswordsGet, &r);
2125         }
2126
2127         status = cli_do_rpc_ndr(cli,
2128                                 mem_ctx,
2129                                 PI_NETLOGON,
2130                                 &ndr_table_netlogon,
2131                                 NDR_NETR_SERVERTRUSTPASSWORDSGET,
2132                                 &r);
2133
2134         if (!NT_STATUS_IS_OK(status)) {
2135                 return status;
2136         }
2137
2138         if (DEBUGLEVEL >= 10) {
2139                 NDR_PRINT_OUT_DEBUG(netr_ServerTrustPasswordsGet, &r);
2140         }
2141
2142         if (NT_STATUS_IS_ERR(status)) {
2143                 return status;
2144         }
2145
2146         /* Return variables */
2147         *return_authenticator = *r.out.return_authenticator;
2148         *password = *r.out.password;
2149         *password2 = *r.out.password2;
2150
2151         /* Return result */
2152         return r.out.result;
2153 }
2154
2155 NTSTATUS rpccli_netr_DsRGetForestTrustInformation(struct rpc_pipe_client *cli,
2156                                                   TALLOC_CTX *mem_ctx,
2157                                                   const char *server_name,
2158                                                   const char *trusted_domain_name,
2159                                                   uint32_t flags,
2160                                                   struct lsa_ForestTrustInformation **forest_trust_info,
2161                                                   WERROR *werror)
2162 {
2163         struct netr_DsRGetForestTrustInformation r;
2164         NTSTATUS status;
2165
2166         /* In parameters */
2167         r.in.server_name = server_name;
2168         r.in.trusted_domain_name = trusted_domain_name;
2169         r.in.flags = flags;
2170
2171         if (DEBUGLEVEL >= 10) {
2172                 NDR_PRINT_IN_DEBUG(netr_DsRGetForestTrustInformation, &r);
2173         }
2174
2175         status = cli_do_rpc_ndr(cli,
2176                                 mem_ctx,
2177                                 PI_NETLOGON,
2178                                 &ndr_table_netlogon,
2179                                 NDR_NETR_DSRGETFORESTTRUSTINFORMATION,
2180                                 &r);
2181
2182         if (!NT_STATUS_IS_OK(status)) {
2183                 return status;
2184         }
2185
2186         if (DEBUGLEVEL >= 10) {
2187                 NDR_PRINT_OUT_DEBUG(netr_DsRGetForestTrustInformation, &r);
2188         }
2189
2190         if (NT_STATUS_IS_ERR(status)) {
2191                 return status;
2192         }
2193
2194         /* Return variables */
2195         *forest_trust_info = *r.out.forest_trust_info;
2196
2197         /* Return result */
2198         if (werror) {
2199                 *werror = r.out.result;
2200         }
2201
2202         return werror_to_ntstatus(r.out.result);
2203 }
2204
2205 NTSTATUS rpccli_netr_GetForestTrustInformation(struct rpc_pipe_client *cli,
2206                                                TALLOC_CTX *mem_ctx,
2207                                                const char *server_name,
2208                                                const char *trusted_domain_name,
2209                                                struct netr_Authenticator *credential,
2210                                                struct netr_Authenticator *return_authenticator,
2211                                                uint32_t flags,
2212                                                struct lsa_ForestTrustInformation **forest_trust_info,
2213                                                WERROR *werror)
2214 {
2215         struct netr_GetForestTrustInformation r;
2216         NTSTATUS status;
2217
2218         /* In parameters */
2219         r.in.server_name = server_name;
2220         r.in.trusted_domain_name = trusted_domain_name;
2221         r.in.credential = credential;
2222         r.in.flags = flags;
2223
2224         if (DEBUGLEVEL >= 10) {
2225                 NDR_PRINT_IN_DEBUG(netr_GetForestTrustInformation, &r);
2226         }
2227
2228         status = cli_do_rpc_ndr(cli,
2229                                 mem_ctx,
2230                                 PI_NETLOGON,
2231                                 &ndr_table_netlogon,
2232                                 NDR_NETR_GETFORESTTRUSTINFORMATION,
2233                                 &r);
2234
2235         if (!NT_STATUS_IS_OK(status)) {
2236                 return status;
2237         }
2238
2239         if (DEBUGLEVEL >= 10) {
2240                 NDR_PRINT_OUT_DEBUG(netr_GetForestTrustInformation, &r);
2241         }
2242
2243         if (NT_STATUS_IS_ERR(status)) {
2244                 return status;
2245         }
2246
2247         /* Return variables */
2248         *return_authenticator = *r.out.return_authenticator;
2249         *forest_trust_info = *r.out.forest_trust_info;
2250
2251         /* Return result */
2252         if (werror) {
2253                 *werror = r.out.result;
2254         }
2255
2256         return werror_to_ntstatus(r.out.result);
2257 }
2258
2259 NTSTATUS rpccli_netr_LogonSamLogonWithFlags(struct rpc_pipe_client *cli,
2260                                             TALLOC_CTX *mem_ctx,
2261                                             const char *server_name,
2262                                             const char *computer_name,
2263                                             struct netr_Authenticator *credential,
2264                                             struct netr_Authenticator *return_authenticator,
2265                                             uint16_t logon_level,
2266                                             union netr_LogonLevel logon,
2267                                             uint16_t validation_level,
2268                                             union netr_Validation *validation,
2269                                             uint8_t *authoritative,
2270                                             uint32_t *flags)
2271 {
2272         struct netr_LogonSamLogonWithFlags r;
2273         NTSTATUS status;
2274
2275         /* In parameters */
2276         r.in.server_name = server_name;
2277         r.in.computer_name = computer_name;
2278         r.in.credential = credential;
2279         r.in.return_authenticator = return_authenticator;
2280         r.in.logon_level = logon_level;
2281         r.in.logon = logon;
2282         r.in.validation_level = validation_level;
2283         r.in.flags = flags;
2284
2285         if (DEBUGLEVEL >= 10) {
2286                 NDR_PRINT_IN_DEBUG(netr_LogonSamLogonWithFlags, &r);
2287         }
2288
2289         status = cli_do_rpc_ndr(cli,
2290                                 mem_ctx,
2291                                 PI_NETLOGON,
2292                                 &ndr_table_netlogon,
2293                                 NDR_NETR_LOGONSAMLOGONWITHFLAGS,
2294                                 &r);
2295
2296         if (!NT_STATUS_IS_OK(status)) {
2297                 return status;
2298         }
2299
2300         if (DEBUGLEVEL >= 10) {
2301                 NDR_PRINT_OUT_DEBUG(netr_LogonSamLogonWithFlags, &r);
2302         }
2303
2304         if (NT_STATUS_IS_ERR(status)) {
2305                 return status;
2306         }
2307
2308         /* Return variables */
2309         if (return_authenticator && r.out.return_authenticator) {
2310                 *return_authenticator = *r.out.return_authenticator;
2311         }
2312         *validation = *r.out.validation;
2313         *authoritative = *r.out.authoritative;
2314         *flags = *r.out.flags;
2315
2316         /* Return result */
2317         return r.out.result;
2318 }
2319
2320 NTSTATUS rpccli_netr_NETRSERVERGETTRUSTINFO(struct rpc_pipe_client *cli,
2321                                             TALLOC_CTX *mem_ctx,
2322                                             WERROR *werror)
2323 {
2324         struct netr_NETRSERVERGETTRUSTINFO r;
2325         NTSTATUS status;
2326
2327         /* In parameters */
2328
2329         if (DEBUGLEVEL >= 10) {
2330                 NDR_PRINT_IN_DEBUG(netr_NETRSERVERGETTRUSTINFO, &r);
2331         }
2332
2333         status = cli_do_rpc_ndr(cli,
2334                                 mem_ctx,
2335                                 PI_NETLOGON,
2336                                 &ndr_table_netlogon,
2337                                 NDR_NETR_NETRSERVERGETTRUSTINFO,
2338                                 &r);
2339
2340         if (!NT_STATUS_IS_OK(status)) {
2341                 return status;
2342         }
2343
2344         if (DEBUGLEVEL >= 10) {
2345                 NDR_PRINT_OUT_DEBUG(netr_NETRSERVERGETTRUSTINFO, &r);
2346         }
2347
2348         if (NT_STATUS_IS_ERR(status)) {
2349                 return status;
2350         }
2351
2352         /* Return variables */
2353
2354         /* Return result */
2355         if (werror) {
2356                 *werror = r.out.result;
2357         }
2358
2359         return werror_to_ntstatus(r.out.result);
2360 }
2361