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(talloc_tos(), struct eventlog_ClearEventLogW);
25 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
30 pull = ndr_pull_init_blob(&blob, r, NULL);
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, NULL);
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(talloc_tos(), struct eventlog_BackupEventLogW);
98 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
103 pull = ndr_pull_init_blob(&blob, r, NULL);
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, NULL);
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(talloc_tos(), struct eventlog_CloseEventLog);
171 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
176 pull = ndr_pull_init_blob(&blob, r, NULL);
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, NULL);
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(talloc_tos(), struct eventlog_DeregisterEventSource);
246 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
251 pull = ndr_pull_init_blob(&blob, r, NULL);
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, NULL);
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(talloc_tos(), struct eventlog_GetNumRecords);
319 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
324 pull = ndr_pull_init_blob(&blob, r, NULL);
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, NULL);
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(talloc_tos(), struct eventlog_GetOldestRecord);
399 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
404 pull = ndr_pull_init_blob(&blob, r, NULL);
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);
422 r->out.oldest_entry = talloc_zero(r, uint32_t);
423 if (r->out.oldest_entry == NULL) {
428 r->out.result = _eventlog_GetOldestRecord(p, r);
430 if (p->rng_fault_state) {
432 /* Return true here, srv_pipe_hnd.c will take care */
436 if (DEBUGLEVEL >= 10) {
437 NDR_PRINT_OUT_DEBUG(eventlog_GetOldestRecord, r);
440 push = ndr_push_init_ctx(r, NULL);
446 ndr_err = call->ndr_push(push, NDR_OUT, r);
447 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
452 blob = ndr_push_blob(push);
453 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
463 static bool api_eventlog_ChangeNotify(pipes_struct *p)
465 const struct ndr_interface_call *call;
466 struct ndr_pull *pull;
467 struct ndr_push *push;
468 enum ndr_err_code ndr_err;
470 struct eventlog_ChangeNotify *r;
472 call = &ndr_table_eventlog.calls[NDR_EVENTLOG_CHANGENOTIFY];
474 r = talloc(talloc_tos(), struct eventlog_ChangeNotify);
479 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
484 pull = ndr_pull_init_blob(&blob, r, NULL);
490 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
491 ndr_err = call->ndr_pull(pull, NDR_IN, r);
492 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
497 if (DEBUGLEVEL >= 10) {
498 NDR_PRINT_IN_DEBUG(eventlog_ChangeNotify, r);
501 r->out.result = _eventlog_ChangeNotify(p, r);
503 if (p->rng_fault_state) {
505 /* Return true here, srv_pipe_hnd.c will take care */
509 if (DEBUGLEVEL >= 10) {
510 NDR_PRINT_OUT_DEBUG(eventlog_ChangeNotify, r);
513 push = ndr_push_init_ctx(r, NULL);
519 ndr_err = call->ndr_push(push, NDR_OUT, r);
520 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
525 blob = ndr_push_blob(push);
526 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
536 static bool api_eventlog_OpenEventLogW(pipes_struct *p)
538 const struct ndr_interface_call *call;
539 struct ndr_pull *pull;
540 struct ndr_push *push;
541 enum ndr_err_code ndr_err;
543 struct eventlog_OpenEventLogW *r;
545 call = &ndr_table_eventlog.calls[NDR_EVENTLOG_OPENEVENTLOGW];
547 r = talloc(talloc_tos(), struct eventlog_OpenEventLogW);
552 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
557 pull = ndr_pull_init_blob(&blob, r, NULL);
563 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
564 ndr_err = call->ndr_pull(pull, NDR_IN, r);
565 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
570 if (DEBUGLEVEL >= 10) {
571 NDR_PRINT_IN_DEBUG(eventlog_OpenEventLogW, r);
575 r->out.handle = talloc_zero(r, struct policy_handle);
576 if (r->out.handle == NULL) {
581 r->out.result = _eventlog_OpenEventLogW(p, r);
583 if (p->rng_fault_state) {
585 /* Return true here, srv_pipe_hnd.c will take care */
589 if (DEBUGLEVEL >= 10) {
590 NDR_PRINT_OUT_DEBUG(eventlog_OpenEventLogW, r);
593 push = ndr_push_init_ctx(r, NULL);
599 ndr_err = call->ndr_push(push, NDR_OUT, r);
600 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
605 blob = ndr_push_blob(push);
606 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
616 static bool api_eventlog_RegisterEventSourceW(pipes_struct *p)
618 const struct ndr_interface_call *call;
619 struct ndr_pull *pull;
620 struct ndr_push *push;
621 enum ndr_err_code ndr_err;
623 struct eventlog_RegisterEventSourceW *r;
625 call = &ndr_table_eventlog.calls[NDR_EVENTLOG_REGISTEREVENTSOURCEW];
627 r = talloc(talloc_tos(), struct eventlog_RegisterEventSourceW);
632 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
637 pull = ndr_pull_init_blob(&blob, r, NULL);
643 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
644 ndr_err = call->ndr_pull(pull, NDR_IN, r);
645 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
650 if (DEBUGLEVEL >= 10) {
651 NDR_PRINT_IN_DEBUG(eventlog_RegisterEventSourceW, r);
654 r->out.result = _eventlog_RegisterEventSourceW(p, r);
656 if (p->rng_fault_state) {
658 /* Return true here, srv_pipe_hnd.c will take care */
662 if (DEBUGLEVEL >= 10) {
663 NDR_PRINT_OUT_DEBUG(eventlog_RegisterEventSourceW, r);
666 push = ndr_push_init_ctx(r, NULL);
672 ndr_err = call->ndr_push(push, NDR_OUT, r);
673 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
678 blob = ndr_push_blob(push);
679 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
689 static bool api_eventlog_OpenBackupEventLogW(pipes_struct *p)
691 const struct ndr_interface_call *call;
692 struct ndr_pull *pull;
693 struct ndr_push *push;
694 enum ndr_err_code ndr_err;
696 struct eventlog_OpenBackupEventLogW *r;
698 call = &ndr_table_eventlog.calls[NDR_EVENTLOG_OPENBACKUPEVENTLOGW];
700 r = talloc(talloc_tos(), struct eventlog_OpenBackupEventLogW);
705 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
710 pull = ndr_pull_init_blob(&blob, r, NULL);
716 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
717 ndr_err = call->ndr_pull(pull, NDR_IN, r);
718 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
723 if (DEBUGLEVEL >= 10) {
724 NDR_PRINT_IN_DEBUG(eventlog_OpenBackupEventLogW, r);
727 r->out.result = _eventlog_OpenBackupEventLogW(p, r);
729 if (p->rng_fault_state) {
731 /* Return true here, srv_pipe_hnd.c will take care */
735 if (DEBUGLEVEL >= 10) {
736 NDR_PRINT_OUT_DEBUG(eventlog_OpenBackupEventLogW, r);
739 push = ndr_push_init_ctx(r, NULL);
745 ndr_err = call->ndr_push(push, NDR_OUT, r);
746 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
751 blob = ndr_push_blob(push);
752 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
762 static bool api_eventlog_ReadEventLogW(pipes_struct *p)
764 const struct ndr_interface_call *call;
765 struct ndr_pull *pull;
766 struct ndr_push *push;
767 enum ndr_err_code ndr_err;
769 struct eventlog_ReadEventLogW *r;
771 call = &ndr_table_eventlog.calls[NDR_EVENTLOG_READEVENTLOGW];
773 r = talloc(talloc_tos(), struct eventlog_ReadEventLogW);
778 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
783 pull = ndr_pull_init_blob(&blob, r, NULL);
789 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
790 ndr_err = call->ndr_pull(pull, NDR_IN, r);
791 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
796 if (DEBUGLEVEL >= 10) {
797 NDR_PRINT_IN_DEBUG(eventlog_ReadEventLogW, r);
801 r->out.data = talloc_zero_array(r, uint8_t, r->in.number_of_bytes);
802 if (r->out.data == NULL) {
807 r->out.sent_size = talloc_zero(r, uint32_t);
808 if (r->out.sent_size == NULL) {
813 r->out.real_size = talloc_zero(r, uint32_t);
814 if (r->out.real_size == NULL) {
819 r->out.result = _eventlog_ReadEventLogW(p, r);
821 if (p->rng_fault_state) {
823 /* Return true here, srv_pipe_hnd.c will take care */
827 if (DEBUGLEVEL >= 10) {
828 NDR_PRINT_OUT_DEBUG(eventlog_ReadEventLogW, r);
831 push = ndr_push_init_ctx(r, NULL);
837 ndr_err = call->ndr_push(push, NDR_OUT, r);
838 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
843 blob = ndr_push_blob(push);
844 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
854 static bool api_eventlog_ReportEventW(pipes_struct *p)
856 const struct ndr_interface_call *call;
857 struct ndr_pull *pull;
858 struct ndr_push *push;
859 enum ndr_err_code ndr_err;
861 struct eventlog_ReportEventW *r;
863 call = &ndr_table_eventlog.calls[NDR_EVENTLOG_REPORTEVENTW];
865 r = talloc(talloc_tos(), struct eventlog_ReportEventW);
870 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
875 pull = ndr_pull_init_blob(&blob, r, NULL);
881 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
882 ndr_err = call->ndr_pull(pull, NDR_IN, r);
883 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
888 if (DEBUGLEVEL >= 10) {
889 NDR_PRINT_IN_DEBUG(eventlog_ReportEventW, r);
892 r->out.result = _eventlog_ReportEventW(p, r);
894 if (p->rng_fault_state) {
896 /* Return true here, srv_pipe_hnd.c will take care */
900 if (DEBUGLEVEL >= 10) {
901 NDR_PRINT_OUT_DEBUG(eventlog_ReportEventW, r);
904 push = ndr_push_init_ctx(r, NULL);
910 ndr_err = call->ndr_push(push, NDR_OUT, r);
911 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
916 blob = ndr_push_blob(push);
917 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
927 static bool api_eventlog_ClearEventLogA(pipes_struct *p)
929 const struct ndr_interface_call *call;
930 struct ndr_pull *pull;
931 struct ndr_push *push;
932 enum ndr_err_code ndr_err;
934 struct eventlog_ClearEventLogA *r;
936 call = &ndr_table_eventlog.calls[NDR_EVENTLOG_CLEAREVENTLOGA];
938 r = talloc(talloc_tos(), struct eventlog_ClearEventLogA);
943 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
948 pull = ndr_pull_init_blob(&blob, r, NULL);
954 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
955 ndr_err = call->ndr_pull(pull, NDR_IN, r);
956 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
961 if (DEBUGLEVEL >= 10) {
962 NDR_PRINT_IN_DEBUG(eventlog_ClearEventLogA, r);
965 r->out.result = _eventlog_ClearEventLogA(p, r);
967 if (p->rng_fault_state) {
969 /* Return true here, srv_pipe_hnd.c will take care */
973 if (DEBUGLEVEL >= 10) {
974 NDR_PRINT_OUT_DEBUG(eventlog_ClearEventLogA, r);
977 push = ndr_push_init_ctx(r, NULL);
983 ndr_err = call->ndr_push(push, NDR_OUT, r);
984 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
989 blob = ndr_push_blob(push);
990 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1000 static bool api_eventlog_BackupEventLogA(pipes_struct *p)
1002 const struct ndr_interface_call *call;
1003 struct ndr_pull *pull;
1004 struct ndr_push *push;
1005 enum ndr_err_code ndr_err;
1007 struct eventlog_BackupEventLogA *r;
1009 call = &ndr_table_eventlog.calls[NDR_EVENTLOG_BACKUPEVENTLOGA];
1011 r = talloc(talloc_tos(), struct eventlog_BackupEventLogA);
1016 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1021 pull = ndr_pull_init_blob(&blob, r, NULL);
1027 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1028 ndr_err = call->ndr_pull(pull, NDR_IN, r);
1029 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1034 if (DEBUGLEVEL >= 10) {
1035 NDR_PRINT_IN_DEBUG(eventlog_BackupEventLogA, r);
1038 r->out.result = _eventlog_BackupEventLogA(p, r);
1040 if (p->rng_fault_state) {
1042 /* Return true here, srv_pipe_hnd.c will take care */
1046 if (DEBUGLEVEL >= 10) {
1047 NDR_PRINT_OUT_DEBUG(eventlog_BackupEventLogA, r);
1050 push = ndr_push_init_ctx(r, NULL);
1056 ndr_err = call->ndr_push(push, NDR_OUT, r);
1057 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1062 blob = ndr_push_blob(push);
1063 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1073 static bool api_eventlog_OpenEventLogA(pipes_struct *p)
1075 const struct ndr_interface_call *call;
1076 struct ndr_pull *pull;
1077 struct ndr_push *push;
1078 enum ndr_err_code ndr_err;
1080 struct eventlog_OpenEventLogA *r;
1082 call = &ndr_table_eventlog.calls[NDR_EVENTLOG_OPENEVENTLOGA];
1084 r = talloc(talloc_tos(), struct eventlog_OpenEventLogA);
1089 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1094 pull = ndr_pull_init_blob(&blob, r, NULL);
1100 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1101 ndr_err = call->ndr_pull(pull, NDR_IN, r);
1102 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1107 if (DEBUGLEVEL >= 10) {
1108 NDR_PRINT_IN_DEBUG(eventlog_OpenEventLogA, r);
1111 r->out.result = _eventlog_OpenEventLogA(p, r);
1113 if (p->rng_fault_state) {
1115 /* Return true here, srv_pipe_hnd.c will take care */
1119 if (DEBUGLEVEL >= 10) {
1120 NDR_PRINT_OUT_DEBUG(eventlog_OpenEventLogA, r);
1123 push = ndr_push_init_ctx(r, NULL);
1129 ndr_err = call->ndr_push(push, NDR_OUT, r);
1130 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1135 blob = ndr_push_blob(push);
1136 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1146 static bool api_eventlog_RegisterEventSourceA(pipes_struct *p)
1148 const struct ndr_interface_call *call;
1149 struct ndr_pull *pull;
1150 struct ndr_push *push;
1151 enum ndr_err_code ndr_err;
1153 struct eventlog_RegisterEventSourceA *r;
1155 call = &ndr_table_eventlog.calls[NDR_EVENTLOG_REGISTEREVENTSOURCEA];
1157 r = talloc(talloc_tos(), struct eventlog_RegisterEventSourceA);
1162 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1167 pull = ndr_pull_init_blob(&blob, r, NULL);
1173 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1174 ndr_err = call->ndr_pull(pull, NDR_IN, r);
1175 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1180 if (DEBUGLEVEL >= 10) {
1181 NDR_PRINT_IN_DEBUG(eventlog_RegisterEventSourceA, r);
1184 r->out.result = _eventlog_RegisterEventSourceA(p, r);
1186 if (p->rng_fault_state) {
1188 /* Return true here, srv_pipe_hnd.c will take care */
1192 if (DEBUGLEVEL >= 10) {
1193 NDR_PRINT_OUT_DEBUG(eventlog_RegisterEventSourceA, r);
1196 push = ndr_push_init_ctx(r, NULL);
1202 ndr_err = call->ndr_push(push, NDR_OUT, r);
1203 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1208 blob = ndr_push_blob(push);
1209 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1219 static bool api_eventlog_OpenBackupEventLogA(pipes_struct *p)
1221 const struct ndr_interface_call *call;
1222 struct ndr_pull *pull;
1223 struct ndr_push *push;
1224 enum ndr_err_code ndr_err;
1226 struct eventlog_OpenBackupEventLogA *r;
1228 call = &ndr_table_eventlog.calls[NDR_EVENTLOG_OPENBACKUPEVENTLOGA];
1230 r = talloc(talloc_tos(), struct eventlog_OpenBackupEventLogA);
1235 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1240 pull = ndr_pull_init_blob(&blob, r, NULL);
1246 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1247 ndr_err = call->ndr_pull(pull, NDR_IN, r);
1248 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1253 if (DEBUGLEVEL >= 10) {
1254 NDR_PRINT_IN_DEBUG(eventlog_OpenBackupEventLogA, r);
1257 r->out.result = _eventlog_OpenBackupEventLogA(p, r);
1259 if (p->rng_fault_state) {
1261 /* Return true here, srv_pipe_hnd.c will take care */
1265 if (DEBUGLEVEL >= 10) {
1266 NDR_PRINT_OUT_DEBUG(eventlog_OpenBackupEventLogA, r);
1269 push = ndr_push_init_ctx(r, NULL);
1275 ndr_err = call->ndr_push(push, NDR_OUT, r);
1276 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1281 blob = ndr_push_blob(push);
1282 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1292 static bool api_eventlog_ReadEventLogA(pipes_struct *p)
1294 const struct ndr_interface_call *call;
1295 struct ndr_pull *pull;
1296 struct ndr_push *push;
1297 enum ndr_err_code ndr_err;
1299 struct eventlog_ReadEventLogA *r;
1301 call = &ndr_table_eventlog.calls[NDR_EVENTLOG_READEVENTLOGA];
1303 r = talloc(talloc_tos(), struct eventlog_ReadEventLogA);
1308 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1313 pull = ndr_pull_init_blob(&blob, r, NULL);
1319 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1320 ndr_err = call->ndr_pull(pull, NDR_IN, r);
1321 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1326 if (DEBUGLEVEL >= 10) {
1327 NDR_PRINT_IN_DEBUG(eventlog_ReadEventLogA, r);
1330 r->out.result = _eventlog_ReadEventLogA(p, r);
1332 if (p->rng_fault_state) {
1334 /* Return true here, srv_pipe_hnd.c will take care */
1338 if (DEBUGLEVEL >= 10) {
1339 NDR_PRINT_OUT_DEBUG(eventlog_ReadEventLogA, r);
1342 push = ndr_push_init_ctx(r, NULL);
1348 ndr_err = call->ndr_push(push, NDR_OUT, r);
1349 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1354 blob = ndr_push_blob(push);
1355 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1365 static bool api_eventlog_ReportEventA(pipes_struct *p)
1367 const struct ndr_interface_call *call;
1368 struct ndr_pull *pull;
1369 struct ndr_push *push;
1370 enum ndr_err_code ndr_err;
1372 struct eventlog_ReportEventA *r;
1374 call = &ndr_table_eventlog.calls[NDR_EVENTLOG_REPORTEVENTA];
1376 r = talloc(talloc_tos(), struct eventlog_ReportEventA);
1381 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1386 pull = ndr_pull_init_blob(&blob, r, NULL);
1392 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1393 ndr_err = call->ndr_pull(pull, NDR_IN, r);
1394 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1399 if (DEBUGLEVEL >= 10) {
1400 NDR_PRINT_IN_DEBUG(eventlog_ReportEventA, r);
1403 r->out.result = _eventlog_ReportEventA(p, r);
1405 if (p->rng_fault_state) {
1407 /* Return true here, srv_pipe_hnd.c will take care */
1411 if (DEBUGLEVEL >= 10) {
1412 NDR_PRINT_OUT_DEBUG(eventlog_ReportEventA, r);
1415 push = ndr_push_init_ctx(r, NULL);
1421 ndr_err = call->ndr_push(push, NDR_OUT, r);
1422 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1427 blob = ndr_push_blob(push);
1428 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1438 static bool api_eventlog_RegisterClusterSvc(pipes_struct *p)
1440 const struct ndr_interface_call *call;
1441 struct ndr_pull *pull;
1442 struct ndr_push *push;
1443 enum ndr_err_code ndr_err;
1445 struct eventlog_RegisterClusterSvc *r;
1447 call = &ndr_table_eventlog.calls[NDR_EVENTLOG_REGISTERCLUSTERSVC];
1449 r = talloc(talloc_tos(), struct eventlog_RegisterClusterSvc);
1454 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1459 pull = ndr_pull_init_blob(&blob, r, NULL);
1465 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1466 ndr_err = call->ndr_pull(pull, NDR_IN, r);
1467 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1472 if (DEBUGLEVEL >= 10) {
1473 NDR_PRINT_IN_DEBUG(eventlog_RegisterClusterSvc, r);
1476 r->out.result = _eventlog_RegisterClusterSvc(p, r);
1478 if (p->rng_fault_state) {
1480 /* Return true here, srv_pipe_hnd.c will take care */
1484 if (DEBUGLEVEL >= 10) {
1485 NDR_PRINT_OUT_DEBUG(eventlog_RegisterClusterSvc, r);
1488 push = ndr_push_init_ctx(r, NULL);
1494 ndr_err = call->ndr_push(push, NDR_OUT, r);
1495 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1500 blob = ndr_push_blob(push);
1501 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1511 static bool api_eventlog_DeregisterClusterSvc(pipes_struct *p)
1513 const struct ndr_interface_call *call;
1514 struct ndr_pull *pull;
1515 struct ndr_push *push;
1516 enum ndr_err_code ndr_err;
1518 struct eventlog_DeregisterClusterSvc *r;
1520 call = &ndr_table_eventlog.calls[NDR_EVENTLOG_DEREGISTERCLUSTERSVC];
1522 r = talloc(talloc_tos(), struct eventlog_DeregisterClusterSvc);
1527 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1532 pull = ndr_pull_init_blob(&blob, r, NULL);
1538 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1539 ndr_err = call->ndr_pull(pull, NDR_IN, r);
1540 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1545 if (DEBUGLEVEL >= 10) {
1546 NDR_PRINT_IN_DEBUG(eventlog_DeregisterClusterSvc, r);
1549 r->out.result = _eventlog_DeregisterClusterSvc(p, r);
1551 if (p->rng_fault_state) {
1553 /* Return true here, srv_pipe_hnd.c will take care */
1557 if (DEBUGLEVEL >= 10) {
1558 NDR_PRINT_OUT_DEBUG(eventlog_DeregisterClusterSvc, r);
1561 push = ndr_push_init_ctx(r, NULL);
1567 ndr_err = call->ndr_push(push, NDR_OUT, r);
1568 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1573 blob = ndr_push_blob(push);
1574 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1584 static bool api_eventlog_WriteClusterEvents(pipes_struct *p)
1586 const struct ndr_interface_call *call;
1587 struct ndr_pull *pull;
1588 struct ndr_push *push;
1589 enum ndr_err_code ndr_err;
1591 struct eventlog_WriteClusterEvents *r;
1593 call = &ndr_table_eventlog.calls[NDR_EVENTLOG_WRITECLUSTEREVENTS];
1595 r = talloc(talloc_tos(), struct eventlog_WriteClusterEvents);
1600 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1605 pull = ndr_pull_init_blob(&blob, r, NULL);
1611 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1612 ndr_err = call->ndr_pull(pull, NDR_IN, r);
1613 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1618 if (DEBUGLEVEL >= 10) {
1619 NDR_PRINT_IN_DEBUG(eventlog_WriteClusterEvents, r);
1622 r->out.result = _eventlog_WriteClusterEvents(p, r);
1624 if (p->rng_fault_state) {
1626 /* Return true here, srv_pipe_hnd.c will take care */
1630 if (DEBUGLEVEL >= 10) {
1631 NDR_PRINT_OUT_DEBUG(eventlog_WriteClusterEvents, r);
1634 push = ndr_push_init_ctx(r, NULL);
1640 ndr_err = call->ndr_push(push, NDR_OUT, r);
1641 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1646 blob = ndr_push_blob(push);
1647 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1657 static bool api_eventlog_GetLogIntormation(pipes_struct *p)
1659 const struct ndr_interface_call *call;
1660 struct ndr_pull *pull;
1661 struct ndr_push *push;
1662 enum ndr_err_code ndr_err;
1664 struct eventlog_GetLogIntormation *r;
1666 call = &ndr_table_eventlog.calls[NDR_EVENTLOG_GETLOGINTORMATION];
1668 r = talloc(talloc_tos(), struct eventlog_GetLogIntormation);
1673 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1678 pull = ndr_pull_init_blob(&blob, r, NULL);
1684 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1685 ndr_err = call->ndr_pull(pull, NDR_IN, r);
1686 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1691 if (DEBUGLEVEL >= 10) {
1692 NDR_PRINT_IN_DEBUG(eventlog_GetLogIntormation, r);
1695 r->out.result = _eventlog_GetLogIntormation(p, r);
1697 if (p->rng_fault_state) {
1699 /* Return true here, srv_pipe_hnd.c will take care */
1703 if (DEBUGLEVEL >= 10) {
1704 NDR_PRINT_OUT_DEBUG(eventlog_GetLogIntormation, r);
1707 push = ndr_push_init_ctx(r, NULL);
1713 ndr_err = call->ndr_push(push, NDR_OUT, r);
1714 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1719 blob = ndr_push_blob(push);
1720 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1730 static bool api_eventlog_FlushEventLog(pipes_struct *p)
1732 const struct ndr_interface_call *call;
1733 struct ndr_pull *pull;
1734 struct ndr_push *push;
1735 enum ndr_err_code ndr_err;
1737 struct eventlog_FlushEventLog *r;
1739 call = &ndr_table_eventlog.calls[NDR_EVENTLOG_FLUSHEVENTLOG];
1741 r = talloc(talloc_tos(), struct eventlog_FlushEventLog);
1746 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1751 pull = ndr_pull_init_blob(&blob, r, NULL);
1757 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1758 ndr_err = call->ndr_pull(pull, NDR_IN, r);
1759 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1764 if (DEBUGLEVEL >= 10) {
1765 NDR_PRINT_IN_DEBUG(eventlog_FlushEventLog, r);
1768 r->out.result = _eventlog_FlushEventLog(p, r);
1770 if (p->rng_fault_state) {
1772 /* Return true here, srv_pipe_hnd.c will take care */
1776 if (DEBUGLEVEL >= 10) {
1777 NDR_PRINT_OUT_DEBUG(eventlog_FlushEventLog, r);
1780 push = ndr_push_init_ctx(r, NULL);
1786 ndr_err = call->ndr_push(push, NDR_OUT, r);
1787 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1792 blob = ndr_push_blob(push);
1793 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1805 static struct api_struct api_eventlog_cmds[] =
1807 {"EVENTLOG_CLEAREVENTLOGW", NDR_EVENTLOG_CLEAREVENTLOGW, api_eventlog_ClearEventLogW},
1808 {"EVENTLOG_BACKUPEVENTLOGW", NDR_EVENTLOG_BACKUPEVENTLOGW, api_eventlog_BackupEventLogW},
1809 {"EVENTLOG_CLOSEEVENTLOG", NDR_EVENTLOG_CLOSEEVENTLOG, api_eventlog_CloseEventLog},
1810 {"EVENTLOG_DEREGISTEREVENTSOURCE", NDR_EVENTLOG_DEREGISTEREVENTSOURCE, api_eventlog_DeregisterEventSource},
1811 {"EVENTLOG_GETNUMRECORDS", NDR_EVENTLOG_GETNUMRECORDS, api_eventlog_GetNumRecords},
1812 {"EVENTLOG_GETOLDESTRECORD", NDR_EVENTLOG_GETOLDESTRECORD, api_eventlog_GetOldestRecord},
1813 {"EVENTLOG_CHANGENOTIFY", NDR_EVENTLOG_CHANGENOTIFY, api_eventlog_ChangeNotify},
1814 {"EVENTLOG_OPENEVENTLOGW", NDR_EVENTLOG_OPENEVENTLOGW, api_eventlog_OpenEventLogW},
1815 {"EVENTLOG_REGISTEREVENTSOURCEW", NDR_EVENTLOG_REGISTEREVENTSOURCEW, api_eventlog_RegisterEventSourceW},
1816 {"EVENTLOG_OPENBACKUPEVENTLOGW", NDR_EVENTLOG_OPENBACKUPEVENTLOGW, api_eventlog_OpenBackupEventLogW},
1817 {"EVENTLOG_READEVENTLOGW", NDR_EVENTLOG_READEVENTLOGW, api_eventlog_ReadEventLogW},
1818 {"EVENTLOG_REPORTEVENTW", NDR_EVENTLOG_REPORTEVENTW, api_eventlog_ReportEventW},
1819 {"EVENTLOG_CLEAREVENTLOGA", NDR_EVENTLOG_CLEAREVENTLOGA, api_eventlog_ClearEventLogA},
1820 {"EVENTLOG_BACKUPEVENTLOGA", NDR_EVENTLOG_BACKUPEVENTLOGA, api_eventlog_BackupEventLogA},
1821 {"EVENTLOG_OPENEVENTLOGA", NDR_EVENTLOG_OPENEVENTLOGA, api_eventlog_OpenEventLogA},
1822 {"EVENTLOG_REGISTEREVENTSOURCEA", NDR_EVENTLOG_REGISTEREVENTSOURCEA, api_eventlog_RegisterEventSourceA},
1823 {"EVENTLOG_OPENBACKUPEVENTLOGA", NDR_EVENTLOG_OPENBACKUPEVENTLOGA, api_eventlog_OpenBackupEventLogA},
1824 {"EVENTLOG_READEVENTLOGA", NDR_EVENTLOG_READEVENTLOGA, api_eventlog_ReadEventLogA},
1825 {"EVENTLOG_REPORTEVENTA", NDR_EVENTLOG_REPORTEVENTA, api_eventlog_ReportEventA},
1826 {"EVENTLOG_REGISTERCLUSTERSVC", NDR_EVENTLOG_REGISTERCLUSTERSVC, api_eventlog_RegisterClusterSvc},
1827 {"EVENTLOG_DEREGISTERCLUSTERSVC", NDR_EVENTLOG_DEREGISTERCLUSTERSVC, api_eventlog_DeregisterClusterSvc},
1828 {"EVENTLOG_WRITECLUSTEREVENTS", NDR_EVENTLOG_WRITECLUSTEREVENTS, api_eventlog_WriteClusterEvents},
1829 {"EVENTLOG_GETLOGINTORMATION", NDR_EVENTLOG_GETLOGINTORMATION, api_eventlog_GetLogIntormation},
1830 {"EVENTLOG_FLUSHEVENTLOG", NDR_EVENTLOG_FLUSHEVENTLOG, api_eventlog_FlushEventLog},
1833 void eventlog_get_pipe_fns(struct api_struct **fns, int *n_fns)
1835 *fns = api_eventlog_cmds;
1836 *n_fns = sizeof(api_eventlog_cmds) / sizeof(struct api_struct);
1839 NTSTATUS rpc_eventlog_init(void)
1841 return rpc_pipe_register_commands(SMB_RPC_INTERFACE_VERSION, "eventlog", "eventlog", &ndr_table_eventlog.syntax_id, api_eventlog_cmds, sizeof(api_eventlog_cmds) / sizeof(struct api_struct));