source3/librpc/gen_ndr/cli_eventlog.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_eventlog.h"
   8
   9 NTSTATUS rpccli_eventlog_ClearEventLogW(struct rpc_pipe_client *cli,
  10                                         TALLOC_CTX *mem_ctx,
  11                                         struct policy_handle *handle,
  12                                         struct lsa_String *backupfile)
  13 {
  14         struct eventlog_ClearEventLogW r;
  15         NTSTATUS status;
  16
  17         /* In parameters */
  18         r.in.handle = handle;
  19         r.in.backupfile = backupfile;
  20
  21         if (DEBUGLEVEL >= 10) {
  22                 NDR_PRINT_IN_DEBUG(eventlog_ClearEventLogW, &r);
  23         }
  24
  25         status = cli_do_rpc_ndr(cli,
  26                                 mem_ctx,
  27                                 PI_EVENTLOG,
  28                                 &ndr_table_eventlog,
  29                                 NDR_EVENTLOG_CLEAREVENTLOGW,
  30                                 &r);
  31
  32         if (!NT_STATUS_IS_OK(status)) {
  33                 return status;
  34         }
  35
  36         if (DEBUGLEVEL >= 10) {
  37                 NDR_PRINT_OUT_DEBUG(eventlog_ClearEventLogW, &r);
  38         }
  39
  40         if (NT_STATUS_IS_ERR(status)) {
  41                 return status;
  42         }
  43
  44         /* Return variables */
  45
  46         /* Return result */
  47         return r.out.result;
  48 }
  49
  50 NTSTATUS rpccli_eventlog_BackupEventLogW(struct rpc_pipe_client *cli,
  51                                          TALLOC_CTX *mem_ctx)
  52 {
  53         struct eventlog_BackupEventLogW r;
  54         NTSTATUS status;
  55
  56         /* In parameters */
  57
  58         if (DEBUGLEVEL >= 10) {
  59                 NDR_PRINT_IN_DEBUG(eventlog_BackupEventLogW, &r);
  60         }
  61
  62         status = cli_do_rpc_ndr(cli,
  63                                 mem_ctx,
  64                                 PI_EVENTLOG,
  65                                 &ndr_table_eventlog,
  66                                 NDR_EVENTLOG_BACKUPEVENTLOGW,
  67                                 &r);
  68
  69         if (!NT_STATUS_IS_OK(status)) {
  70                 return status;
  71         }
  72
  73         if (DEBUGLEVEL >= 10) {
  74                 NDR_PRINT_OUT_DEBUG(eventlog_BackupEventLogW, &r);
  75         }
  76
  77         if (NT_STATUS_IS_ERR(status)) {
  78                 return status;
  79         }
  80
  81         /* Return variables */
  82
  83         /* Return result */
  84         return r.out.result;
  85 }
  86
  87 NTSTATUS rpccli_eventlog_CloseEventLog(struct rpc_pipe_client *cli,
  88                                        TALLOC_CTX *mem_ctx,
  89                                        struct policy_handle *handle)
  90 {
  91         struct eventlog_CloseEventLog r;
  92         NTSTATUS status;
  93
  94         /* In parameters */
  95         r.in.handle = handle;
  96
  97         if (DEBUGLEVEL >= 10) {
  98                 NDR_PRINT_IN_DEBUG(eventlog_CloseEventLog, &r);
  99         }
 100
 101         status = cli_do_rpc_ndr(cli,
 102                                 mem_ctx,
 103                                 PI_EVENTLOG,
 104                                 &ndr_table_eventlog,
 105                                 NDR_EVENTLOG_CLOSEEVENTLOG,
 106                                 &r);
 107
 108         if (!NT_STATUS_IS_OK(status)) {
 109                 return status;
 110         }
 111
 112         if (DEBUGLEVEL >= 10) {
 113                 NDR_PRINT_OUT_DEBUG(eventlog_CloseEventLog, &r);
 114         }
 115
 116         if (NT_STATUS_IS_ERR(status)) {
 117                 return status;
 118         }
 119
 120         /* Return variables */
 121         *handle = *r.out.handle;
 122
 123         /* Return result */
 124         return r.out.result;
 125 }
 126
 127 NTSTATUS rpccli_eventlog_DeregisterEventSource(struct rpc_pipe_client *cli,
 128                                                TALLOC_CTX *mem_ctx)
 129 {
 130         struct eventlog_DeregisterEventSource r;
 131         NTSTATUS status;
 132
 133         /* In parameters */
 134
 135         if (DEBUGLEVEL >= 10) {
 136                 NDR_PRINT_IN_DEBUG(eventlog_DeregisterEventSource, &r);
 137         }
 138
 139         status = cli_do_rpc_ndr(cli,
 140                                 mem_ctx,
 141                                 PI_EVENTLOG,
 142                                 &ndr_table_eventlog,
 143                                 NDR_EVENTLOG_DEREGISTEREVENTSOURCE,
 144                                 &r);
 145
 146         if (!NT_STATUS_IS_OK(status)) {
 147                 return status;
 148         }
 149
 150         if (DEBUGLEVEL >= 10) {
 151                 NDR_PRINT_OUT_DEBUG(eventlog_DeregisterEventSource, &r);
 152         }
 153
 154         if (NT_STATUS_IS_ERR(status)) {
 155                 return status;
 156         }
 157
 158         /* Return variables */
 159
 160         /* Return result */
 161         return r.out.result;
 162 }
 163
 164 NTSTATUS rpccli_eventlog_GetNumRecords(struct rpc_pipe_client *cli,
 165                                        TALLOC_CTX *mem_ctx,
 166                                        struct policy_handle *handle,
 167                                        uint32_t *number)
 168 {
 169         struct eventlog_GetNumRecords r;
 170         NTSTATUS status;
 171
 172         /* In parameters */
 173         r.in.handle = handle;
 174
 175         if (DEBUGLEVEL >= 10) {
 176                 NDR_PRINT_IN_DEBUG(eventlog_GetNumRecords, &r);
 177         }
 178
 179         status = cli_do_rpc_ndr(cli,
 180                                 mem_ctx,
 181                                 PI_EVENTLOG,
 182                                 &ndr_table_eventlog,
 183                                 NDR_EVENTLOG_GETNUMRECORDS,
 184                                 &r);
 185
 186         if (!NT_STATUS_IS_OK(status)) {
 187                 return status;
 188         }
 189
 190         if (DEBUGLEVEL >= 10) {
 191                 NDR_PRINT_OUT_DEBUG(eventlog_GetNumRecords, &r);
 192         }
 193
 194         if (NT_STATUS_IS_ERR(status)) {
 195                 return status;
 196         }
 197
 198         /* Return variables */
 199         *number = *r.out.number;
 200
 201         /* Return result */
 202         return r.out.result;
 203 }
 204
 205 NTSTATUS rpccli_eventlog_GetOldestRecord(struct rpc_pipe_client *cli,
 206                                          TALLOC_CTX *mem_ctx,
 207                                          struct policy_handle *handle,
 208                                          uint32_t *oldest_entry)
 209 {
 210         struct eventlog_GetOldestRecord r;
 211         NTSTATUS status;
 212
 213         /* In parameters */
 214         r.in.handle = handle;
 215
 216         if (DEBUGLEVEL >= 10) {
 217                 NDR_PRINT_IN_DEBUG(eventlog_GetOldestRecord, &r);
 218         }
 219
 220         status = cli_do_rpc_ndr(cli,
 221                                 mem_ctx,
 222                                 PI_EVENTLOG,
 223                                 &ndr_table_eventlog,
 224                                 NDR_EVENTLOG_GETOLDESTRECORD,
 225                                 &r);
 226
 227         if (!NT_STATUS_IS_OK(status)) {
 228                 return status;
 229         }
 230
 231         if (DEBUGLEVEL >= 10) {
 232                 NDR_PRINT_OUT_DEBUG(eventlog_GetOldestRecord, &r);
 233         }
 234
 235         if (NT_STATUS_IS_ERR(status)) {
 236                 return status;
 237         }
 238
 239         /* Return variables */
 240         *oldest_entry = *r.out.oldest_entry;
 241
 242         /* Return result */
 243         return r.out.result;
 244 }
 245
 246 NTSTATUS rpccli_eventlog_ChangeNotify(struct rpc_pipe_client *cli,
 247                                       TALLOC_CTX *mem_ctx)
 248 {
 249         struct eventlog_ChangeNotify r;
 250         NTSTATUS status;
 251
 252         /* In parameters */
 253
 254         if (DEBUGLEVEL >= 10) {
 255                 NDR_PRINT_IN_DEBUG(eventlog_ChangeNotify, &r);
 256         }
 257
 258         status = cli_do_rpc_ndr(cli,
 259                                 mem_ctx,
 260                                 PI_EVENTLOG,
 261                                 &ndr_table_eventlog,
 262                                 NDR_EVENTLOG_CHANGENOTIFY,
 263                                 &r);
 264
 265         if (!NT_STATUS_IS_OK(status)) {
 266                 return status;
 267         }
 268
 269         if (DEBUGLEVEL >= 10) {
 270                 NDR_PRINT_OUT_DEBUG(eventlog_ChangeNotify, &r);
 271         }
 272
 273         if (NT_STATUS_IS_ERR(status)) {
 274                 return status;
 275         }
 276
 277         /* Return variables */
 278
 279         /* Return result */
 280         return r.out.result;
 281 }
 282
 283 NTSTATUS rpccli_eventlog_OpenEventLogW(struct rpc_pipe_client *cli,
 284                                        TALLOC_CTX *mem_ctx,
 285                                        struct eventlog_OpenUnknown0 *unknown0,
 286                                        struct lsa_String *logname,
 287                                        struct lsa_String *servername,
 288                                        uint32_t unknown2,
 289                                        uint32_t unknown3,
 290                                        struct policy_handle *handle)
 291 {
 292         struct eventlog_OpenEventLogW r;
 293         NTSTATUS status;
 294
 295         /* In parameters */
 296         r.in.unknown0 = unknown0;
 297         r.in.logname = logname;
 298         r.in.servername = servername;
 299         r.in.unknown2 = unknown2;
 300         r.in.unknown3 = unknown3;
 301
 302         if (DEBUGLEVEL >= 10) {
 303                 NDR_PRINT_IN_DEBUG(eventlog_OpenEventLogW, &r);
 304         }
 305
 306         status = cli_do_rpc_ndr(cli,
 307                                 mem_ctx,
 308                                 PI_EVENTLOG,
 309                                 &ndr_table_eventlog,
 310                                 NDR_EVENTLOG_OPENEVENTLOGW,
 311                                 &r);
 312
 313         if (!NT_STATUS_IS_OK(status)) {
 314                 return status;
 315         }
 316
 317         if (DEBUGLEVEL >= 10) {
 318                 NDR_PRINT_OUT_DEBUG(eventlog_OpenEventLogW, &r);
 319         }
 320
 321         if (NT_STATUS_IS_ERR(status)) {
 322                 return status;
 323         }
 324
 325         /* Return variables */
 326         *handle = *r.out.handle;
 327
 328         /* Return result */
 329         return r.out.result;
 330 }
 331
 332 NTSTATUS rpccli_eventlog_RegisterEventSourceW(struct rpc_pipe_client *cli,
 333                                               TALLOC_CTX *mem_ctx)
 334 {
 335         struct eventlog_RegisterEventSourceW r;
 336         NTSTATUS status;
 337
 338         /* In parameters */
 339
 340         if (DEBUGLEVEL >= 10) {
 341                 NDR_PRINT_IN_DEBUG(eventlog_RegisterEventSourceW, &r);
 342         }
 343
 344         status = cli_do_rpc_ndr(cli,
 345                                 mem_ctx,
 346                                 PI_EVENTLOG,
 347                                 &ndr_table_eventlog,
 348                                 NDR_EVENTLOG_REGISTEREVENTSOURCEW,
 349                                 &r);
 350
 351         if (!NT_STATUS_IS_OK(status)) {
 352                 return status;
 353         }
 354
 355         if (DEBUGLEVEL >= 10) {
 356                 NDR_PRINT_OUT_DEBUG(eventlog_RegisterEventSourceW, &r);
 357         }
 358
 359         if (NT_STATUS_IS_ERR(status)) {
 360                 return status;
 361         }
 362
 363         /* Return variables */
 364
 365         /* Return result */
 366         return r.out.result;
 367 }
 368
 369 NTSTATUS rpccli_eventlog_OpenBackupEventLogW(struct rpc_pipe_client *cli,
 370                                              TALLOC_CTX *mem_ctx)
 371 {
 372         struct eventlog_OpenBackupEventLogW r;
 373         NTSTATUS status;
 374
 375         /* In parameters */
 376
 377         if (DEBUGLEVEL >= 10) {
 378                 NDR_PRINT_IN_DEBUG(eventlog_OpenBackupEventLogW, &r);
 379         }
 380
 381         status = cli_do_rpc_ndr(cli,
 382                                 mem_ctx,
 383                                 PI_EVENTLOG,
 384                                 &ndr_table_eventlog,
 385                                 NDR_EVENTLOG_OPENBACKUPEVENTLOGW,
 386                                 &r);
 387
 388         if (!NT_STATUS_IS_OK(status)) {
 389                 return status;
 390         }
 391
 392         if (DEBUGLEVEL >= 10) {
 393                 NDR_PRINT_OUT_DEBUG(eventlog_OpenBackupEventLogW, &r);
 394         }
 395
 396         if (NT_STATUS_IS_ERR(status)) {
 397                 return status;
 398         }
 399
 400         /* Return variables */
 401
 402         /* Return result */
 403         return r.out.result;
 404 }
 405
 406 NTSTATUS rpccli_eventlog_ReadEventLogW(struct rpc_pipe_client *cli,
 407                                        TALLOC_CTX *mem_ctx,
 408                                        struct policy_handle *handle,
 409                                        uint32_t flags,
 410                                        uint32_t offset,
 411                                        uint32_t number_of_bytes,
 412                                        uint8_t *data,
 413                                        uint32_t *sent_size,
 414                                        uint32_t *real_size)
 415 {
 416         struct eventlog_ReadEventLogW r;
 417         NTSTATUS status;
 418
 419         /* In parameters */
 420         r.in.handle = handle;
 421         r.in.flags = flags;
 422         r.in.offset = offset;
 423         r.in.number_of_bytes = number_of_bytes;
 424
 425         if (DEBUGLEVEL >= 10) {
 426                 NDR_PRINT_IN_DEBUG(eventlog_ReadEventLogW, &r);
 427         }
 428
 429         status = cli_do_rpc_ndr(cli,
 430                                 mem_ctx,
 431                                 PI_EVENTLOG,
 432                                 &ndr_table_eventlog,
 433                                 NDR_EVENTLOG_READEVENTLOGW,
 434                                 &r);
 435
 436         if (!NT_STATUS_IS_OK(status)) {
 437                 return status;
 438         }
 439
 440         if (DEBUGLEVEL >= 10) {
 441                 NDR_PRINT_OUT_DEBUG(eventlog_ReadEventLogW, &r);
 442         }
 443
 444         if (NT_STATUS_IS_ERR(status)) {
 445                 return status;
 446         }
 447
 448         /* Return variables */
 449         memcpy(data, r.out.data, r.in.number_of_bytes);
 450         *sent_size = *r.out.sent_size;
 451         *real_size = *r.out.real_size;
 452
 453         /* Return result */
 454         return r.out.result;
 455 }
 456
 457 NTSTATUS rpccli_eventlog_ReportEventW(struct rpc_pipe_client *cli,
 458                                       TALLOC_CTX *mem_ctx)
 459 {
 460         struct eventlog_ReportEventW r;
 461         NTSTATUS status;
 462
 463         /* In parameters */
 464
 465         if (DEBUGLEVEL >= 10) {
 466                 NDR_PRINT_IN_DEBUG(eventlog_ReportEventW, &r);
 467         }
 468
 469         status = cli_do_rpc_ndr(cli,
 470                                 mem_ctx,
 471                                 PI_EVENTLOG,
 472                                 &ndr_table_eventlog,
 473                                 NDR_EVENTLOG_REPORTEVENTW,
 474                                 &r);
 475
 476         if (!NT_STATUS_IS_OK(status)) {
 477                 return status;
 478         }
 479
 480         if (DEBUGLEVEL >= 10) {
 481                 NDR_PRINT_OUT_DEBUG(eventlog_ReportEventW, &r);
 482         }
 483
 484         if (NT_STATUS_IS_ERR(status)) {
 485                 return status;
 486         }
 487
 488         /* Return variables */
 489
 490         /* Return result */
 491         return r.out.result;
 492 }
 493
 494 NTSTATUS rpccli_eventlog_ClearEventLogA(struct rpc_pipe_client *cli,
 495                                         TALLOC_CTX *mem_ctx)
 496 {
 497         struct eventlog_ClearEventLogA r;
 498         NTSTATUS status;
 499
 500         /* In parameters */
 501
 502         if (DEBUGLEVEL >= 10) {
 503                 NDR_PRINT_IN_DEBUG(eventlog_ClearEventLogA, &r);
 504         }
 505
 506         status = cli_do_rpc_ndr(cli,
 507                                 mem_ctx,
 508                                 PI_EVENTLOG,
 509                                 &ndr_table_eventlog,
 510                                 NDR_EVENTLOG_CLEAREVENTLOGA,
 511                                 &r);
 512
 513         if (!NT_STATUS_IS_OK(status)) {
 514                 return status;
 515         }
 516
 517         if (DEBUGLEVEL >= 10) {
 518                 NDR_PRINT_OUT_DEBUG(eventlog_ClearEventLogA, &r);
 519         }
 520
 521         if (NT_STATUS_IS_ERR(status)) {
 522                 return status;
 523         }
 524
 525         /* Return variables */
 526
 527         /* Return result */
 528         return r.out.result;
 529 }
 530
 531 NTSTATUS rpccli_eventlog_BackupEventLogA(struct rpc_pipe_client *cli,
 532                                          TALLOC_CTX *mem_ctx)
 533 {
 534         struct eventlog_BackupEventLogA r;
 535         NTSTATUS status;
 536
 537         /* In parameters */
 538
 539         if (DEBUGLEVEL >= 10) {
 540                 NDR_PRINT_IN_DEBUG(eventlog_BackupEventLogA, &r);
 541         }
 542
 543         status = cli_do_rpc_ndr(cli,
 544                                 mem_ctx,
 545                                 PI_EVENTLOG,
 546                                 &ndr_table_eventlog,
 547                                 NDR_EVENTLOG_BACKUPEVENTLOGA,
 548                                 &r);
 549
 550         if (!NT_STATUS_IS_OK(status)) {
 551                 return status;
 552         }
 553
 554         if (DEBUGLEVEL >= 10) {
 555                 NDR_PRINT_OUT_DEBUG(eventlog_BackupEventLogA, &r);
 556         }
 557
 558         if (NT_STATUS_IS_ERR(status)) {
 559                 return status;
 560         }
 561
 562         /* Return variables */
 563
 564         /* Return result */
 565         return r.out.result;
 566 }
 567
 568 NTSTATUS rpccli_eventlog_OpenEventLogA(struct rpc_pipe_client *cli,
 569                                        TALLOC_CTX *mem_ctx)
 570 {
 571         struct eventlog_OpenEventLogA r;
 572         NTSTATUS status;
 573
 574         /* In parameters */
 575
 576         if (DEBUGLEVEL >= 10) {
 577                 NDR_PRINT_IN_DEBUG(eventlog_OpenEventLogA, &r);
 578         }
 579
 580         status = cli_do_rpc_ndr(cli,
 581                                 mem_ctx,
 582                                 PI_EVENTLOG,
 583                                 &ndr_table_eventlog,
 584                                 NDR_EVENTLOG_OPENEVENTLOGA,
 585                                 &r);
 586
 587         if (!NT_STATUS_IS_OK(status)) {
 588                 return status;
 589         }
 590
 591         if (DEBUGLEVEL >= 10) {
 592                 NDR_PRINT_OUT_DEBUG(eventlog_OpenEventLogA, &r);
 593         }
 594
 595         if (NT_STATUS_IS_ERR(status)) {
 596                 return status;
 597         }
 598
 599         /* Return variables */
 600
 601         /* Return result */
 602         return r.out.result;
 603 }
 604
 605 NTSTATUS rpccli_eventlog_RegisterEventSourceA(struct rpc_pipe_client *cli,
 606                                               TALLOC_CTX *mem_ctx)
 607 {
 608         struct eventlog_RegisterEventSourceA r;
 609         NTSTATUS status;
 610
 611         /* In parameters */
 612
 613         if (DEBUGLEVEL >= 10) {
 614                 NDR_PRINT_IN_DEBUG(eventlog_RegisterEventSourceA, &r);
 615         }
 616
 617         status = cli_do_rpc_ndr(cli,
 618                                 mem_ctx,
 619                                 PI_EVENTLOG,
 620                                 &ndr_table_eventlog,
 621                                 NDR_EVENTLOG_REGISTEREVENTSOURCEA,
 622                                 &r);
 623
 624         if (!NT_STATUS_IS_OK(status)) {
 625                 return status;
 626         }
 627
 628         if (DEBUGLEVEL >= 10) {
 629                 NDR_PRINT_OUT_DEBUG(eventlog_RegisterEventSourceA, &r);
 630         }
 631
 632         if (NT_STATUS_IS_ERR(status)) {
 633                 return status;
 634         }
 635
 636         /* Return variables */
 637
 638         /* Return result */
 639         return r.out.result;
 640 }
 641
 642 NTSTATUS rpccli_eventlog_OpenBackupEventLogA(struct rpc_pipe_client *cli,
 643                                              TALLOC_CTX *mem_ctx)
 644 {
 645         struct eventlog_OpenBackupEventLogA r;
 646         NTSTATUS status;
 647
 648         /* In parameters */
 649
 650         if (DEBUGLEVEL >= 10) {
 651                 NDR_PRINT_IN_DEBUG(eventlog_OpenBackupEventLogA, &r);
 652         }
 653
 654         status = cli_do_rpc_ndr(cli,
 655                                 mem_ctx,
 656                                 PI_EVENTLOG,
 657                                 &ndr_table_eventlog,
 658                                 NDR_EVENTLOG_OPENBACKUPEVENTLOGA,
 659                                 &r);
 660
 661         if (!NT_STATUS_IS_OK(status)) {
 662                 return status;
 663         }
 664
 665         if (DEBUGLEVEL >= 10) {
 666                 NDR_PRINT_OUT_DEBUG(eventlog_OpenBackupEventLogA, &r);
 667         }
 668
 669         if (NT_STATUS_IS_ERR(status)) {
 670                 return status;
 671         }
 672
 673         /* Return variables */
 674
 675         /* Return result */
 676         return r.out.result;
 677 }
 678
 679 NTSTATUS rpccli_eventlog_ReadEventLogA(struct rpc_pipe_client *cli,
 680                                        TALLOC_CTX *mem_ctx)
 681 {
 682         struct eventlog_ReadEventLogA r;
 683         NTSTATUS status;
 684
 685         /* In parameters */
 686
 687         if (DEBUGLEVEL >= 10) {
 688                 NDR_PRINT_IN_DEBUG(eventlog_ReadEventLogA, &r);
 689         }
 690
 691         status = cli_do_rpc_ndr(cli,
 692                                 mem_ctx,
 693                                 PI_EVENTLOG,
 694                                 &ndr_table_eventlog,
 695                                 NDR_EVENTLOG_READEVENTLOGA,
 696                                 &r);
 697
 698         if (!NT_STATUS_IS_OK(status)) {
 699                 return status;
 700         }
 701
 702         if (DEBUGLEVEL >= 10) {
 703                 NDR_PRINT_OUT_DEBUG(eventlog_ReadEventLogA, &r);
 704         }
 705
 706         if (NT_STATUS_IS_ERR(status)) {
 707                 return status;
 708         }
 709
 710         /* Return variables */
 711
 712         /* Return result */
 713         return r.out.result;
 714 }
 715
 716 NTSTATUS rpccli_eventlog_ReportEventA(struct rpc_pipe_client *cli,
 717                                       TALLOC_CTX *mem_ctx)
 718 {
 719         struct eventlog_ReportEventA r;
 720         NTSTATUS status;
 721
 722         /* In parameters */
 723
 724         if (DEBUGLEVEL >= 10) {
 725                 NDR_PRINT_IN_DEBUG(eventlog_ReportEventA, &r);
 726         }
 727
 728         status = cli_do_rpc_ndr(cli,
 729                                 mem_ctx,
 730                                 PI_EVENTLOG,
 731                                 &ndr_table_eventlog,
 732                                 NDR_EVENTLOG_REPORTEVENTA,
 733                                 &r);
 734
 735         if (!NT_STATUS_IS_OK(status)) {
 736                 return status;
 737         }
 738
 739         if (DEBUGLEVEL >= 10) {
 740                 NDR_PRINT_OUT_DEBUG(eventlog_ReportEventA, &r);
 741         }
 742
 743         if (NT_STATUS_IS_ERR(status)) {
 744                 return status;
 745         }
 746
 747         /* Return variables */
 748
 749         /* Return result */
 750         return r.out.result;
 751 }
 752
 753 NTSTATUS rpccli_eventlog_RegisterClusterSvc(struct rpc_pipe_client *cli,
 754                                             TALLOC_CTX *mem_ctx)
 755 {
 756         struct eventlog_RegisterClusterSvc r;
 757         NTSTATUS status;
 758
 759         /* In parameters */
 760
 761         if (DEBUGLEVEL >= 10) {
 762                 NDR_PRINT_IN_DEBUG(eventlog_RegisterClusterSvc, &r);
 763         }
 764
 765         status = cli_do_rpc_ndr(cli,
 766                                 mem_ctx,
 767                                 PI_EVENTLOG,
 768                                 &ndr_table_eventlog,
 769                                 NDR_EVENTLOG_REGISTERCLUSTERSVC,
 770                                 &r);
 771
 772         if (!NT_STATUS_IS_OK(status)) {
 773                 return status;
 774         }
 775
 776         if (DEBUGLEVEL >= 10) {
 777                 NDR_PRINT_OUT_DEBUG(eventlog_RegisterClusterSvc, &r);
 778         }
 779
 780         if (NT_STATUS_IS_ERR(status)) {
 781                 return status;
 782         }
 783
 784         /* Return variables */
 785
 786         /* Return result */
 787         return r.out.result;
 788 }
 789
 790 NTSTATUS rpccli_eventlog_DeregisterClusterSvc(struct rpc_pipe_client *cli,
 791                                               TALLOC_CTX *mem_ctx)
 792 {
 793         struct eventlog_DeregisterClusterSvc r;
 794         NTSTATUS status;
 795
 796         /* In parameters */
 797
 798         if (DEBUGLEVEL >= 10) {
 799                 NDR_PRINT_IN_DEBUG(eventlog_DeregisterClusterSvc, &r);
 800         }
 801
 802         status = cli_do_rpc_ndr(cli,
 803                                 mem_ctx,
 804                                 PI_EVENTLOG,
 805                                 &ndr_table_eventlog,
 806                                 NDR_EVENTLOG_DEREGISTERCLUSTERSVC,
 807                                 &r);
 808
 809         if (!NT_STATUS_IS_OK(status)) {
 810                 return status;
 811         }
 812
 813         if (DEBUGLEVEL >= 10) {
 814                 NDR_PRINT_OUT_DEBUG(eventlog_DeregisterClusterSvc, &r);
 815         }
 816
 817         if (NT_STATUS_IS_ERR(status)) {
 818                 return status;
 819         }
 820
 821         /* Return variables */
 822
 823         /* Return result */
 824         return r.out.result;
 825 }
 826
 827 NTSTATUS rpccli_eventlog_WriteClusterEvents(struct rpc_pipe_client *cli,
 828                                             TALLOC_CTX *mem_ctx)
 829 {
 830         struct eventlog_WriteClusterEvents r;
 831         NTSTATUS status;
 832
 833         /* In parameters */
 834
 835         if (DEBUGLEVEL >= 10) {
 836                 NDR_PRINT_IN_DEBUG(eventlog_WriteClusterEvents, &r);
 837         }
 838
 839         status = cli_do_rpc_ndr(cli,
 840                                 mem_ctx,
 841                                 PI_EVENTLOG,
 842                                 &ndr_table_eventlog,
 843                                 NDR_EVENTLOG_WRITECLUSTEREVENTS,
 844                                 &r);
 845
 846         if (!NT_STATUS_IS_OK(status)) {
 847                 return status;
 848         }
 849
 850         if (DEBUGLEVEL >= 10) {
 851                 NDR_PRINT_OUT_DEBUG(eventlog_WriteClusterEvents, &r);
 852         }
 853
 854         if (NT_STATUS_IS_ERR(status)) {
 855                 return status;
 856         }
 857
 858         /* Return variables */
 859
 860         /* Return result */
 861         return r.out.result;
 862 }
 863
 864 NTSTATUS rpccli_eventlog_GetLogIntormation(struct rpc_pipe_client *cli,
 865                                            TALLOC_CTX *mem_ctx)
 866 {
 867         struct eventlog_GetLogIntormation r;
 868         NTSTATUS status;
 869
 870         /* In parameters */
 871
 872         if (DEBUGLEVEL >= 10) {
 873                 NDR_PRINT_IN_DEBUG(eventlog_GetLogIntormation, &r);
 874         }
 875
 876         status = cli_do_rpc_ndr(cli,
 877                                 mem_ctx,
 878                                 PI_EVENTLOG,
 879                                 &ndr_table_eventlog,
 880                                 NDR_EVENTLOG_GETLOGINTORMATION,
 881                                 &r);
 882
 883         if (!NT_STATUS_IS_OK(status)) {
 884                 return status;
 885         }
 886
 887         if (DEBUGLEVEL >= 10) {
 888                 NDR_PRINT_OUT_DEBUG(eventlog_GetLogIntormation, &r);
 889         }
 890
 891         if (NT_STATUS_IS_ERR(status)) {
 892                 return status;
 893         }
 894
 895         /* Return variables */
 896
 897         /* Return result */
 898         return r.out.result;
 899 }
 900
 901 NTSTATUS rpccli_eventlog_FlushEventLog(struct rpc_pipe_client *cli,
 902                                        TALLOC_CTX *mem_ctx,
 903                                        struct policy_handle *handle)
 904 {
 905         struct eventlog_FlushEventLog r;
 906         NTSTATUS status;
 907
 908         /* In parameters */
 909         r.in.handle = handle;
 910
 911         if (DEBUGLEVEL >= 10) {
 912                 NDR_PRINT_IN_DEBUG(eventlog_FlushEventLog, &r);
 913         }
 914
 915         status = cli_do_rpc_ndr(cli,
 916                                 mem_ctx,
 917                                 PI_EVENTLOG,
 918                                 &ndr_table_eventlog,
 919                                 NDR_EVENTLOG_FLUSHEVENTLOG,
 920                                 &r);
 921
 922         if (!NT_STATUS_IS_OK(status)) {
 923                 return status;
 924         }
 925
 926         if (DEBUGLEVEL >= 10) {
 927                 NDR_PRINT_OUT_DEBUG(eventlog_FlushEventLog, &r);
 928         }
 929
 930         if (NT_STATUS_IS_ERR(status)) {
 931                 return status;
 932         }
 933
 934         /* Return variables */
 935
 936         /* Return result */
 937         return r.out.result;
 938 }
 939