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