2 * Unix SMB/CIFS implementation.
3 * server auto-generated by pidl. DO NOT MODIFY!
7 #include "librpc/gen_ndr/srv_eventlog.h"
9 static bool api_eventlog_ClearEventLogW(pipes_struct *p)
11 const struct ndr_interface_call *call;
12 struct ndr_pull *pull;
13 struct ndr_push *push;
14 enum ndr_err_code ndr_err;
16 struct eventlog_ClearEventLogW *r;
18 call = &ndr_table_eventlog.calls[NDR_EVENTLOG_CLEAREVENTLOGW];
20 r = talloc(NULL, struct eventlog_ClearEventLogW);
25 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
30 pull = ndr_pull_init_blob(&blob, r);
36 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
37 ndr_err = call->ndr_pull(pull, NDR_IN, r);
38 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
43 if (DEBUGLEVEL >= 10) {
44 NDR_PRINT_IN_DEBUG(eventlog_ClearEventLogW, r);
47 r->out.result = _eventlog_ClearEventLogW(p, r);
49 if (p->rng_fault_state) {
51 /* Return true here, srv_pipe_hnd.c will take care */
55 if (DEBUGLEVEL >= 10) {
56 NDR_PRINT_OUT_DEBUG(eventlog_ClearEventLogW, r);
59 push = ndr_push_init_ctx(r);
65 ndr_err = call->ndr_push(push, NDR_OUT, r);
66 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
71 blob = ndr_push_blob(push);
72 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
82 static bool api_eventlog_BackupEventLogW(pipes_struct *p)
84 const struct ndr_interface_call *call;
85 struct ndr_pull *pull;
86 struct ndr_push *push;
87 enum ndr_err_code ndr_err;
89 struct eventlog_BackupEventLogW *r;
91 call = &ndr_table_eventlog.calls[NDR_EVENTLOG_BACKUPEVENTLOGW];
93 r = talloc(NULL, struct eventlog_BackupEventLogW);
98 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
103 pull = ndr_pull_init_blob(&blob, r);
109 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
110 ndr_err = call->ndr_pull(pull, NDR_IN, r);
111 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
116 if (DEBUGLEVEL >= 10) {
117 NDR_PRINT_IN_DEBUG(eventlog_BackupEventLogW, r);
120 r->out.result = _eventlog_BackupEventLogW(p, r);
122 if (p->rng_fault_state) {
124 /* Return true here, srv_pipe_hnd.c will take care */
128 if (DEBUGLEVEL >= 10) {
129 NDR_PRINT_OUT_DEBUG(eventlog_BackupEventLogW, r);
132 push = ndr_push_init_ctx(r);
138 ndr_err = call->ndr_push(push, NDR_OUT, r);
139 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
144 blob = ndr_push_blob(push);
145 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
155 static bool api_eventlog_CloseEventLog(pipes_struct *p)
157 const struct ndr_interface_call *call;
158 struct ndr_pull *pull;
159 struct ndr_push *push;
160 enum ndr_err_code ndr_err;
162 struct eventlog_CloseEventLog *r;
164 call = &ndr_table_eventlog.calls[NDR_EVENTLOG_CLOSEEVENTLOG];
166 r = talloc(NULL, struct eventlog_CloseEventLog);
171 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
176 pull = ndr_pull_init_blob(&blob, r);
182 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
183 ndr_err = call->ndr_pull(pull, NDR_IN, r);
184 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
189 if (DEBUGLEVEL >= 10) {
190 NDR_PRINT_IN_DEBUG(eventlog_CloseEventLog, r);
194 r->out.handle = r->in.handle;
195 r->out.result = _eventlog_CloseEventLog(p, r);
197 if (p->rng_fault_state) {
199 /* Return true here, srv_pipe_hnd.c will take care */
203 if (DEBUGLEVEL >= 10) {
204 NDR_PRINT_OUT_DEBUG(eventlog_CloseEventLog, r);
207 push = ndr_push_init_ctx(r);
213 ndr_err = call->ndr_push(push, NDR_OUT, r);
214 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
219 blob = ndr_push_blob(push);
220 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
230 static bool api_eventlog_DeregisterEventSource(pipes_struct *p)
232 const struct ndr_interface_call *call;
233 struct ndr_pull *pull;
234 struct ndr_push *push;
235 enum ndr_err_code ndr_err;
237 struct eventlog_DeregisterEventSource *r;
239 call = &ndr_table_eventlog.calls[NDR_EVENTLOG_DEREGISTEREVENTSOURCE];
241 r = talloc(NULL, struct eventlog_DeregisterEventSource);
246 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
251 pull = ndr_pull_init_blob(&blob, r);
257 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
258 ndr_err = call->ndr_pull(pull, NDR_IN, r);
259 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
264 if (DEBUGLEVEL >= 10) {
265 NDR_PRINT_IN_DEBUG(eventlog_DeregisterEventSource, r);
268 r->out.result = _eventlog_DeregisterEventSource(p, r);
270 if (p->rng_fault_state) {
272 /* Return true here, srv_pipe_hnd.c will take care */
276 if (DEBUGLEVEL >= 10) {
277 NDR_PRINT_OUT_DEBUG(eventlog_DeregisterEventSource, r);
280 push = ndr_push_init_ctx(r);
286 ndr_err = call->ndr_push(push, NDR_OUT, r);
287 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
292 blob = ndr_push_blob(push);
293 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
303 static bool api_eventlog_GetNumRecords(pipes_struct *p)
305 const struct ndr_interface_call *call;
306 struct ndr_pull *pull;
307 struct ndr_push *push;
308 enum ndr_err_code ndr_err;
310 struct eventlog_GetNumRecords *r;
312 call = &ndr_table_eventlog.calls[NDR_EVENTLOG_GETNUMRECORDS];
314 r = talloc(NULL, struct eventlog_GetNumRecords);
319 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
324 pull = ndr_pull_init_blob(&blob, r);
330 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
331 ndr_err = call->ndr_pull(pull, NDR_IN, r);
332 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
337 if (DEBUGLEVEL >= 10) {
338 NDR_PRINT_IN_DEBUG(eventlog_GetNumRecords, r);
342 r->out.number = talloc_zero(r, uint32_t);
343 if (r->out.number == NULL) {
348 r->out.result = _eventlog_GetNumRecords(p, r);
350 if (p->rng_fault_state) {
352 /* Return true here, srv_pipe_hnd.c will take care */
356 if (DEBUGLEVEL >= 10) {
357 NDR_PRINT_OUT_DEBUG(eventlog_GetNumRecords, r);
360 push = ndr_push_init_ctx(r);
366 ndr_err = call->ndr_push(push, NDR_OUT, r);
367 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
372 blob = ndr_push_blob(push);
373 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
383 static bool api_eventlog_GetOldestRecord(pipes_struct *p)
385 const struct ndr_interface_call *call;
386 struct ndr_pull *pull;
387 struct ndr_push *push;
388 enum ndr_err_code ndr_err;
390 struct eventlog_GetOldestRecord *r;
392 call = &ndr_table_eventlog.calls[NDR_EVENTLOG_GETOLDESTRECORD];
394 r = talloc(NULL, struct eventlog_GetOldestRecord);
399 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
404 pull = ndr_pull_init_blob(&blob, r);
410 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
411 ndr_err = call->ndr_pull(pull, NDR_IN, r);
412 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
417 if (DEBUGLEVEL >= 10) {
418 NDR_PRINT_IN_DEBUG(eventlog_GetOldestRecord, r);
421 r->out.result = _eventlog_GetOldestRecord(p, r);
423 if (p->rng_fault_state) {
425 /* Return true here, srv_pipe_hnd.c will take care */
429 if (DEBUGLEVEL >= 10) {
430 NDR_PRINT_OUT_DEBUG(eventlog_GetOldestRecord, r);
433 push = ndr_push_init_ctx(r);
439 ndr_err = call->ndr_push(push, NDR_OUT, r);
440 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
445 blob = ndr_push_blob(push);
446 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
456 static bool api_eventlog_ChangeNotify(pipes_struct *p)
458 const struct ndr_interface_call *call;
459 struct ndr_pull *pull;
460 struct ndr_push *push;
461 enum ndr_err_code ndr_err;
463 struct eventlog_ChangeNotify *r;
465 call = &ndr_table_eventlog.calls[NDR_EVENTLOG_CHANGENOTIFY];
467 r = talloc(NULL, struct eventlog_ChangeNotify);
472 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
477 pull = ndr_pull_init_blob(&blob, r);
483 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
484 ndr_err = call->ndr_pull(pull, NDR_IN, r);
485 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
490 if (DEBUGLEVEL >= 10) {
491 NDR_PRINT_IN_DEBUG(eventlog_ChangeNotify, r);
494 r->out.result = _eventlog_ChangeNotify(p, r);
496 if (p->rng_fault_state) {
498 /* Return true here, srv_pipe_hnd.c will take care */
502 if (DEBUGLEVEL >= 10) {
503 NDR_PRINT_OUT_DEBUG(eventlog_ChangeNotify, r);
506 push = ndr_push_init_ctx(r);
512 ndr_err = call->ndr_push(push, NDR_OUT, r);
513 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
518 blob = ndr_push_blob(push);
519 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
529 static bool api_eventlog_OpenEventLogW(pipes_struct *p)
531 const struct ndr_interface_call *call;
532 struct ndr_pull *pull;
533 struct ndr_push *push;
534 enum ndr_err_code ndr_err;
536 struct eventlog_OpenEventLogW *r;
538 call = &ndr_table_eventlog.calls[NDR_EVENTLOG_OPENEVENTLOGW];
540 r = talloc(NULL, struct eventlog_OpenEventLogW);
545 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
550 pull = ndr_pull_init_blob(&blob, r);
556 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
557 ndr_err = call->ndr_pull(pull, NDR_IN, r);
558 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
563 if (DEBUGLEVEL >= 10) {
564 NDR_PRINT_IN_DEBUG(eventlog_OpenEventLogW, r);
568 r->out.handle = talloc_zero(r, struct policy_handle);
569 if (r->out.handle == NULL) {
574 r->out.result = _eventlog_OpenEventLogW(p, r);
576 if (p->rng_fault_state) {
578 /* Return true here, srv_pipe_hnd.c will take care */
582 if (DEBUGLEVEL >= 10) {
583 NDR_PRINT_OUT_DEBUG(eventlog_OpenEventLogW, r);
586 push = ndr_push_init_ctx(r);
592 ndr_err = call->ndr_push(push, NDR_OUT, r);
593 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
598 blob = ndr_push_blob(push);
599 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
609 static bool api_eventlog_RegisterEventSourceW(pipes_struct *p)
611 const struct ndr_interface_call *call;
612 struct ndr_pull *pull;
613 struct ndr_push *push;
614 enum ndr_err_code ndr_err;
616 struct eventlog_RegisterEventSourceW *r;
618 call = &ndr_table_eventlog.calls[NDR_EVENTLOG_REGISTEREVENTSOURCEW];
620 r = talloc(NULL, struct eventlog_RegisterEventSourceW);
625 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
630 pull = ndr_pull_init_blob(&blob, r);
636 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
637 ndr_err = call->ndr_pull(pull, NDR_IN, r);
638 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
643 if (DEBUGLEVEL >= 10) {
644 NDR_PRINT_IN_DEBUG(eventlog_RegisterEventSourceW, r);
647 r->out.result = _eventlog_RegisterEventSourceW(p, r);
649 if (p->rng_fault_state) {
651 /* Return true here, srv_pipe_hnd.c will take care */
655 if (DEBUGLEVEL >= 10) {
656 NDR_PRINT_OUT_DEBUG(eventlog_RegisterEventSourceW, r);
659 push = ndr_push_init_ctx(r);
665 ndr_err = call->ndr_push(push, NDR_OUT, r);
666 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
671 blob = ndr_push_blob(push);
672 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
682 static bool api_eventlog_OpenBackupEventLogW(pipes_struct *p)
684 const struct ndr_interface_call *call;
685 struct ndr_pull *pull;
686 struct ndr_push *push;
687 enum ndr_err_code ndr_err;
689 struct eventlog_OpenBackupEventLogW *r;
691 call = &ndr_table_eventlog.calls[NDR_EVENTLOG_OPENBACKUPEVENTLOGW];
693 r = talloc(NULL, struct eventlog_OpenBackupEventLogW);
698 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
703 pull = ndr_pull_init_blob(&blob, r);
709 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
710 ndr_err = call->ndr_pull(pull, NDR_IN, r);
711 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
716 if (DEBUGLEVEL >= 10) {
717 NDR_PRINT_IN_DEBUG(eventlog_OpenBackupEventLogW, r);
720 r->out.result = _eventlog_OpenBackupEventLogW(p, r);
722 if (p->rng_fault_state) {
724 /* Return true here, srv_pipe_hnd.c will take care */
728 if (DEBUGLEVEL >= 10) {
729 NDR_PRINT_OUT_DEBUG(eventlog_OpenBackupEventLogW, r);
732 push = ndr_push_init_ctx(r);
738 ndr_err = call->ndr_push(push, NDR_OUT, r);
739 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
744 blob = ndr_push_blob(push);
745 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
755 static bool api_eventlog_ReadEventLogW(pipes_struct *p)
757 const struct ndr_interface_call *call;
758 struct ndr_pull *pull;
759 struct ndr_push *push;
760 enum ndr_err_code ndr_err;
762 struct eventlog_ReadEventLogW *r;
764 call = &ndr_table_eventlog.calls[NDR_EVENTLOG_READEVENTLOGW];
766 r = talloc(NULL, struct eventlog_ReadEventLogW);
771 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
776 pull = ndr_pull_init_blob(&blob, r);
782 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
783 ndr_err = call->ndr_pull(pull, NDR_IN, r);
784 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
789 if (DEBUGLEVEL >= 10) {
790 NDR_PRINT_IN_DEBUG(eventlog_ReadEventLogW, r);
794 r->out.data = talloc_zero_array(r, uint8_t, r->in.number_of_bytes);
795 if (r->out.data == NULL) {
800 r->out.sent_size = talloc_zero(r, uint32_t);
801 if (r->out.sent_size == NULL) {
806 r->out.real_size = talloc_zero(r, uint32_t);
807 if (r->out.real_size == NULL) {
812 r->out.result = _eventlog_ReadEventLogW(p, r);
814 if (p->rng_fault_state) {
816 /* Return true here, srv_pipe_hnd.c will take care */
820 if (DEBUGLEVEL >= 10) {
821 NDR_PRINT_OUT_DEBUG(eventlog_ReadEventLogW, r);
824 push = ndr_push_init_ctx(r);
830 ndr_err = call->ndr_push(push, NDR_OUT, r);
831 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
836 blob = ndr_push_blob(push);
837 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
847 static bool api_eventlog_ReportEventW(pipes_struct *p)
849 const struct ndr_interface_call *call;
850 struct ndr_pull *pull;
851 struct ndr_push *push;
852 enum ndr_err_code ndr_err;
854 struct eventlog_ReportEventW *r;
856 call = &ndr_table_eventlog.calls[NDR_EVENTLOG_REPORTEVENTW];
858 r = talloc(NULL, struct eventlog_ReportEventW);
863 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
868 pull = ndr_pull_init_blob(&blob, r);
874 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
875 ndr_err = call->ndr_pull(pull, NDR_IN, r);
876 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
881 if (DEBUGLEVEL >= 10) {
882 NDR_PRINT_IN_DEBUG(eventlog_ReportEventW, r);
885 r->out.result = _eventlog_ReportEventW(p, r);
887 if (p->rng_fault_state) {
889 /* Return true here, srv_pipe_hnd.c will take care */
893 if (DEBUGLEVEL >= 10) {
894 NDR_PRINT_OUT_DEBUG(eventlog_ReportEventW, r);
897 push = ndr_push_init_ctx(r);
903 ndr_err = call->ndr_push(push, NDR_OUT, r);
904 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
909 blob = ndr_push_blob(push);
910 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
920 static bool api_eventlog_ClearEventLogA(pipes_struct *p)
922 const struct ndr_interface_call *call;
923 struct ndr_pull *pull;
924 struct ndr_push *push;
925 enum ndr_err_code ndr_err;
927 struct eventlog_ClearEventLogA *r;
929 call = &ndr_table_eventlog.calls[NDR_EVENTLOG_CLEAREVENTLOGA];
931 r = talloc(NULL, struct eventlog_ClearEventLogA);
936 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
941 pull = ndr_pull_init_blob(&blob, r);
947 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
948 ndr_err = call->ndr_pull(pull, NDR_IN, r);
949 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
954 if (DEBUGLEVEL >= 10) {
955 NDR_PRINT_IN_DEBUG(eventlog_ClearEventLogA, r);
958 r->out.result = _eventlog_ClearEventLogA(p, r);
960 if (p->rng_fault_state) {
962 /* Return true here, srv_pipe_hnd.c will take care */
966 if (DEBUGLEVEL >= 10) {
967 NDR_PRINT_OUT_DEBUG(eventlog_ClearEventLogA, r);
970 push = ndr_push_init_ctx(r);
976 ndr_err = call->ndr_push(push, NDR_OUT, r);
977 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
982 blob = ndr_push_blob(push);
983 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
993 static bool api_eventlog_BackupEventLogA(pipes_struct *p)
995 const struct ndr_interface_call *call;
996 struct ndr_pull *pull;
997 struct ndr_push *push;
998 enum ndr_err_code ndr_err;
1000 struct eventlog_BackupEventLogA *r;
1002 call = &ndr_table_eventlog.calls[NDR_EVENTLOG_BACKUPEVENTLOGA];
1004 r = talloc(NULL, struct eventlog_BackupEventLogA);
1009 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1014 pull = ndr_pull_init_blob(&blob, r);
1020 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1021 ndr_err = call->ndr_pull(pull, NDR_IN, r);
1022 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1027 if (DEBUGLEVEL >= 10) {
1028 NDR_PRINT_IN_DEBUG(eventlog_BackupEventLogA, r);
1031 r->out.result = _eventlog_BackupEventLogA(p, r);
1033 if (p->rng_fault_state) {
1035 /* Return true here, srv_pipe_hnd.c will take care */
1039 if (DEBUGLEVEL >= 10) {
1040 NDR_PRINT_OUT_DEBUG(eventlog_BackupEventLogA, r);
1043 push = ndr_push_init_ctx(r);
1049 ndr_err = call->ndr_push(push, NDR_OUT, r);
1050 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1055 blob = ndr_push_blob(push);
1056 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1066 static bool api_eventlog_OpenEventLogA(pipes_struct *p)
1068 const struct ndr_interface_call *call;
1069 struct ndr_pull *pull;
1070 struct ndr_push *push;
1071 enum ndr_err_code ndr_err;
1073 struct eventlog_OpenEventLogA *r;
1075 call = &ndr_table_eventlog.calls[NDR_EVENTLOG_OPENEVENTLOGA];
1077 r = talloc(NULL, struct eventlog_OpenEventLogA);
1082 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1087 pull = ndr_pull_init_blob(&blob, r);
1093 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1094 ndr_err = call->ndr_pull(pull, NDR_IN, r);
1095 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1100 if (DEBUGLEVEL >= 10) {
1101 NDR_PRINT_IN_DEBUG(eventlog_OpenEventLogA, r);
1104 r->out.result = _eventlog_OpenEventLogA(p, r);
1106 if (p->rng_fault_state) {
1108 /* Return true here, srv_pipe_hnd.c will take care */
1112 if (DEBUGLEVEL >= 10) {
1113 NDR_PRINT_OUT_DEBUG(eventlog_OpenEventLogA, r);
1116 push = ndr_push_init_ctx(r);
1122 ndr_err = call->ndr_push(push, NDR_OUT, r);
1123 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1128 blob = ndr_push_blob(push);
1129 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1139 static bool api_eventlog_RegisterEventSourceA(pipes_struct *p)
1141 const struct ndr_interface_call *call;
1142 struct ndr_pull *pull;
1143 struct ndr_push *push;
1144 enum ndr_err_code ndr_err;
1146 struct eventlog_RegisterEventSourceA *r;
1148 call = &ndr_table_eventlog.calls[NDR_EVENTLOG_REGISTEREVENTSOURCEA];
1150 r = talloc(NULL, struct eventlog_RegisterEventSourceA);
1155 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1160 pull = ndr_pull_init_blob(&blob, r);
1166 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1167 ndr_err = call->ndr_pull(pull, NDR_IN, r);
1168 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1173 if (DEBUGLEVEL >= 10) {
1174 NDR_PRINT_IN_DEBUG(eventlog_RegisterEventSourceA, r);
1177 r->out.result = _eventlog_RegisterEventSourceA(p, r);
1179 if (p->rng_fault_state) {
1181 /* Return true here, srv_pipe_hnd.c will take care */
1185 if (DEBUGLEVEL >= 10) {
1186 NDR_PRINT_OUT_DEBUG(eventlog_RegisterEventSourceA, r);
1189 push = ndr_push_init_ctx(r);
1195 ndr_err = call->ndr_push(push, NDR_OUT, r);
1196 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1201 blob = ndr_push_blob(push);
1202 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1212 static bool api_eventlog_OpenBackupEventLogA(pipes_struct *p)
1214 const struct ndr_interface_call *call;
1215 struct ndr_pull *pull;
1216 struct ndr_push *push;
1217 enum ndr_err_code ndr_err;
1219 struct eventlog_OpenBackupEventLogA *r;
1221 call = &ndr_table_eventlog.calls[NDR_EVENTLOG_OPENBACKUPEVENTLOGA];
1223 r = talloc(NULL, struct eventlog_OpenBackupEventLogA);
1228 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1233 pull = ndr_pull_init_blob(&blob, r);
1239 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1240 ndr_err = call->ndr_pull(pull, NDR_IN, r);
1241 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1246 if (DEBUGLEVEL >= 10) {
1247 NDR_PRINT_IN_DEBUG(eventlog_OpenBackupEventLogA, r);
1250 r->out.result = _eventlog_OpenBackupEventLogA(p, r);
1252 if (p->rng_fault_state) {
1254 /* Return true here, srv_pipe_hnd.c will take care */
1258 if (DEBUGLEVEL >= 10) {
1259 NDR_PRINT_OUT_DEBUG(eventlog_OpenBackupEventLogA, r);
1262 push = ndr_push_init_ctx(r);
1268 ndr_err = call->ndr_push(push, NDR_OUT, r);
1269 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1274 blob = ndr_push_blob(push);
1275 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1285 static bool api_eventlog_ReadEventLogA(pipes_struct *p)
1287 const struct ndr_interface_call *call;
1288 struct ndr_pull *pull;
1289 struct ndr_push *push;
1290 enum ndr_err_code ndr_err;
1292 struct eventlog_ReadEventLogA *r;
1294 call = &ndr_table_eventlog.calls[NDR_EVENTLOG_READEVENTLOGA];
1296 r = talloc(NULL, struct eventlog_ReadEventLogA);
1301 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1306 pull = ndr_pull_init_blob(&blob, r);
1312 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1313 ndr_err = call->ndr_pull(pull, NDR_IN, r);
1314 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1319 if (DEBUGLEVEL >= 10) {
1320 NDR_PRINT_IN_DEBUG(eventlog_ReadEventLogA, r);
1323 r->out.result = _eventlog_ReadEventLogA(p, r);
1325 if (p->rng_fault_state) {
1327 /* Return true here, srv_pipe_hnd.c will take care */
1331 if (DEBUGLEVEL >= 10) {
1332 NDR_PRINT_OUT_DEBUG(eventlog_ReadEventLogA, r);
1335 push = ndr_push_init_ctx(r);
1341 ndr_err = call->ndr_push(push, NDR_OUT, r);
1342 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1347 blob = ndr_push_blob(push);
1348 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1358 static bool api_eventlog_ReportEventA(pipes_struct *p)
1360 const struct ndr_interface_call *call;
1361 struct ndr_pull *pull;
1362 struct ndr_push *push;
1363 enum ndr_err_code ndr_err;
1365 struct eventlog_ReportEventA *r;
1367 call = &ndr_table_eventlog.calls[NDR_EVENTLOG_REPORTEVENTA];
1369 r = talloc(NULL, struct eventlog_ReportEventA);
1374 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1379 pull = ndr_pull_init_blob(&blob, r);
1385 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1386 ndr_err = call->ndr_pull(pull, NDR_IN, r);
1387 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1392 if (DEBUGLEVEL >= 10) {
1393 NDR_PRINT_IN_DEBUG(eventlog_ReportEventA, r);
1396 r->out.result = _eventlog_ReportEventA(p, r);
1398 if (p->rng_fault_state) {
1400 /* Return true here, srv_pipe_hnd.c will take care */
1404 if (DEBUGLEVEL >= 10) {
1405 NDR_PRINT_OUT_DEBUG(eventlog_ReportEventA, r);
1408 push = ndr_push_init_ctx(r);
1414 ndr_err = call->ndr_push(push, NDR_OUT, r);
1415 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1420 blob = ndr_push_blob(push);
1421 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1431 static bool api_eventlog_RegisterClusterSvc(pipes_struct *p)
1433 const struct ndr_interface_call *call;
1434 struct ndr_pull *pull;
1435 struct ndr_push *push;
1436 enum ndr_err_code ndr_err;
1438 struct eventlog_RegisterClusterSvc *r;
1440 call = &ndr_table_eventlog.calls[NDR_EVENTLOG_REGISTERCLUSTERSVC];
1442 r = talloc(NULL, struct eventlog_RegisterClusterSvc);
1447 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1452 pull = ndr_pull_init_blob(&blob, r);
1458 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1459 ndr_err = call->ndr_pull(pull, NDR_IN, r);
1460 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1465 if (DEBUGLEVEL >= 10) {
1466 NDR_PRINT_IN_DEBUG(eventlog_RegisterClusterSvc, r);
1469 r->out.result = _eventlog_RegisterClusterSvc(p, r);
1471 if (p->rng_fault_state) {
1473 /* Return true here, srv_pipe_hnd.c will take care */
1477 if (DEBUGLEVEL >= 10) {
1478 NDR_PRINT_OUT_DEBUG(eventlog_RegisterClusterSvc, r);
1481 push = ndr_push_init_ctx(r);
1487 ndr_err = call->ndr_push(push, NDR_OUT, r);
1488 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1493 blob = ndr_push_blob(push);
1494 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1504 static bool api_eventlog_DeregisterClusterSvc(pipes_struct *p)
1506 const struct ndr_interface_call *call;
1507 struct ndr_pull *pull;
1508 struct ndr_push *push;
1509 enum ndr_err_code ndr_err;
1511 struct eventlog_DeregisterClusterSvc *r;
1513 call = &ndr_table_eventlog.calls[NDR_EVENTLOG_DEREGISTERCLUSTERSVC];
1515 r = talloc(NULL, struct eventlog_DeregisterClusterSvc);
1520 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1525 pull = ndr_pull_init_blob(&blob, r);
1531 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1532 ndr_err = call->ndr_pull(pull, NDR_IN, r);
1533 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1538 if (DEBUGLEVEL >= 10) {
1539 NDR_PRINT_IN_DEBUG(eventlog_DeregisterClusterSvc, r);
1542 r->out.result = _eventlog_DeregisterClusterSvc(p, r);
1544 if (p->rng_fault_state) {
1546 /* Return true here, srv_pipe_hnd.c will take care */
1550 if (DEBUGLEVEL >= 10) {
1551 NDR_PRINT_OUT_DEBUG(eventlog_DeregisterClusterSvc, r);
1554 push = ndr_push_init_ctx(r);
1560 ndr_err = call->ndr_push(push, NDR_OUT, r);
1561 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1566 blob = ndr_push_blob(push);
1567 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1577 static bool api_eventlog_WriteClusterEvents(pipes_struct *p)
1579 const struct ndr_interface_call *call;
1580 struct ndr_pull *pull;
1581 struct ndr_push *push;
1582 enum ndr_err_code ndr_err;
1584 struct eventlog_WriteClusterEvents *r;
1586 call = &ndr_table_eventlog.calls[NDR_EVENTLOG_WRITECLUSTEREVENTS];
1588 r = talloc(NULL, struct eventlog_WriteClusterEvents);
1593 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1598 pull = ndr_pull_init_blob(&blob, r);
1604 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1605 ndr_err = call->ndr_pull(pull, NDR_IN, r);
1606 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1611 if (DEBUGLEVEL >= 10) {
1612 NDR_PRINT_IN_DEBUG(eventlog_WriteClusterEvents, r);
1615 r->out.result = _eventlog_WriteClusterEvents(p, r);
1617 if (p->rng_fault_state) {
1619 /* Return true here, srv_pipe_hnd.c will take care */
1623 if (DEBUGLEVEL >= 10) {
1624 NDR_PRINT_OUT_DEBUG(eventlog_WriteClusterEvents, r);
1627 push = ndr_push_init_ctx(r);
1633 ndr_err = call->ndr_push(push, NDR_OUT, r);
1634 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1639 blob = ndr_push_blob(push);
1640 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1650 static bool api_eventlog_GetLogIntormation(pipes_struct *p)
1652 const struct ndr_interface_call *call;
1653 struct ndr_pull *pull;
1654 struct ndr_push *push;
1655 enum ndr_err_code ndr_err;
1657 struct eventlog_GetLogIntormation *r;
1659 call = &ndr_table_eventlog.calls[NDR_EVENTLOG_GETLOGINTORMATION];
1661 r = talloc(NULL, struct eventlog_GetLogIntormation);
1666 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1671 pull = ndr_pull_init_blob(&blob, r);
1677 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1678 ndr_err = call->ndr_pull(pull, NDR_IN, r);
1679 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1684 if (DEBUGLEVEL >= 10) {
1685 NDR_PRINT_IN_DEBUG(eventlog_GetLogIntormation, r);
1688 r->out.result = _eventlog_GetLogIntormation(p, r);
1690 if (p->rng_fault_state) {
1692 /* Return true here, srv_pipe_hnd.c will take care */
1696 if (DEBUGLEVEL >= 10) {
1697 NDR_PRINT_OUT_DEBUG(eventlog_GetLogIntormation, r);
1700 push = ndr_push_init_ctx(r);
1706 ndr_err = call->ndr_push(push, NDR_OUT, r);
1707 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1712 blob = ndr_push_blob(push);
1713 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1723 static bool api_eventlog_FlushEventLog(pipes_struct *p)
1725 const struct ndr_interface_call *call;
1726 struct ndr_pull *pull;
1727 struct ndr_push *push;
1728 enum ndr_err_code ndr_err;
1730 struct eventlog_FlushEventLog *r;
1732 call = &ndr_table_eventlog.calls[NDR_EVENTLOG_FLUSHEVENTLOG];
1734 r = talloc(NULL, struct eventlog_FlushEventLog);
1739 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1744 pull = ndr_pull_init_blob(&blob, r);
1750 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1751 ndr_err = call->ndr_pull(pull, NDR_IN, r);
1752 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1757 if (DEBUGLEVEL >= 10) {
1758 NDR_PRINT_IN_DEBUG(eventlog_FlushEventLog, r);
1761 r->out.result = _eventlog_FlushEventLog(p, r);
1763 if (p->rng_fault_state) {
1765 /* Return true here, srv_pipe_hnd.c will take care */
1769 if (DEBUGLEVEL >= 10) {
1770 NDR_PRINT_OUT_DEBUG(eventlog_FlushEventLog, r);
1773 push = ndr_push_init_ctx(r);
1779 ndr_err = call->ndr_push(push, NDR_OUT, r);
1780 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1785 blob = ndr_push_blob(push);
1786 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1798 static struct api_struct api_eventlog_cmds[] =
1800 {"EVENTLOG_CLEAREVENTLOGW", NDR_EVENTLOG_CLEAREVENTLOGW, api_eventlog_ClearEventLogW},
1801 {"EVENTLOG_BACKUPEVENTLOGW", NDR_EVENTLOG_BACKUPEVENTLOGW, api_eventlog_BackupEventLogW},
1802 {"EVENTLOG_CLOSEEVENTLOG", NDR_EVENTLOG_CLOSEEVENTLOG, api_eventlog_CloseEventLog},
1803 {"EVENTLOG_DEREGISTEREVENTSOURCE", NDR_EVENTLOG_DEREGISTEREVENTSOURCE, api_eventlog_DeregisterEventSource},
1804 {"EVENTLOG_GETNUMRECORDS", NDR_EVENTLOG_GETNUMRECORDS, api_eventlog_GetNumRecords},
1805 {"EVENTLOG_GETOLDESTRECORD", NDR_EVENTLOG_GETOLDESTRECORD, api_eventlog_GetOldestRecord},
1806 {"EVENTLOG_CHANGENOTIFY", NDR_EVENTLOG_CHANGENOTIFY, api_eventlog_ChangeNotify},
1807 {"EVENTLOG_OPENEVENTLOGW", NDR_EVENTLOG_OPENEVENTLOGW, api_eventlog_OpenEventLogW},
1808 {"EVENTLOG_REGISTEREVENTSOURCEW", NDR_EVENTLOG_REGISTEREVENTSOURCEW, api_eventlog_RegisterEventSourceW},
1809 {"EVENTLOG_OPENBACKUPEVENTLOGW", NDR_EVENTLOG_OPENBACKUPEVENTLOGW, api_eventlog_OpenBackupEventLogW},
1810 {"EVENTLOG_READEVENTLOGW", NDR_EVENTLOG_READEVENTLOGW, api_eventlog_ReadEventLogW},
1811 {"EVENTLOG_REPORTEVENTW", NDR_EVENTLOG_REPORTEVENTW, api_eventlog_ReportEventW},
1812 {"EVENTLOG_CLEAREVENTLOGA", NDR_EVENTLOG_CLEAREVENTLOGA, api_eventlog_ClearEventLogA},
1813 {"EVENTLOG_BACKUPEVENTLOGA", NDR_EVENTLOG_BACKUPEVENTLOGA, api_eventlog_BackupEventLogA},
1814 {"EVENTLOG_OPENEVENTLOGA", NDR_EVENTLOG_OPENEVENTLOGA, api_eventlog_OpenEventLogA},
1815 {"EVENTLOG_REGISTEREVENTSOURCEA", NDR_EVENTLOG_REGISTEREVENTSOURCEA, api_eventlog_RegisterEventSourceA},
1816 {"EVENTLOG_OPENBACKUPEVENTLOGA", NDR_EVENTLOG_OPENBACKUPEVENTLOGA, api_eventlog_OpenBackupEventLogA},
1817 {"EVENTLOG_READEVENTLOGA", NDR_EVENTLOG_READEVENTLOGA, api_eventlog_ReadEventLogA},
1818 {"EVENTLOG_REPORTEVENTA", NDR_EVENTLOG_REPORTEVENTA, api_eventlog_ReportEventA},
1819 {"EVENTLOG_REGISTERCLUSTERSVC", NDR_EVENTLOG_REGISTERCLUSTERSVC, api_eventlog_RegisterClusterSvc},
1820 {"EVENTLOG_DEREGISTERCLUSTERSVC", NDR_EVENTLOG_DEREGISTERCLUSTERSVC, api_eventlog_DeregisterClusterSvc},
1821 {"EVENTLOG_WRITECLUSTEREVENTS", NDR_EVENTLOG_WRITECLUSTEREVENTS, api_eventlog_WriteClusterEvents},
1822 {"EVENTLOG_GETLOGINTORMATION", NDR_EVENTLOG_GETLOGINTORMATION, api_eventlog_GetLogIntormation},
1823 {"EVENTLOG_FLUSHEVENTLOG", NDR_EVENTLOG_FLUSHEVENTLOG, api_eventlog_FlushEventLog},
1826 void eventlog_get_pipe_fns(struct api_struct **fns, int *n_fns)
1828 *fns = api_eventlog_cmds;
1829 *n_fns = sizeof(api_eventlog_cmds) / sizeof(struct api_struct);
1832 NTSTATUS rpc_eventlog_init(void)
1834 return rpc_pipe_register_commands(SMB_RPC_INTERFACE_VERSION, "eventlog", "eventlog", api_eventlog_cmds, sizeof(api_eventlog_cmds) / sizeof(struct api_struct));