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;
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 status = call->ndr_pull(pull, NDR_IN, r);
38 if (NT_STATUS_IS_ERR(status)) {
44 NDR_PRINT_IN_DEBUG(eventlog_ClearEventLogW, r);
46 r->out.result = _eventlog_ClearEventLogW(p, r);
48 if (p->rng_fault_state) {
50 /* Return True here, srv_pipe_hnd.c will take care */
55 NDR_PRINT_OUT_DEBUG(eventlog_ClearEventLogW, r);
57 push = ndr_push_init_ctx(r);
63 status = call->ndr_push(push, NDR_OUT, r);
64 if (NT_STATUS_IS_ERR(status)) {
69 blob = ndr_push_blob(push);
70 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
80 static bool api_eventlog_BackupEventLogW(pipes_struct *p)
82 const struct ndr_interface_call *call;
83 struct ndr_pull *pull;
84 struct ndr_push *push;
87 struct eventlog_BackupEventLogW *r;
89 call = &ndr_table_eventlog.calls[NDR_EVENTLOG_BACKUPEVENTLOGW];
91 r = talloc(NULL, struct eventlog_BackupEventLogW);
96 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
101 pull = ndr_pull_init_blob(&blob, r);
107 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
108 status = call->ndr_pull(pull, NDR_IN, r);
109 if (NT_STATUS_IS_ERR(status)) {
114 if (DEBUGLEVEL >= 10)
115 NDR_PRINT_IN_DEBUG(eventlog_BackupEventLogW, r);
117 r->out.result = _eventlog_BackupEventLogW(p, r);
119 if (p->rng_fault_state) {
121 /* Return True here, srv_pipe_hnd.c will take care */
125 if (DEBUGLEVEL >= 10)
126 NDR_PRINT_OUT_DEBUG(eventlog_BackupEventLogW, r);
128 push = ndr_push_init_ctx(r);
134 status = call->ndr_push(push, NDR_OUT, r);
135 if (NT_STATUS_IS_ERR(status)) {
140 blob = ndr_push_blob(push);
141 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
151 static bool api_eventlog_CloseEventLog(pipes_struct *p)
153 const struct ndr_interface_call *call;
154 struct ndr_pull *pull;
155 struct ndr_push *push;
158 struct eventlog_CloseEventLog *r;
160 call = &ndr_table_eventlog.calls[NDR_EVENTLOG_CLOSEEVENTLOG];
162 r = talloc(NULL, struct eventlog_CloseEventLog);
167 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
172 pull = ndr_pull_init_blob(&blob, r);
178 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
179 status = call->ndr_pull(pull, NDR_IN, r);
180 if (NT_STATUS_IS_ERR(status)) {
185 if (DEBUGLEVEL >= 10)
186 NDR_PRINT_IN_DEBUG(eventlog_CloseEventLog, r);
189 r->out.handle = r->in.handle;
190 r->out.result = _eventlog_CloseEventLog(p, r);
192 if (p->rng_fault_state) {
194 /* Return True here, srv_pipe_hnd.c will take care */
198 if (DEBUGLEVEL >= 10)
199 NDR_PRINT_OUT_DEBUG(eventlog_CloseEventLog, r);
201 push = ndr_push_init_ctx(r);
207 status = call->ndr_push(push, NDR_OUT, r);
208 if (NT_STATUS_IS_ERR(status)) {
213 blob = ndr_push_blob(push);
214 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
224 static bool api_eventlog_DeregisterEventSource(pipes_struct *p)
226 const struct ndr_interface_call *call;
227 struct ndr_pull *pull;
228 struct ndr_push *push;
231 struct eventlog_DeregisterEventSource *r;
233 call = &ndr_table_eventlog.calls[NDR_EVENTLOG_DEREGISTEREVENTSOURCE];
235 r = talloc(NULL, struct eventlog_DeregisterEventSource);
240 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
245 pull = ndr_pull_init_blob(&blob, r);
251 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
252 status = call->ndr_pull(pull, NDR_IN, r);
253 if (NT_STATUS_IS_ERR(status)) {
258 if (DEBUGLEVEL >= 10)
259 NDR_PRINT_IN_DEBUG(eventlog_DeregisterEventSource, r);
261 r->out.result = _eventlog_DeregisterEventSource(p, r);
263 if (p->rng_fault_state) {
265 /* Return True here, srv_pipe_hnd.c will take care */
269 if (DEBUGLEVEL >= 10)
270 NDR_PRINT_OUT_DEBUG(eventlog_DeregisterEventSource, r);
272 push = ndr_push_init_ctx(r);
278 status = call->ndr_push(push, NDR_OUT, r);
279 if (NT_STATUS_IS_ERR(status)) {
284 blob = ndr_push_blob(push);
285 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
295 static bool api_eventlog_GetNumRecords(pipes_struct *p)
297 const struct ndr_interface_call *call;
298 struct ndr_pull *pull;
299 struct ndr_push *push;
302 struct eventlog_GetNumRecords *r;
304 call = &ndr_table_eventlog.calls[NDR_EVENTLOG_GETNUMRECORDS];
306 r = talloc(NULL, struct eventlog_GetNumRecords);
311 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
316 pull = ndr_pull_init_blob(&blob, r);
322 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
323 status = call->ndr_pull(pull, NDR_IN, r);
324 if (NT_STATUS_IS_ERR(status)) {
329 if (DEBUGLEVEL >= 10)
330 NDR_PRINT_IN_DEBUG(eventlog_GetNumRecords, r);
333 r->out.number = talloc_zero(r, uint32_t);
334 if (r->out.number == NULL) {
339 r->out.result = _eventlog_GetNumRecords(p, r);
341 if (p->rng_fault_state) {
343 /* Return True here, srv_pipe_hnd.c will take care */
347 if (DEBUGLEVEL >= 10)
348 NDR_PRINT_OUT_DEBUG(eventlog_GetNumRecords, r);
350 push = ndr_push_init_ctx(r);
356 status = call->ndr_push(push, NDR_OUT, r);
357 if (NT_STATUS_IS_ERR(status)) {
362 blob = ndr_push_blob(push);
363 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
373 static bool api_eventlog_GetOldestRecord(pipes_struct *p)
375 const struct ndr_interface_call *call;
376 struct ndr_pull *pull;
377 struct ndr_push *push;
380 struct eventlog_GetOldestRecord *r;
382 call = &ndr_table_eventlog.calls[NDR_EVENTLOG_GETOLDESTRECORD];
384 r = talloc(NULL, struct eventlog_GetOldestRecord);
389 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
394 pull = ndr_pull_init_blob(&blob, r);
400 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
401 status = call->ndr_pull(pull, NDR_IN, r);
402 if (NT_STATUS_IS_ERR(status)) {
407 if (DEBUGLEVEL >= 10)
408 NDR_PRINT_IN_DEBUG(eventlog_GetOldestRecord, r);
410 r->out.result = _eventlog_GetOldestRecord(p, r);
412 if (p->rng_fault_state) {
414 /* Return True here, srv_pipe_hnd.c will take care */
418 if (DEBUGLEVEL >= 10)
419 NDR_PRINT_OUT_DEBUG(eventlog_GetOldestRecord, r);
421 push = ndr_push_init_ctx(r);
427 status = call->ndr_push(push, NDR_OUT, r);
428 if (NT_STATUS_IS_ERR(status)) {
433 blob = ndr_push_blob(push);
434 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
444 static bool api_eventlog_ChangeNotify(pipes_struct *p)
446 const struct ndr_interface_call *call;
447 struct ndr_pull *pull;
448 struct ndr_push *push;
451 struct eventlog_ChangeNotify *r;
453 call = &ndr_table_eventlog.calls[NDR_EVENTLOG_CHANGENOTIFY];
455 r = talloc(NULL, struct eventlog_ChangeNotify);
460 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
465 pull = ndr_pull_init_blob(&blob, r);
471 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
472 status = call->ndr_pull(pull, NDR_IN, r);
473 if (NT_STATUS_IS_ERR(status)) {
478 if (DEBUGLEVEL >= 10)
479 NDR_PRINT_IN_DEBUG(eventlog_ChangeNotify, r);
481 r->out.result = _eventlog_ChangeNotify(p, r);
483 if (p->rng_fault_state) {
485 /* Return True here, srv_pipe_hnd.c will take care */
489 if (DEBUGLEVEL >= 10)
490 NDR_PRINT_OUT_DEBUG(eventlog_ChangeNotify, r);
492 push = ndr_push_init_ctx(r);
498 status = call->ndr_push(push, NDR_OUT, r);
499 if (NT_STATUS_IS_ERR(status)) {
504 blob = ndr_push_blob(push);
505 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
515 static bool api_eventlog_OpenEventLogW(pipes_struct *p)
517 const struct ndr_interface_call *call;
518 struct ndr_pull *pull;
519 struct ndr_push *push;
522 struct eventlog_OpenEventLogW *r;
524 call = &ndr_table_eventlog.calls[NDR_EVENTLOG_OPENEVENTLOGW];
526 r = talloc(NULL, struct eventlog_OpenEventLogW);
531 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
536 pull = ndr_pull_init_blob(&blob, r);
542 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
543 status = call->ndr_pull(pull, NDR_IN, r);
544 if (NT_STATUS_IS_ERR(status)) {
549 if (DEBUGLEVEL >= 10)
550 NDR_PRINT_IN_DEBUG(eventlog_OpenEventLogW, r);
553 r->out.handle = talloc_zero(r, struct policy_handle);
554 if (r->out.handle == NULL) {
559 r->out.result = _eventlog_OpenEventLogW(p, r);
561 if (p->rng_fault_state) {
563 /* Return True here, srv_pipe_hnd.c will take care */
567 if (DEBUGLEVEL >= 10)
568 NDR_PRINT_OUT_DEBUG(eventlog_OpenEventLogW, r);
570 push = ndr_push_init_ctx(r);
576 status = call->ndr_push(push, NDR_OUT, r);
577 if (NT_STATUS_IS_ERR(status)) {
582 blob = ndr_push_blob(push);
583 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
593 static bool api_eventlog_RegisterEventSourceW(pipes_struct *p)
595 const struct ndr_interface_call *call;
596 struct ndr_pull *pull;
597 struct ndr_push *push;
600 struct eventlog_RegisterEventSourceW *r;
602 call = &ndr_table_eventlog.calls[NDR_EVENTLOG_REGISTEREVENTSOURCEW];
604 r = talloc(NULL, struct eventlog_RegisterEventSourceW);
609 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
614 pull = ndr_pull_init_blob(&blob, r);
620 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
621 status = call->ndr_pull(pull, NDR_IN, r);
622 if (NT_STATUS_IS_ERR(status)) {
627 if (DEBUGLEVEL >= 10)
628 NDR_PRINT_IN_DEBUG(eventlog_RegisterEventSourceW, r);
630 r->out.result = _eventlog_RegisterEventSourceW(p, r);
632 if (p->rng_fault_state) {
634 /* Return True here, srv_pipe_hnd.c will take care */
638 if (DEBUGLEVEL >= 10)
639 NDR_PRINT_OUT_DEBUG(eventlog_RegisterEventSourceW, r);
641 push = ndr_push_init_ctx(r);
647 status = call->ndr_push(push, NDR_OUT, r);
648 if (NT_STATUS_IS_ERR(status)) {
653 blob = ndr_push_blob(push);
654 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
664 static bool api_eventlog_OpenBackupEventLogW(pipes_struct *p)
666 const struct ndr_interface_call *call;
667 struct ndr_pull *pull;
668 struct ndr_push *push;
671 struct eventlog_OpenBackupEventLogW *r;
673 call = &ndr_table_eventlog.calls[NDR_EVENTLOG_OPENBACKUPEVENTLOGW];
675 r = talloc(NULL, struct eventlog_OpenBackupEventLogW);
680 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
685 pull = ndr_pull_init_blob(&blob, r);
691 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
692 status = call->ndr_pull(pull, NDR_IN, r);
693 if (NT_STATUS_IS_ERR(status)) {
698 if (DEBUGLEVEL >= 10)
699 NDR_PRINT_IN_DEBUG(eventlog_OpenBackupEventLogW, r);
701 r->out.result = _eventlog_OpenBackupEventLogW(p, r);
703 if (p->rng_fault_state) {
705 /* Return True here, srv_pipe_hnd.c will take care */
709 if (DEBUGLEVEL >= 10)
710 NDR_PRINT_OUT_DEBUG(eventlog_OpenBackupEventLogW, r);
712 push = ndr_push_init_ctx(r);
718 status = call->ndr_push(push, NDR_OUT, r);
719 if (NT_STATUS_IS_ERR(status)) {
724 blob = ndr_push_blob(push);
725 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
735 static bool api_eventlog_ReadEventLogW(pipes_struct *p)
737 const struct ndr_interface_call *call;
738 struct ndr_pull *pull;
739 struct ndr_push *push;
742 struct eventlog_ReadEventLogW *r;
744 call = &ndr_table_eventlog.calls[NDR_EVENTLOG_READEVENTLOGW];
746 r = talloc(NULL, struct eventlog_ReadEventLogW);
751 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
756 pull = ndr_pull_init_blob(&blob, r);
762 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
763 status = call->ndr_pull(pull, NDR_IN, r);
764 if (NT_STATUS_IS_ERR(status)) {
769 if (DEBUGLEVEL >= 10)
770 NDR_PRINT_IN_DEBUG(eventlog_ReadEventLogW, r);
773 r->out.data = talloc_zero_array(r, uint8_t, r->in.number_of_bytes);
774 if (r->out.data == NULL) {
779 r->out.sent_size = talloc_zero(r, uint32_t);
780 if (r->out.sent_size == NULL) {
785 r->out.real_size = talloc_zero(r, uint32_t);
786 if (r->out.real_size == NULL) {
791 r->out.result = _eventlog_ReadEventLogW(p, r);
793 if (p->rng_fault_state) {
795 /* Return True here, srv_pipe_hnd.c will take care */
799 if (DEBUGLEVEL >= 10)
800 NDR_PRINT_OUT_DEBUG(eventlog_ReadEventLogW, r);
802 push = ndr_push_init_ctx(r);
808 status = call->ndr_push(push, NDR_OUT, r);
809 if (NT_STATUS_IS_ERR(status)) {
814 blob = ndr_push_blob(push);
815 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
825 static bool api_eventlog_ReportEventW(pipes_struct *p)
827 const struct ndr_interface_call *call;
828 struct ndr_pull *pull;
829 struct ndr_push *push;
832 struct eventlog_ReportEventW *r;
834 call = &ndr_table_eventlog.calls[NDR_EVENTLOG_REPORTEVENTW];
836 r = talloc(NULL, struct eventlog_ReportEventW);
841 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
846 pull = ndr_pull_init_blob(&blob, r);
852 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
853 status = call->ndr_pull(pull, NDR_IN, r);
854 if (NT_STATUS_IS_ERR(status)) {
859 if (DEBUGLEVEL >= 10)
860 NDR_PRINT_IN_DEBUG(eventlog_ReportEventW, r);
862 r->out.result = _eventlog_ReportEventW(p, r);
864 if (p->rng_fault_state) {
866 /* Return True here, srv_pipe_hnd.c will take care */
870 if (DEBUGLEVEL >= 10)
871 NDR_PRINT_OUT_DEBUG(eventlog_ReportEventW, r);
873 push = ndr_push_init_ctx(r);
879 status = call->ndr_push(push, NDR_OUT, r);
880 if (NT_STATUS_IS_ERR(status)) {
885 blob = ndr_push_blob(push);
886 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
896 static bool api_eventlog_ClearEventLogA(pipes_struct *p)
898 const struct ndr_interface_call *call;
899 struct ndr_pull *pull;
900 struct ndr_push *push;
903 struct eventlog_ClearEventLogA *r;
905 call = &ndr_table_eventlog.calls[NDR_EVENTLOG_CLEAREVENTLOGA];
907 r = talloc(NULL, struct eventlog_ClearEventLogA);
912 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
917 pull = ndr_pull_init_blob(&blob, r);
923 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
924 status = call->ndr_pull(pull, NDR_IN, r);
925 if (NT_STATUS_IS_ERR(status)) {
930 if (DEBUGLEVEL >= 10)
931 NDR_PRINT_IN_DEBUG(eventlog_ClearEventLogA, r);
933 r->out.result = _eventlog_ClearEventLogA(p, r);
935 if (p->rng_fault_state) {
937 /* Return True here, srv_pipe_hnd.c will take care */
941 if (DEBUGLEVEL >= 10)
942 NDR_PRINT_OUT_DEBUG(eventlog_ClearEventLogA, r);
944 push = ndr_push_init_ctx(r);
950 status = call->ndr_push(push, NDR_OUT, r);
951 if (NT_STATUS_IS_ERR(status)) {
956 blob = ndr_push_blob(push);
957 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
967 static bool api_eventlog_BackupEventLogA(pipes_struct *p)
969 const struct ndr_interface_call *call;
970 struct ndr_pull *pull;
971 struct ndr_push *push;
974 struct eventlog_BackupEventLogA *r;
976 call = &ndr_table_eventlog.calls[NDR_EVENTLOG_BACKUPEVENTLOGA];
978 r = talloc(NULL, struct eventlog_BackupEventLogA);
983 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
988 pull = ndr_pull_init_blob(&blob, r);
994 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
995 status = call->ndr_pull(pull, NDR_IN, r);
996 if (NT_STATUS_IS_ERR(status)) {
1001 if (DEBUGLEVEL >= 10)
1002 NDR_PRINT_IN_DEBUG(eventlog_BackupEventLogA, r);
1004 r->out.result = _eventlog_BackupEventLogA(p, r);
1006 if (p->rng_fault_state) {
1008 /* Return True here, srv_pipe_hnd.c will take care */
1012 if (DEBUGLEVEL >= 10)
1013 NDR_PRINT_OUT_DEBUG(eventlog_BackupEventLogA, r);
1015 push = ndr_push_init_ctx(r);
1021 status = call->ndr_push(push, NDR_OUT, r);
1022 if (NT_STATUS_IS_ERR(status)) {
1027 blob = ndr_push_blob(push);
1028 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
1038 static bool api_eventlog_OpenEventLogA(pipes_struct *p)
1040 const struct ndr_interface_call *call;
1041 struct ndr_pull *pull;
1042 struct ndr_push *push;
1045 struct eventlog_OpenEventLogA *r;
1047 call = &ndr_table_eventlog.calls[NDR_EVENTLOG_OPENEVENTLOGA];
1049 r = talloc(NULL, struct eventlog_OpenEventLogA);
1054 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1059 pull = ndr_pull_init_blob(&blob, r);
1065 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1066 status = call->ndr_pull(pull, NDR_IN, r);
1067 if (NT_STATUS_IS_ERR(status)) {
1072 if (DEBUGLEVEL >= 10)
1073 NDR_PRINT_IN_DEBUG(eventlog_OpenEventLogA, r);
1075 r->out.result = _eventlog_OpenEventLogA(p, r);
1077 if (p->rng_fault_state) {
1079 /* Return True here, srv_pipe_hnd.c will take care */
1083 if (DEBUGLEVEL >= 10)
1084 NDR_PRINT_OUT_DEBUG(eventlog_OpenEventLogA, r);
1086 push = ndr_push_init_ctx(r);
1092 status = call->ndr_push(push, NDR_OUT, r);
1093 if (NT_STATUS_IS_ERR(status)) {
1098 blob = ndr_push_blob(push);
1099 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
1109 static bool api_eventlog_RegisterEventSourceA(pipes_struct *p)
1111 const struct ndr_interface_call *call;
1112 struct ndr_pull *pull;
1113 struct ndr_push *push;
1116 struct eventlog_RegisterEventSourceA *r;
1118 call = &ndr_table_eventlog.calls[NDR_EVENTLOG_REGISTEREVENTSOURCEA];
1120 r = talloc(NULL, struct eventlog_RegisterEventSourceA);
1125 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1130 pull = ndr_pull_init_blob(&blob, r);
1136 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1137 status = call->ndr_pull(pull, NDR_IN, r);
1138 if (NT_STATUS_IS_ERR(status)) {
1143 if (DEBUGLEVEL >= 10)
1144 NDR_PRINT_IN_DEBUG(eventlog_RegisterEventSourceA, r);
1146 r->out.result = _eventlog_RegisterEventSourceA(p, r);
1148 if (p->rng_fault_state) {
1150 /* Return True here, srv_pipe_hnd.c will take care */
1154 if (DEBUGLEVEL >= 10)
1155 NDR_PRINT_OUT_DEBUG(eventlog_RegisterEventSourceA, r);
1157 push = ndr_push_init_ctx(r);
1163 status = call->ndr_push(push, NDR_OUT, r);
1164 if (NT_STATUS_IS_ERR(status)) {
1169 blob = ndr_push_blob(push);
1170 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
1180 static bool api_eventlog_OpenBackupEventLogA(pipes_struct *p)
1182 const struct ndr_interface_call *call;
1183 struct ndr_pull *pull;
1184 struct ndr_push *push;
1187 struct eventlog_OpenBackupEventLogA *r;
1189 call = &ndr_table_eventlog.calls[NDR_EVENTLOG_OPENBACKUPEVENTLOGA];
1191 r = talloc(NULL, struct eventlog_OpenBackupEventLogA);
1196 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1201 pull = ndr_pull_init_blob(&blob, r);
1207 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1208 status = call->ndr_pull(pull, NDR_IN, r);
1209 if (NT_STATUS_IS_ERR(status)) {
1214 if (DEBUGLEVEL >= 10)
1215 NDR_PRINT_IN_DEBUG(eventlog_OpenBackupEventLogA, r);
1217 r->out.result = _eventlog_OpenBackupEventLogA(p, r);
1219 if (p->rng_fault_state) {
1221 /* Return True here, srv_pipe_hnd.c will take care */
1225 if (DEBUGLEVEL >= 10)
1226 NDR_PRINT_OUT_DEBUG(eventlog_OpenBackupEventLogA, r);
1228 push = ndr_push_init_ctx(r);
1234 status = call->ndr_push(push, NDR_OUT, r);
1235 if (NT_STATUS_IS_ERR(status)) {
1240 blob = ndr_push_blob(push);
1241 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
1251 static bool api_eventlog_ReadEventLogA(pipes_struct *p)
1253 const struct ndr_interface_call *call;
1254 struct ndr_pull *pull;
1255 struct ndr_push *push;
1258 struct eventlog_ReadEventLogA *r;
1260 call = &ndr_table_eventlog.calls[NDR_EVENTLOG_READEVENTLOGA];
1262 r = talloc(NULL, struct eventlog_ReadEventLogA);
1267 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1272 pull = ndr_pull_init_blob(&blob, r);
1278 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1279 status = call->ndr_pull(pull, NDR_IN, r);
1280 if (NT_STATUS_IS_ERR(status)) {
1285 if (DEBUGLEVEL >= 10)
1286 NDR_PRINT_IN_DEBUG(eventlog_ReadEventLogA, r);
1288 r->out.result = _eventlog_ReadEventLogA(p, r);
1290 if (p->rng_fault_state) {
1292 /* Return True here, srv_pipe_hnd.c will take care */
1296 if (DEBUGLEVEL >= 10)
1297 NDR_PRINT_OUT_DEBUG(eventlog_ReadEventLogA, r);
1299 push = ndr_push_init_ctx(r);
1305 status = call->ndr_push(push, NDR_OUT, r);
1306 if (NT_STATUS_IS_ERR(status)) {
1311 blob = ndr_push_blob(push);
1312 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
1322 static bool api_eventlog_ReportEventA(pipes_struct *p)
1324 const struct ndr_interface_call *call;
1325 struct ndr_pull *pull;
1326 struct ndr_push *push;
1329 struct eventlog_ReportEventA *r;
1331 call = &ndr_table_eventlog.calls[NDR_EVENTLOG_REPORTEVENTA];
1333 r = talloc(NULL, struct eventlog_ReportEventA);
1338 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1343 pull = ndr_pull_init_blob(&blob, r);
1349 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1350 status = call->ndr_pull(pull, NDR_IN, r);
1351 if (NT_STATUS_IS_ERR(status)) {
1356 if (DEBUGLEVEL >= 10)
1357 NDR_PRINT_IN_DEBUG(eventlog_ReportEventA, r);
1359 r->out.result = _eventlog_ReportEventA(p, r);
1361 if (p->rng_fault_state) {
1363 /* Return True here, srv_pipe_hnd.c will take care */
1367 if (DEBUGLEVEL >= 10)
1368 NDR_PRINT_OUT_DEBUG(eventlog_ReportEventA, r);
1370 push = ndr_push_init_ctx(r);
1376 status = call->ndr_push(push, NDR_OUT, r);
1377 if (NT_STATUS_IS_ERR(status)) {
1382 blob = ndr_push_blob(push);
1383 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
1393 static bool api_eventlog_RegisterClusterSvc(pipes_struct *p)
1395 const struct ndr_interface_call *call;
1396 struct ndr_pull *pull;
1397 struct ndr_push *push;
1400 struct eventlog_RegisterClusterSvc *r;
1402 call = &ndr_table_eventlog.calls[NDR_EVENTLOG_REGISTERCLUSTERSVC];
1404 r = talloc(NULL, struct eventlog_RegisterClusterSvc);
1409 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1414 pull = ndr_pull_init_blob(&blob, r);
1420 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1421 status = call->ndr_pull(pull, NDR_IN, r);
1422 if (NT_STATUS_IS_ERR(status)) {
1427 if (DEBUGLEVEL >= 10)
1428 NDR_PRINT_IN_DEBUG(eventlog_RegisterClusterSvc, r);
1430 r->out.result = _eventlog_RegisterClusterSvc(p, r);
1432 if (p->rng_fault_state) {
1434 /* Return True here, srv_pipe_hnd.c will take care */
1438 if (DEBUGLEVEL >= 10)
1439 NDR_PRINT_OUT_DEBUG(eventlog_RegisterClusterSvc, r);
1441 push = ndr_push_init_ctx(r);
1447 status = call->ndr_push(push, NDR_OUT, r);
1448 if (NT_STATUS_IS_ERR(status)) {
1453 blob = ndr_push_blob(push);
1454 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
1464 static bool api_eventlog_DeregisterClusterSvc(pipes_struct *p)
1466 const struct ndr_interface_call *call;
1467 struct ndr_pull *pull;
1468 struct ndr_push *push;
1471 struct eventlog_DeregisterClusterSvc *r;
1473 call = &ndr_table_eventlog.calls[NDR_EVENTLOG_DEREGISTERCLUSTERSVC];
1475 r = talloc(NULL, struct eventlog_DeregisterClusterSvc);
1480 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1485 pull = ndr_pull_init_blob(&blob, r);
1491 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1492 status = call->ndr_pull(pull, NDR_IN, r);
1493 if (NT_STATUS_IS_ERR(status)) {
1498 if (DEBUGLEVEL >= 10)
1499 NDR_PRINT_IN_DEBUG(eventlog_DeregisterClusterSvc, r);
1501 r->out.result = _eventlog_DeregisterClusterSvc(p, r);
1503 if (p->rng_fault_state) {
1505 /* Return True here, srv_pipe_hnd.c will take care */
1509 if (DEBUGLEVEL >= 10)
1510 NDR_PRINT_OUT_DEBUG(eventlog_DeregisterClusterSvc, r);
1512 push = ndr_push_init_ctx(r);
1518 status = call->ndr_push(push, NDR_OUT, r);
1519 if (NT_STATUS_IS_ERR(status)) {
1524 blob = ndr_push_blob(push);
1525 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
1535 static bool api_eventlog_WriteClusterEvents(pipes_struct *p)
1537 const struct ndr_interface_call *call;
1538 struct ndr_pull *pull;
1539 struct ndr_push *push;
1542 struct eventlog_WriteClusterEvents *r;
1544 call = &ndr_table_eventlog.calls[NDR_EVENTLOG_WRITECLUSTEREVENTS];
1546 r = talloc(NULL, struct eventlog_WriteClusterEvents);
1551 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1556 pull = ndr_pull_init_blob(&blob, r);
1562 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1563 status = call->ndr_pull(pull, NDR_IN, r);
1564 if (NT_STATUS_IS_ERR(status)) {
1569 if (DEBUGLEVEL >= 10)
1570 NDR_PRINT_IN_DEBUG(eventlog_WriteClusterEvents, r);
1572 r->out.result = _eventlog_WriteClusterEvents(p, r);
1574 if (p->rng_fault_state) {
1576 /* Return True here, srv_pipe_hnd.c will take care */
1580 if (DEBUGLEVEL >= 10)
1581 NDR_PRINT_OUT_DEBUG(eventlog_WriteClusterEvents, r);
1583 push = ndr_push_init_ctx(r);
1589 status = call->ndr_push(push, NDR_OUT, r);
1590 if (NT_STATUS_IS_ERR(status)) {
1595 blob = ndr_push_blob(push);
1596 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
1606 static bool api_eventlog_GetLogIntormation(pipes_struct *p)
1608 const struct ndr_interface_call *call;
1609 struct ndr_pull *pull;
1610 struct ndr_push *push;
1613 struct eventlog_GetLogIntormation *r;
1615 call = &ndr_table_eventlog.calls[NDR_EVENTLOG_GETLOGINTORMATION];
1617 r = talloc(NULL, struct eventlog_GetLogIntormation);
1622 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1627 pull = ndr_pull_init_blob(&blob, r);
1633 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1634 status = call->ndr_pull(pull, NDR_IN, r);
1635 if (NT_STATUS_IS_ERR(status)) {
1640 if (DEBUGLEVEL >= 10)
1641 NDR_PRINT_IN_DEBUG(eventlog_GetLogIntormation, r);
1643 r->out.result = _eventlog_GetLogIntormation(p, r);
1645 if (p->rng_fault_state) {
1647 /* Return True here, srv_pipe_hnd.c will take care */
1651 if (DEBUGLEVEL >= 10)
1652 NDR_PRINT_OUT_DEBUG(eventlog_GetLogIntormation, r);
1654 push = ndr_push_init_ctx(r);
1660 status = call->ndr_push(push, NDR_OUT, r);
1661 if (NT_STATUS_IS_ERR(status)) {
1666 blob = ndr_push_blob(push);
1667 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
1677 static bool api_eventlog_FlushEventLog(pipes_struct *p)
1679 const struct ndr_interface_call *call;
1680 struct ndr_pull *pull;
1681 struct ndr_push *push;
1684 struct eventlog_FlushEventLog *r;
1686 call = &ndr_table_eventlog.calls[NDR_EVENTLOG_FLUSHEVENTLOG];
1688 r = talloc(NULL, struct eventlog_FlushEventLog);
1693 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1698 pull = ndr_pull_init_blob(&blob, r);
1704 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1705 status = call->ndr_pull(pull, NDR_IN, r);
1706 if (NT_STATUS_IS_ERR(status)) {
1711 if (DEBUGLEVEL >= 10)
1712 NDR_PRINT_IN_DEBUG(eventlog_FlushEventLog, r);
1714 r->out.result = _eventlog_FlushEventLog(p, r);
1716 if (p->rng_fault_state) {
1718 /* Return True here, srv_pipe_hnd.c will take care */
1722 if (DEBUGLEVEL >= 10)
1723 NDR_PRINT_OUT_DEBUG(eventlog_FlushEventLog, r);
1725 push = ndr_push_init_ctx(r);
1731 status = call->ndr_push(push, NDR_OUT, r);
1732 if (NT_STATUS_IS_ERR(status)) {
1737 blob = ndr_push_blob(push);
1738 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
1750 static struct api_struct api_eventlog_cmds[] =
1752 {"EVENTLOG_CLEAREVENTLOGW", NDR_EVENTLOG_CLEAREVENTLOGW, api_eventlog_ClearEventLogW},
1753 {"EVENTLOG_BACKUPEVENTLOGW", NDR_EVENTLOG_BACKUPEVENTLOGW, api_eventlog_BackupEventLogW},
1754 {"EVENTLOG_CLOSEEVENTLOG", NDR_EVENTLOG_CLOSEEVENTLOG, api_eventlog_CloseEventLog},
1755 {"EVENTLOG_DEREGISTEREVENTSOURCE", NDR_EVENTLOG_DEREGISTEREVENTSOURCE, api_eventlog_DeregisterEventSource},
1756 {"EVENTLOG_GETNUMRECORDS", NDR_EVENTLOG_GETNUMRECORDS, api_eventlog_GetNumRecords},
1757 {"EVENTLOG_GETOLDESTRECORD", NDR_EVENTLOG_GETOLDESTRECORD, api_eventlog_GetOldestRecord},
1758 {"EVENTLOG_CHANGENOTIFY", NDR_EVENTLOG_CHANGENOTIFY, api_eventlog_ChangeNotify},
1759 {"EVENTLOG_OPENEVENTLOGW", NDR_EVENTLOG_OPENEVENTLOGW, api_eventlog_OpenEventLogW},
1760 {"EVENTLOG_REGISTEREVENTSOURCEW", NDR_EVENTLOG_REGISTEREVENTSOURCEW, api_eventlog_RegisterEventSourceW},
1761 {"EVENTLOG_OPENBACKUPEVENTLOGW", NDR_EVENTLOG_OPENBACKUPEVENTLOGW, api_eventlog_OpenBackupEventLogW},
1762 {"EVENTLOG_READEVENTLOGW", NDR_EVENTLOG_READEVENTLOGW, api_eventlog_ReadEventLogW},
1763 {"EVENTLOG_REPORTEVENTW", NDR_EVENTLOG_REPORTEVENTW, api_eventlog_ReportEventW},
1764 {"EVENTLOG_CLEAREVENTLOGA", NDR_EVENTLOG_CLEAREVENTLOGA, api_eventlog_ClearEventLogA},
1765 {"EVENTLOG_BACKUPEVENTLOGA", NDR_EVENTLOG_BACKUPEVENTLOGA, api_eventlog_BackupEventLogA},
1766 {"EVENTLOG_OPENEVENTLOGA", NDR_EVENTLOG_OPENEVENTLOGA, api_eventlog_OpenEventLogA},
1767 {"EVENTLOG_REGISTEREVENTSOURCEA", NDR_EVENTLOG_REGISTEREVENTSOURCEA, api_eventlog_RegisterEventSourceA},
1768 {"EVENTLOG_OPENBACKUPEVENTLOGA", NDR_EVENTLOG_OPENBACKUPEVENTLOGA, api_eventlog_OpenBackupEventLogA},
1769 {"EVENTLOG_READEVENTLOGA", NDR_EVENTLOG_READEVENTLOGA, api_eventlog_ReadEventLogA},
1770 {"EVENTLOG_REPORTEVENTA", NDR_EVENTLOG_REPORTEVENTA, api_eventlog_ReportEventA},
1771 {"EVENTLOG_REGISTERCLUSTERSVC", NDR_EVENTLOG_REGISTERCLUSTERSVC, api_eventlog_RegisterClusterSvc},
1772 {"EVENTLOG_DEREGISTERCLUSTERSVC", NDR_EVENTLOG_DEREGISTERCLUSTERSVC, api_eventlog_DeregisterClusterSvc},
1773 {"EVENTLOG_WRITECLUSTEREVENTS", NDR_EVENTLOG_WRITECLUSTEREVENTS, api_eventlog_WriteClusterEvents},
1774 {"EVENTLOG_GETLOGINTORMATION", NDR_EVENTLOG_GETLOGINTORMATION, api_eventlog_GetLogIntormation},
1775 {"EVENTLOG_FLUSHEVENTLOG", NDR_EVENTLOG_FLUSHEVENTLOG, api_eventlog_FlushEventLog},
1778 void eventlog_get_pipe_fns(struct api_struct **fns, int *n_fns)
1780 *fns = api_eventlog_cmds;
1781 *n_fns = sizeof(api_eventlog_cmds) / sizeof(struct api_struct);
1784 NTSTATUS rpc_eventlog_init(void)
1786 return rpc_pipe_register_commands(SMB_RPC_INTERFACE_VERSION, "eventlog", "eventlog", api_eventlog_cmds, sizeof(api_eventlog_cmds) / sizeof(struct api_struct));