02d8fb2e65105617ac8064d6ec94bda54c0eaf7f
[sfrench/samba-autobuild/.git] / 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