2 * Unix SMB/CIFS implementation.
3 * client auto-generated by pidl. DO NOT MODIFY!
7 #include "../librpc/gen_ndr/cli_eventlog.h"
9 struct rpccli_eventlog_ClearEventLogW_state
{
10 struct eventlog_ClearEventLogW orig
;
11 struct eventlog_ClearEventLogW tmp
;
12 TALLOC_CTX
*out_mem_ctx
;
13 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
16 static void rpccli_eventlog_ClearEventLogW_done(struct tevent_req
*subreq
);
18 struct tevent_req
*rpccli_eventlog_ClearEventLogW_send(TALLOC_CTX
*mem_ctx
,
19 struct tevent_context
*ev
,
20 struct rpc_pipe_client
*cli
,
21 struct policy_handle
*_handle
/* [in] [ref] */,
22 struct lsa_String
*_backupfile
/* [in] [unique] */)
24 struct tevent_req
*req
;
25 struct rpccli_eventlog_ClearEventLogW_state
*state
;
26 struct tevent_req
*subreq
;
28 req
= tevent_req_create(mem_ctx
, &state
,
29 struct rpccli_eventlog_ClearEventLogW_state
);
33 state
->out_mem_ctx
= NULL
;
34 state
->dispatch_recv
= cli
->dispatch_recv
;
37 state
->orig
.in
.handle
= _handle
;
38 state
->orig
.in
.backupfile
= _backupfile
;
43 ZERO_STRUCT(state
->orig
.out
.result
);
45 /* make a temporary copy, that we pass to the dispatch function */
46 state
->tmp
= state
->orig
;
48 subreq
= cli
->dispatch_send(state
, ev
, cli
,
49 NDR_EVENTLOG_UUID
, NDR_EVENTLOG_VERSION
,
50 NDR_EVENTLOG_CLEAREVENTLOGW
,
52 if (tevent_req_nomem(subreq
, req
)) {
53 return tevent_req_post(req
, ev
);
55 tevent_req_set_callback(subreq
, rpccli_eventlog_ClearEventLogW_done
, req
);
59 static void rpccli_eventlog_ClearEventLogW_done(struct tevent_req
*subreq
)
61 struct tevent_req
*req
= tevent_req_callback_data(
62 subreq
, struct tevent_req
);
63 struct rpccli_eventlog_ClearEventLogW_state
*state
= tevent_req_data(
64 req
, struct rpccli_eventlog_ClearEventLogW_state
);
68 if (state
->out_mem_ctx
) {
69 mem_ctx
= state
->out_mem_ctx
;
74 status
= state
->dispatch_recv(subreq
, mem_ctx
);
76 if (!NT_STATUS_IS_OK(status
)) {
77 tevent_req_nterror(req
, status
);
81 /* Copy out parameters */
84 state
->orig
.out
.result
= state
->tmp
.out
.result
;
86 /* Reset temporary structure */
87 ZERO_STRUCT(state
->tmp
);
92 NTSTATUS
rpccli_eventlog_ClearEventLogW_recv(struct tevent_req
*req
,
96 struct rpccli_eventlog_ClearEventLogW_state
*state
= tevent_req_data(
97 req
, struct rpccli_eventlog_ClearEventLogW_state
);
100 if (tevent_req_is_nterror(req
, &status
)) {
101 tevent_req_received(req
);
105 /* Steal possbile out parameters to the callers context */
106 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
109 *result
= state
->orig
.out
.result
;
111 tevent_req_received(req
);
115 NTSTATUS
rpccli_eventlog_ClearEventLogW(struct rpc_pipe_client
*cli
,
117 struct policy_handle
*handle
/* [in] [ref] */,
118 struct lsa_String
*backupfile
/* [in] [unique] */)
120 struct eventlog_ClearEventLogW r
;
124 r
.in
.handle
= handle
;
125 r
.in
.backupfile
= backupfile
;
127 status
= cli
->dispatch(cli
,
129 NDR_EVENTLOG_UUID
, NDR_EVENTLOG_VERSION
,
130 NDR_EVENTLOG_CLEAREVENTLOGW
,
133 if (!NT_STATUS_IS_OK(status
)) {
137 if (NT_STATUS_IS_ERR(status
)) {
141 /* Return variables */
147 struct rpccli_eventlog_BackupEventLogW_state
{
148 struct eventlog_BackupEventLogW orig
;
149 struct eventlog_BackupEventLogW tmp
;
150 TALLOC_CTX
*out_mem_ctx
;
151 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
154 static void rpccli_eventlog_BackupEventLogW_done(struct tevent_req
*subreq
);
156 struct tevent_req
*rpccli_eventlog_BackupEventLogW_send(TALLOC_CTX
*mem_ctx
,
157 struct tevent_context
*ev
,
158 struct rpc_pipe_client
*cli
,
159 struct policy_handle
*_handle
/* [in] [ref] */,
160 struct lsa_String
*_backup_filename
/* [in] [ref] */)
162 struct tevent_req
*req
;
163 struct rpccli_eventlog_BackupEventLogW_state
*state
;
164 struct tevent_req
*subreq
;
166 req
= tevent_req_create(mem_ctx
, &state
,
167 struct rpccli_eventlog_BackupEventLogW_state
);
171 state
->out_mem_ctx
= NULL
;
172 state
->dispatch_recv
= cli
->dispatch_recv
;
175 state
->orig
.in
.handle
= _handle
;
176 state
->orig
.in
.backup_filename
= _backup_filename
;
181 ZERO_STRUCT(state
->orig
.out
.result
);
183 /* make a temporary copy, that we pass to the dispatch function */
184 state
->tmp
= state
->orig
;
186 subreq
= cli
->dispatch_send(state
, ev
, cli
,
187 NDR_EVENTLOG_UUID
, NDR_EVENTLOG_VERSION
,
188 NDR_EVENTLOG_BACKUPEVENTLOGW
,
190 if (tevent_req_nomem(subreq
, req
)) {
191 return tevent_req_post(req
, ev
);
193 tevent_req_set_callback(subreq
, rpccli_eventlog_BackupEventLogW_done
, req
);
197 static void rpccli_eventlog_BackupEventLogW_done(struct tevent_req
*subreq
)
199 struct tevent_req
*req
= tevent_req_callback_data(
200 subreq
, struct tevent_req
);
201 struct rpccli_eventlog_BackupEventLogW_state
*state
= tevent_req_data(
202 req
, struct rpccli_eventlog_BackupEventLogW_state
);
206 if (state
->out_mem_ctx
) {
207 mem_ctx
= state
->out_mem_ctx
;
212 status
= state
->dispatch_recv(subreq
, mem_ctx
);
214 if (!NT_STATUS_IS_OK(status
)) {
215 tevent_req_nterror(req
, status
);
219 /* Copy out parameters */
222 state
->orig
.out
.result
= state
->tmp
.out
.result
;
224 /* Reset temporary structure */
225 ZERO_STRUCT(state
->tmp
);
227 tevent_req_done(req
);
230 NTSTATUS
rpccli_eventlog_BackupEventLogW_recv(struct tevent_req
*req
,
234 struct rpccli_eventlog_BackupEventLogW_state
*state
= tevent_req_data(
235 req
, struct rpccli_eventlog_BackupEventLogW_state
);
238 if (tevent_req_is_nterror(req
, &status
)) {
239 tevent_req_received(req
);
243 /* Steal possbile out parameters to the callers context */
244 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
247 *result
= state
->orig
.out
.result
;
249 tevent_req_received(req
);
253 NTSTATUS
rpccli_eventlog_BackupEventLogW(struct rpc_pipe_client
*cli
,
255 struct policy_handle
*handle
/* [in] [ref] */,
256 struct lsa_String
*backup_filename
/* [in] [ref] */)
258 struct eventlog_BackupEventLogW r
;
262 r
.in
.handle
= handle
;
263 r
.in
.backup_filename
= backup_filename
;
265 status
= cli
->dispatch(cli
,
267 NDR_EVENTLOG_UUID
, NDR_EVENTLOG_VERSION
,
268 NDR_EVENTLOG_BACKUPEVENTLOGW
,
271 if (!NT_STATUS_IS_OK(status
)) {
275 if (NT_STATUS_IS_ERR(status
)) {
279 /* Return variables */
285 struct rpccli_eventlog_CloseEventLog_state
{
286 struct eventlog_CloseEventLog orig
;
287 struct eventlog_CloseEventLog tmp
;
288 TALLOC_CTX
*out_mem_ctx
;
289 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
292 static void rpccli_eventlog_CloseEventLog_done(struct tevent_req
*subreq
);
294 struct tevent_req
*rpccli_eventlog_CloseEventLog_send(TALLOC_CTX
*mem_ctx
,
295 struct tevent_context
*ev
,
296 struct rpc_pipe_client
*cli
,
297 struct policy_handle
*_handle
/* [in,out] [ref] */)
299 struct tevent_req
*req
;
300 struct rpccli_eventlog_CloseEventLog_state
*state
;
301 struct tevent_req
*subreq
;
303 req
= tevent_req_create(mem_ctx
, &state
,
304 struct rpccli_eventlog_CloseEventLog_state
);
308 state
->out_mem_ctx
= NULL
;
309 state
->dispatch_recv
= cli
->dispatch_recv
;
312 state
->orig
.in
.handle
= _handle
;
315 state
->orig
.out
.handle
= _handle
;
318 ZERO_STRUCT(state
->orig
.out
.result
);
320 state
->out_mem_ctx
= talloc_named_const(state
, 0,
321 "rpccli_eventlog_CloseEventLog_out_memory");
322 if (tevent_req_nomem(state
->out_mem_ctx
, req
)) {
323 return tevent_req_post(req
, ev
);
326 /* make a temporary copy, that we pass to the dispatch function */
327 state
->tmp
= state
->orig
;
329 subreq
= cli
->dispatch_send(state
, ev
, cli
,
330 NDR_EVENTLOG_UUID
, NDR_EVENTLOG_VERSION
,
331 NDR_EVENTLOG_CLOSEEVENTLOG
,
333 if (tevent_req_nomem(subreq
, req
)) {
334 return tevent_req_post(req
, ev
);
336 tevent_req_set_callback(subreq
, rpccli_eventlog_CloseEventLog_done
, req
);
340 static void rpccli_eventlog_CloseEventLog_done(struct tevent_req
*subreq
)
342 struct tevent_req
*req
= tevent_req_callback_data(
343 subreq
, struct tevent_req
);
344 struct rpccli_eventlog_CloseEventLog_state
*state
= tevent_req_data(
345 req
, struct rpccli_eventlog_CloseEventLog_state
);
349 if (state
->out_mem_ctx
) {
350 mem_ctx
= state
->out_mem_ctx
;
355 status
= state
->dispatch_recv(subreq
, mem_ctx
);
357 if (!NT_STATUS_IS_OK(status
)) {
358 tevent_req_nterror(req
, status
);
362 /* Copy out parameters */
363 *state
->orig
.out
.handle
= *state
->tmp
.out
.handle
;
366 state
->orig
.out
.result
= state
->tmp
.out
.result
;
368 /* Reset temporary structure */
369 ZERO_STRUCT(state
->tmp
);
371 tevent_req_done(req
);
374 NTSTATUS
rpccli_eventlog_CloseEventLog_recv(struct tevent_req
*req
,
378 struct rpccli_eventlog_CloseEventLog_state
*state
= tevent_req_data(
379 req
, struct rpccli_eventlog_CloseEventLog_state
);
382 if (tevent_req_is_nterror(req
, &status
)) {
383 tevent_req_received(req
);
387 /* Steal possbile out parameters to the callers context */
388 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
391 *result
= state
->orig
.out
.result
;
393 tevent_req_received(req
);
397 NTSTATUS
rpccli_eventlog_CloseEventLog(struct rpc_pipe_client
*cli
,
399 struct policy_handle
*handle
/* [in,out] [ref] */)
401 struct eventlog_CloseEventLog r
;
405 r
.in
.handle
= handle
;
407 status
= cli
->dispatch(cli
,
409 NDR_EVENTLOG_UUID
, NDR_EVENTLOG_VERSION
,
410 NDR_EVENTLOG_CLOSEEVENTLOG
,
413 if (!NT_STATUS_IS_OK(status
)) {
417 if (NT_STATUS_IS_ERR(status
)) {
421 /* Return variables */
422 *handle
= *r
.out
.handle
;
428 struct rpccli_eventlog_DeregisterEventSource_state
{
429 struct eventlog_DeregisterEventSource orig
;
430 struct eventlog_DeregisterEventSource tmp
;
431 TALLOC_CTX
*out_mem_ctx
;
432 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
435 static void rpccli_eventlog_DeregisterEventSource_done(struct tevent_req
*subreq
);
437 struct tevent_req
*rpccli_eventlog_DeregisterEventSource_send(TALLOC_CTX
*mem_ctx
,
438 struct tevent_context
*ev
,
439 struct rpc_pipe_client
*cli
,
440 struct policy_handle
*_handle
/* [in,out] [ref] */)
442 struct tevent_req
*req
;
443 struct rpccli_eventlog_DeregisterEventSource_state
*state
;
444 struct tevent_req
*subreq
;
446 req
= tevent_req_create(mem_ctx
, &state
,
447 struct rpccli_eventlog_DeregisterEventSource_state
);
451 state
->out_mem_ctx
= NULL
;
452 state
->dispatch_recv
= cli
->dispatch_recv
;
455 state
->orig
.in
.handle
= _handle
;
458 state
->orig
.out
.handle
= _handle
;
461 ZERO_STRUCT(state
->orig
.out
.result
);
463 state
->out_mem_ctx
= talloc_named_const(state
, 0,
464 "rpccli_eventlog_DeregisterEventSource_out_memory");
465 if (tevent_req_nomem(state
->out_mem_ctx
, req
)) {
466 return tevent_req_post(req
, ev
);
469 /* make a temporary copy, that we pass to the dispatch function */
470 state
->tmp
= state
->orig
;
472 subreq
= cli
->dispatch_send(state
, ev
, cli
,
473 NDR_EVENTLOG_UUID
, NDR_EVENTLOG_VERSION
,
474 NDR_EVENTLOG_DEREGISTEREVENTSOURCE
,
476 if (tevent_req_nomem(subreq
, req
)) {
477 return tevent_req_post(req
, ev
);
479 tevent_req_set_callback(subreq
, rpccli_eventlog_DeregisterEventSource_done
, req
);
483 static void rpccli_eventlog_DeregisterEventSource_done(struct tevent_req
*subreq
)
485 struct tevent_req
*req
= tevent_req_callback_data(
486 subreq
, struct tevent_req
);
487 struct rpccli_eventlog_DeregisterEventSource_state
*state
= tevent_req_data(
488 req
, struct rpccli_eventlog_DeregisterEventSource_state
);
492 if (state
->out_mem_ctx
) {
493 mem_ctx
= state
->out_mem_ctx
;
498 status
= state
->dispatch_recv(subreq
, mem_ctx
);
500 if (!NT_STATUS_IS_OK(status
)) {
501 tevent_req_nterror(req
, status
);
505 /* Copy out parameters */
506 *state
->orig
.out
.handle
= *state
->tmp
.out
.handle
;
509 state
->orig
.out
.result
= state
->tmp
.out
.result
;
511 /* Reset temporary structure */
512 ZERO_STRUCT(state
->tmp
);
514 tevent_req_done(req
);
517 NTSTATUS
rpccli_eventlog_DeregisterEventSource_recv(struct tevent_req
*req
,
521 struct rpccli_eventlog_DeregisterEventSource_state
*state
= tevent_req_data(
522 req
, struct rpccli_eventlog_DeregisterEventSource_state
);
525 if (tevent_req_is_nterror(req
, &status
)) {
526 tevent_req_received(req
);
530 /* Steal possbile out parameters to the callers context */
531 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
534 *result
= state
->orig
.out
.result
;
536 tevent_req_received(req
);
540 NTSTATUS
rpccli_eventlog_DeregisterEventSource(struct rpc_pipe_client
*cli
,
542 struct policy_handle
*handle
/* [in,out] [ref] */)
544 struct eventlog_DeregisterEventSource r
;
548 r
.in
.handle
= handle
;
550 status
= cli
->dispatch(cli
,
552 NDR_EVENTLOG_UUID
, NDR_EVENTLOG_VERSION
,
553 NDR_EVENTLOG_DEREGISTEREVENTSOURCE
,
556 if (!NT_STATUS_IS_OK(status
)) {
560 if (NT_STATUS_IS_ERR(status
)) {
564 /* Return variables */
565 *handle
= *r
.out
.handle
;
571 struct rpccli_eventlog_GetNumRecords_state
{
572 struct eventlog_GetNumRecords orig
;
573 struct eventlog_GetNumRecords tmp
;
574 TALLOC_CTX
*out_mem_ctx
;
575 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
578 static void rpccli_eventlog_GetNumRecords_done(struct tevent_req
*subreq
);
580 struct tevent_req
*rpccli_eventlog_GetNumRecords_send(TALLOC_CTX
*mem_ctx
,
581 struct tevent_context
*ev
,
582 struct rpc_pipe_client
*cli
,
583 struct policy_handle
*_handle
/* [in] [ref] */,
584 uint32_t *_number
/* [out] [ref] */)
586 struct tevent_req
*req
;
587 struct rpccli_eventlog_GetNumRecords_state
*state
;
588 struct tevent_req
*subreq
;
590 req
= tevent_req_create(mem_ctx
, &state
,
591 struct rpccli_eventlog_GetNumRecords_state
);
595 state
->out_mem_ctx
= NULL
;
596 state
->dispatch_recv
= cli
->dispatch_recv
;
599 state
->orig
.in
.handle
= _handle
;
602 state
->orig
.out
.number
= _number
;
605 ZERO_STRUCT(state
->orig
.out
.result
);
607 state
->out_mem_ctx
= talloc_named_const(state
, 0,
608 "rpccli_eventlog_GetNumRecords_out_memory");
609 if (tevent_req_nomem(state
->out_mem_ctx
, req
)) {
610 return tevent_req_post(req
, ev
);
613 /* make a temporary copy, that we pass to the dispatch function */
614 state
->tmp
= state
->orig
;
616 subreq
= cli
->dispatch_send(state
, ev
, cli
,
617 NDR_EVENTLOG_UUID
, NDR_EVENTLOG_VERSION
,
618 NDR_EVENTLOG_GETNUMRECORDS
,
620 if (tevent_req_nomem(subreq
, req
)) {
621 return tevent_req_post(req
, ev
);
623 tevent_req_set_callback(subreq
, rpccli_eventlog_GetNumRecords_done
, req
);
627 static void rpccli_eventlog_GetNumRecords_done(struct tevent_req
*subreq
)
629 struct tevent_req
*req
= tevent_req_callback_data(
630 subreq
, struct tevent_req
);
631 struct rpccli_eventlog_GetNumRecords_state
*state
= tevent_req_data(
632 req
, struct rpccli_eventlog_GetNumRecords_state
);
636 if (state
->out_mem_ctx
) {
637 mem_ctx
= state
->out_mem_ctx
;
642 status
= state
->dispatch_recv(subreq
, mem_ctx
);
644 if (!NT_STATUS_IS_OK(status
)) {
645 tevent_req_nterror(req
, status
);
649 /* Copy out parameters */
650 *state
->orig
.out
.number
= *state
->tmp
.out
.number
;
653 state
->orig
.out
.result
= state
->tmp
.out
.result
;
655 /* Reset temporary structure */
656 ZERO_STRUCT(state
->tmp
);
658 tevent_req_done(req
);
661 NTSTATUS
rpccli_eventlog_GetNumRecords_recv(struct tevent_req
*req
,
665 struct rpccli_eventlog_GetNumRecords_state
*state
= tevent_req_data(
666 req
, struct rpccli_eventlog_GetNumRecords_state
);
669 if (tevent_req_is_nterror(req
, &status
)) {
670 tevent_req_received(req
);
674 /* Steal possbile out parameters to the callers context */
675 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
678 *result
= state
->orig
.out
.result
;
680 tevent_req_received(req
);
684 NTSTATUS
rpccli_eventlog_GetNumRecords(struct rpc_pipe_client
*cli
,
686 struct policy_handle
*handle
/* [in] [ref] */,
687 uint32_t *number
/* [out] [ref] */)
689 struct eventlog_GetNumRecords r
;
693 r
.in
.handle
= handle
;
695 status
= cli
->dispatch(cli
,
697 NDR_EVENTLOG_UUID
, NDR_EVENTLOG_VERSION
,
698 NDR_EVENTLOG_GETNUMRECORDS
,
701 if (!NT_STATUS_IS_OK(status
)) {
705 if (NT_STATUS_IS_ERR(status
)) {
709 /* Return variables */
710 *number
= *r
.out
.number
;
716 struct rpccli_eventlog_GetOldestRecord_state
{
717 struct eventlog_GetOldestRecord orig
;
718 struct eventlog_GetOldestRecord tmp
;
719 TALLOC_CTX
*out_mem_ctx
;
720 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
723 static void rpccli_eventlog_GetOldestRecord_done(struct tevent_req
*subreq
);
725 struct tevent_req
*rpccli_eventlog_GetOldestRecord_send(TALLOC_CTX
*mem_ctx
,
726 struct tevent_context
*ev
,
727 struct rpc_pipe_client
*cli
,
728 struct policy_handle
*_handle
/* [in] [ref] */,
729 uint32_t *_oldest_entry
/* [out] [ref] */)
731 struct tevent_req
*req
;
732 struct rpccli_eventlog_GetOldestRecord_state
*state
;
733 struct tevent_req
*subreq
;
735 req
= tevent_req_create(mem_ctx
, &state
,
736 struct rpccli_eventlog_GetOldestRecord_state
);
740 state
->out_mem_ctx
= NULL
;
741 state
->dispatch_recv
= cli
->dispatch_recv
;
744 state
->orig
.in
.handle
= _handle
;
747 state
->orig
.out
.oldest_entry
= _oldest_entry
;
750 ZERO_STRUCT(state
->orig
.out
.result
);
752 state
->out_mem_ctx
= talloc_named_const(state
, 0,
753 "rpccli_eventlog_GetOldestRecord_out_memory");
754 if (tevent_req_nomem(state
->out_mem_ctx
, req
)) {
755 return tevent_req_post(req
, ev
);
758 /* make a temporary copy, that we pass to the dispatch function */
759 state
->tmp
= state
->orig
;
761 subreq
= cli
->dispatch_send(state
, ev
, cli
,
762 NDR_EVENTLOG_UUID
, NDR_EVENTLOG_VERSION
,
763 NDR_EVENTLOG_GETOLDESTRECORD
,
765 if (tevent_req_nomem(subreq
, req
)) {
766 return tevent_req_post(req
, ev
);
768 tevent_req_set_callback(subreq
, rpccli_eventlog_GetOldestRecord_done
, req
);
772 static void rpccli_eventlog_GetOldestRecord_done(struct tevent_req
*subreq
)
774 struct tevent_req
*req
= tevent_req_callback_data(
775 subreq
, struct tevent_req
);
776 struct rpccli_eventlog_GetOldestRecord_state
*state
= tevent_req_data(
777 req
, struct rpccli_eventlog_GetOldestRecord_state
);
781 if (state
->out_mem_ctx
) {
782 mem_ctx
= state
->out_mem_ctx
;
787 status
= state
->dispatch_recv(subreq
, mem_ctx
);
789 if (!NT_STATUS_IS_OK(status
)) {
790 tevent_req_nterror(req
, status
);
794 /* Copy out parameters */
795 *state
->orig
.out
.oldest_entry
= *state
->tmp
.out
.oldest_entry
;
798 state
->orig
.out
.result
= state
->tmp
.out
.result
;
800 /* Reset temporary structure */
801 ZERO_STRUCT(state
->tmp
);
803 tevent_req_done(req
);
806 NTSTATUS
rpccli_eventlog_GetOldestRecord_recv(struct tevent_req
*req
,
810 struct rpccli_eventlog_GetOldestRecord_state
*state
= tevent_req_data(
811 req
, struct rpccli_eventlog_GetOldestRecord_state
);
814 if (tevent_req_is_nterror(req
, &status
)) {
815 tevent_req_received(req
);
819 /* Steal possbile out parameters to the callers context */
820 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
823 *result
= state
->orig
.out
.result
;
825 tevent_req_received(req
);
829 NTSTATUS
rpccli_eventlog_GetOldestRecord(struct rpc_pipe_client
*cli
,
831 struct policy_handle
*handle
/* [in] [ref] */,
832 uint32_t *oldest_entry
/* [out] [ref] */)
834 struct eventlog_GetOldestRecord r
;
838 r
.in
.handle
= handle
;
840 status
= cli
->dispatch(cli
,
842 NDR_EVENTLOG_UUID
, NDR_EVENTLOG_VERSION
,
843 NDR_EVENTLOG_GETOLDESTRECORD
,
846 if (!NT_STATUS_IS_OK(status
)) {
850 if (NT_STATUS_IS_ERR(status
)) {
854 /* Return variables */
855 *oldest_entry
= *r
.out
.oldest_entry
;
861 struct rpccli_eventlog_ChangeNotify_state
{
862 struct eventlog_ChangeNotify orig
;
863 struct eventlog_ChangeNotify tmp
;
864 TALLOC_CTX
*out_mem_ctx
;
865 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
868 static void rpccli_eventlog_ChangeNotify_done(struct tevent_req
*subreq
);
870 struct tevent_req
*rpccli_eventlog_ChangeNotify_send(TALLOC_CTX
*mem_ctx
,
871 struct tevent_context
*ev
,
872 struct rpc_pipe_client
*cli
)
874 struct tevent_req
*req
;
875 struct rpccli_eventlog_ChangeNotify_state
*state
;
876 struct tevent_req
*subreq
;
878 req
= tevent_req_create(mem_ctx
, &state
,
879 struct rpccli_eventlog_ChangeNotify_state
);
883 state
->out_mem_ctx
= NULL
;
884 state
->dispatch_recv
= cli
->dispatch_recv
;
891 ZERO_STRUCT(state
->orig
.out
.result
);
893 /* make a temporary copy, that we pass to the dispatch function */
894 state
->tmp
= state
->orig
;
896 subreq
= cli
->dispatch_send(state
, ev
, cli
,
897 NDR_EVENTLOG_UUID
, NDR_EVENTLOG_VERSION
,
898 NDR_EVENTLOG_CHANGENOTIFY
,
900 if (tevent_req_nomem(subreq
, req
)) {
901 return tevent_req_post(req
, ev
);
903 tevent_req_set_callback(subreq
, rpccli_eventlog_ChangeNotify_done
, req
);
907 static void rpccli_eventlog_ChangeNotify_done(struct tevent_req
*subreq
)
909 struct tevent_req
*req
= tevent_req_callback_data(
910 subreq
, struct tevent_req
);
911 struct rpccli_eventlog_ChangeNotify_state
*state
= tevent_req_data(
912 req
, struct rpccli_eventlog_ChangeNotify_state
);
916 if (state
->out_mem_ctx
) {
917 mem_ctx
= state
->out_mem_ctx
;
922 status
= state
->dispatch_recv(subreq
, mem_ctx
);
924 if (!NT_STATUS_IS_OK(status
)) {
925 tevent_req_nterror(req
, status
);
929 /* Copy out parameters */
932 state
->orig
.out
.result
= state
->tmp
.out
.result
;
934 /* Reset temporary structure */
935 ZERO_STRUCT(state
->tmp
);
937 tevent_req_done(req
);
940 NTSTATUS
rpccli_eventlog_ChangeNotify_recv(struct tevent_req
*req
,
944 struct rpccli_eventlog_ChangeNotify_state
*state
= tevent_req_data(
945 req
, struct rpccli_eventlog_ChangeNotify_state
);
948 if (tevent_req_is_nterror(req
, &status
)) {
949 tevent_req_received(req
);
953 /* Steal possbile out parameters to the callers context */
954 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
957 *result
= state
->orig
.out
.result
;
959 tevent_req_received(req
);
963 NTSTATUS
rpccli_eventlog_ChangeNotify(struct rpc_pipe_client
*cli
,
966 struct eventlog_ChangeNotify r
;
971 status
= cli
->dispatch(cli
,
973 NDR_EVENTLOG_UUID
, NDR_EVENTLOG_VERSION
,
974 NDR_EVENTLOG_CHANGENOTIFY
,
977 if (!NT_STATUS_IS_OK(status
)) {
981 if (NT_STATUS_IS_ERR(status
)) {
985 /* Return variables */
991 struct rpccli_eventlog_OpenEventLogW_state
{
992 struct eventlog_OpenEventLogW orig
;
993 struct eventlog_OpenEventLogW tmp
;
994 TALLOC_CTX
*out_mem_ctx
;
995 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
998 static void rpccli_eventlog_OpenEventLogW_done(struct tevent_req
*subreq
);
1000 struct tevent_req
*rpccli_eventlog_OpenEventLogW_send(TALLOC_CTX
*mem_ctx
,
1001 struct tevent_context
*ev
,
1002 struct rpc_pipe_client
*cli
,
1003 struct eventlog_OpenUnknown0
*_unknown0
/* [in] [unique] */,
1004 struct lsa_String
*_logname
/* [in] [ref] */,
1005 struct lsa_String
*_servername
/* [in] [ref] */,
1006 uint32_t _major_version
/* [in] */,
1007 uint32_t _minor_version
/* [in] */,
1008 struct policy_handle
*_handle
/* [out] [ref] */)
1010 struct tevent_req
*req
;
1011 struct rpccli_eventlog_OpenEventLogW_state
*state
;
1012 struct tevent_req
*subreq
;
1014 req
= tevent_req_create(mem_ctx
, &state
,
1015 struct rpccli_eventlog_OpenEventLogW_state
);
1019 state
->out_mem_ctx
= NULL
;
1020 state
->dispatch_recv
= cli
->dispatch_recv
;
1023 state
->orig
.in
.unknown0
= _unknown0
;
1024 state
->orig
.in
.logname
= _logname
;
1025 state
->orig
.in
.servername
= _servername
;
1026 state
->orig
.in
.major_version
= _major_version
;
1027 state
->orig
.in
.minor_version
= _minor_version
;
1029 /* Out parameters */
1030 state
->orig
.out
.handle
= _handle
;
1033 ZERO_STRUCT(state
->orig
.out
.result
);
1035 state
->out_mem_ctx
= talloc_named_const(state
, 0,
1036 "rpccli_eventlog_OpenEventLogW_out_memory");
1037 if (tevent_req_nomem(state
->out_mem_ctx
, req
)) {
1038 return tevent_req_post(req
, ev
);
1041 /* make a temporary copy, that we pass to the dispatch function */
1042 state
->tmp
= state
->orig
;
1044 subreq
= cli
->dispatch_send(state
, ev
, cli
,
1045 NDR_EVENTLOG_UUID
, NDR_EVENTLOG_VERSION
,
1046 NDR_EVENTLOG_OPENEVENTLOGW
,
1048 if (tevent_req_nomem(subreq
, req
)) {
1049 return tevent_req_post(req
, ev
);
1051 tevent_req_set_callback(subreq
, rpccli_eventlog_OpenEventLogW_done
, req
);
1055 static void rpccli_eventlog_OpenEventLogW_done(struct tevent_req
*subreq
)
1057 struct tevent_req
*req
= tevent_req_callback_data(
1058 subreq
, struct tevent_req
);
1059 struct rpccli_eventlog_OpenEventLogW_state
*state
= tevent_req_data(
1060 req
, struct rpccli_eventlog_OpenEventLogW_state
);
1062 TALLOC_CTX
*mem_ctx
;
1064 if (state
->out_mem_ctx
) {
1065 mem_ctx
= state
->out_mem_ctx
;
1070 status
= state
->dispatch_recv(subreq
, mem_ctx
);
1071 TALLOC_FREE(subreq
);
1072 if (!NT_STATUS_IS_OK(status
)) {
1073 tevent_req_nterror(req
, status
);
1077 /* Copy out parameters */
1078 *state
->orig
.out
.handle
= *state
->tmp
.out
.handle
;
1081 state
->orig
.out
.result
= state
->tmp
.out
.result
;
1083 /* Reset temporary structure */
1084 ZERO_STRUCT(state
->tmp
);
1086 tevent_req_done(req
);
1089 NTSTATUS
rpccli_eventlog_OpenEventLogW_recv(struct tevent_req
*req
,
1090 TALLOC_CTX
*mem_ctx
,
1093 struct rpccli_eventlog_OpenEventLogW_state
*state
= tevent_req_data(
1094 req
, struct rpccli_eventlog_OpenEventLogW_state
);
1097 if (tevent_req_is_nterror(req
, &status
)) {
1098 tevent_req_received(req
);
1102 /* Steal possbile out parameters to the callers context */
1103 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
1106 *result
= state
->orig
.out
.result
;
1108 tevent_req_received(req
);
1109 return NT_STATUS_OK
;
1112 NTSTATUS
rpccli_eventlog_OpenEventLogW(struct rpc_pipe_client
*cli
,
1113 TALLOC_CTX
*mem_ctx
,
1114 struct eventlog_OpenUnknown0
*unknown0
/* [in] [unique] */,
1115 struct lsa_String
*logname
/* [in] [ref] */,
1116 struct lsa_String
*servername
/* [in] [ref] */,
1117 uint32_t major_version
/* [in] */,
1118 uint32_t minor_version
/* [in] */,
1119 struct policy_handle
*handle
/* [out] [ref] */)
1121 struct eventlog_OpenEventLogW r
;
1125 r
.in
.unknown0
= unknown0
;
1126 r
.in
.logname
= logname
;
1127 r
.in
.servername
= servername
;
1128 r
.in
.major_version
= major_version
;
1129 r
.in
.minor_version
= minor_version
;
1131 status
= cli
->dispatch(cli
,
1133 NDR_EVENTLOG_UUID
, NDR_EVENTLOG_VERSION
,
1134 NDR_EVENTLOG_OPENEVENTLOGW
,
1137 if (!NT_STATUS_IS_OK(status
)) {
1141 if (NT_STATUS_IS_ERR(status
)) {
1145 /* Return variables */
1146 *handle
= *r
.out
.handle
;
1149 return r
.out
.result
;
1152 struct rpccli_eventlog_RegisterEventSourceW_state
{
1153 struct eventlog_RegisterEventSourceW orig
;
1154 struct eventlog_RegisterEventSourceW tmp
;
1155 TALLOC_CTX
*out_mem_ctx
;
1156 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
1159 static void rpccli_eventlog_RegisterEventSourceW_done(struct tevent_req
*subreq
);
1161 struct tevent_req
*rpccli_eventlog_RegisterEventSourceW_send(TALLOC_CTX
*mem_ctx
,
1162 struct tevent_context
*ev
,
1163 struct rpc_pipe_client
*cli
,
1164 struct eventlog_OpenUnknown0
*_unknown0
/* [in] [unique] */,
1165 struct lsa_String
*_module_name
/* [in] [ref] */,
1166 struct lsa_String
*_reg_module_name
/* [in] [ref] */,
1167 uint32_t _major_version
/* [in] */,
1168 uint32_t _minor_version
/* [in] */,
1169 struct policy_handle
*_log_handle
/* [out] [ref] */)
1171 struct tevent_req
*req
;
1172 struct rpccli_eventlog_RegisterEventSourceW_state
*state
;
1173 struct tevent_req
*subreq
;
1175 req
= tevent_req_create(mem_ctx
, &state
,
1176 struct rpccli_eventlog_RegisterEventSourceW_state
);
1180 state
->out_mem_ctx
= NULL
;
1181 state
->dispatch_recv
= cli
->dispatch_recv
;
1184 state
->orig
.in
.unknown0
= _unknown0
;
1185 state
->orig
.in
.module_name
= _module_name
;
1186 state
->orig
.in
.reg_module_name
= _reg_module_name
;
1187 state
->orig
.in
.major_version
= _major_version
;
1188 state
->orig
.in
.minor_version
= _minor_version
;
1190 /* Out parameters */
1191 state
->orig
.out
.log_handle
= _log_handle
;
1194 ZERO_STRUCT(state
->orig
.out
.result
);
1196 state
->out_mem_ctx
= talloc_named_const(state
, 0,
1197 "rpccli_eventlog_RegisterEventSourceW_out_memory");
1198 if (tevent_req_nomem(state
->out_mem_ctx
, req
)) {
1199 return tevent_req_post(req
, ev
);
1202 /* make a temporary copy, that we pass to the dispatch function */
1203 state
->tmp
= state
->orig
;
1205 subreq
= cli
->dispatch_send(state
, ev
, cli
,
1206 NDR_EVENTLOG_UUID
, NDR_EVENTLOG_VERSION
,
1207 NDR_EVENTLOG_REGISTEREVENTSOURCEW
,
1209 if (tevent_req_nomem(subreq
, req
)) {
1210 return tevent_req_post(req
, ev
);
1212 tevent_req_set_callback(subreq
, rpccli_eventlog_RegisterEventSourceW_done
, req
);
1216 static void rpccli_eventlog_RegisterEventSourceW_done(struct tevent_req
*subreq
)
1218 struct tevent_req
*req
= tevent_req_callback_data(
1219 subreq
, struct tevent_req
);
1220 struct rpccli_eventlog_RegisterEventSourceW_state
*state
= tevent_req_data(
1221 req
, struct rpccli_eventlog_RegisterEventSourceW_state
);
1223 TALLOC_CTX
*mem_ctx
;
1225 if (state
->out_mem_ctx
) {
1226 mem_ctx
= state
->out_mem_ctx
;
1231 status
= state
->dispatch_recv(subreq
, mem_ctx
);
1232 TALLOC_FREE(subreq
);
1233 if (!NT_STATUS_IS_OK(status
)) {
1234 tevent_req_nterror(req
, status
);
1238 /* Copy out parameters */
1239 *state
->orig
.out
.log_handle
= *state
->tmp
.out
.log_handle
;
1242 state
->orig
.out
.result
= state
->tmp
.out
.result
;
1244 /* Reset temporary structure */
1245 ZERO_STRUCT(state
->tmp
);
1247 tevent_req_done(req
);
1250 NTSTATUS
rpccli_eventlog_RegisterEventSourceW_recv(struct tevent_req
*req
,
1251 TALLOC_CTX
*mem_ctx
,
1254 struct rpccli_eventlog_RegisterEventSourceW_state
*state
= tevent_req_data(
1255 req
, struct rpccli_eventlog_RegisterEventSourceW_state
);
1258 if (tevent_req_is_nterror(req
, &status
)) {
1259 tevent_req_received(req
);
1263 /* Steal possbile out parameters to the callers context */
1264 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
1267 *result
= state
->orig
.out
.result
;
1269 tevent_req_received(req
);
1270 return NT_STATUS_OK
;
1273 NTSTATUS
rpccli_eventlog_RegisterEventSourceW(struct rpc_pipe_client
*cli
,
1274 TALLOC_CTX
*mem_ctx
,
1275 struct eventlog_OpenUnknown0
*unknown0
/* [in] [unique] */,
1276 struct lsa_String
*module_name
/* [in] [ref] */,
1277 struct lsa_String
*reg_module_name
/* [in] [ref] */,
1278 uint32_t major_version
/* [in] */,
1279 uint32_t minor_version
/* [in] */,
1280 struct policy_handle
*log_handle
/* [out] [ref] */)
1282 struct eventlog_RegisterEventSourceW r
;
1286 r
.in
.unknown0
= unknown0
;
1287 r
.in
.module_name
= module_name
;
1288 r
.in
.reg_module_name
= reg_module_name
;
1289 r
.in
.major_version
= major_version
;
1290 r
.in
.minor_version
= minor_version
;
1292 status
= cli
->dispatch(cli
,
1294 NDR_EVENTLOG_UUID
, NDR_EVENTLOG_VERSION
,
1295 NDR_EVENTLOG_REGISTEREVENTSOURCEW
,
1298 if (!NT_STATUS_IS_OK(status
)) {
1302 if (NT_STATUS_IS_ERR(status
)) {
1306 /* Return variables */
1307 *log_handle
= *r
.out
.log_handle
;
1310 return r
.out
.result
;
1313 struct rpccli_eventlog_OpenBackupEventLogW_state
{
1314 struct eventlog_OpenBackupEventLogW orig
;
1315 struct eventlog_OpenBackupEventLogW tmp
;
1316 TALLOC_CTX
*out_mem_ctx
;
1317 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
1320 static void rpccli_eventlog_OpenBackupEventLogW_done(struct tevent_req
*subreq
);
1322 struct tevent_req
*rpccli_eventlog_OpenBackupEventLogW_send(TALLOC_CTX
*mem_ctx
,
1323 struct tevent_context
*ev
,
1324 struct rpc_pipe_client
*cli
,
1325 struct eventlog_OpenUnknown0
*_unknown0
/* [in] [unique] */,
1326 struct lsa_String
*_backup_logname
/* [in] [ref] */,
1327 uint32_t _major_version
/* [in] */,
1328 uint32_t _minor_version
/* [in] */,
1329 struct policy_handle
*_handle
/* [out] [ref] */)
1331 struct tevent_req
*req
;
1332 struct rpccli_eventlog_OpenBackupEventLogW_state
*state
;
1333 struct tevent_req
*subreq
;
1335 req
= tevent_req_create(mem_ctx
, &state
,
1336 struct rpccli_eventlog_OpenBackupEventLogW_state
);
1340 state
->out_mem_ctx
= NULL
;
1341 state
->dispatch_recv
= cli
->dispatch_recv
;
1344 state
->orig
.in
.unknown0
= _unknown0
;
1345 state
->orig
.in
.backup_logname
= _backup_logname
;
1346 state
->orig
.in
.major_version
= _major_version
;
1347 state
->orig
.in
.minor_version
= _minor_version
;
1349 /* Out parameters */
1350 state
->orig
.out
.handle
= _handle
;
1353 ZERO_STRUCT(state
->orig
.out
.result
);
1355 state
->out_mem_ctx
= talloc_named_const(state
, 0,
1356 "rpccli_eventlog_OpenBackupEventLogW_out_memory");
1357 if (tevent_req_nomem(state
->out_mem_ctx
, req
)) {
1358 return tevent_req_post(req
, ev
);
1361 /* make a temporary copy, that we pass to the dispatch function */
1362 state
->tmp
= state
->orig
;
1364 subreq
= cli
->dispatch_send(state
, ev
, cli
,
1365 NDR_EVENTLOG_UUID
, NDR_EVENTLOG_VERSION
,
1366 NDR_EVENTLOG_OPENBACKUPEVENTLOGW
,
1368 if (tevent_req_nomem(subreq
, req
)) {
1369 return tevent_req_post(req
, ev
);
1371 tevent_req_set_callback(subreq
, rpccli_eventlog_OpenBackupEventLogW_done
, req
);
1375 static void rpccli_eventlog_OpenBackupEventLogW_done(struct tevent_req
*subreq
)
1377 struct tevent_req
*req
= tevent_req_callback_data(
1378 subreq
, struct tevent_req
);
1379 struct rpccli_eventlog_OpenBackupEventLogW_state
*state
= tevent_req_data(
1380 req
, struct rpccli_eventlog_OpenBackupEventLogW_state
);
1382 TALLOC_CTX
*mem_ctx
;
1384 if (state
->out_mem_ctx
) {
1385 mem_ctx
= state
->out_mem_ctx
;
1390 status
= state
->dispatch_recv(subreq
, mem_ctx
);
1391 TALLOC_FREE(subreq
);
1392 if (!NT_STATUS_IS_OK(status
)) {
1393 tevent_req_nterror(req
, status
);
1397 /* Copy out parameters */
1398 *state
->orig
.out
.handle
= *state
->tmp
.out
.handle
;
1401 state
->orig
.out
.result
= state
->tmp
.out
.result
;
1403 /* Reset temporary structure */
1404 ZERO_STRUCT(state
->tmp
);
1406 tevent_req_done(req
);
1409 NTSTATUS
rpccli_eventlog_OpenBackupEventLogW_recv(struct tevent_req
*req
,
1410 TALLOC_CTX
*mem_ctx
,
1413 struct rpccli_eventlog_OpenBackupEventLogW_state
*state
= tevent_req_data(
1414 req
, struct rpccli_eventlog_OpenBackupEventLogW_state
);
1417 if (tevent_req_is_nterror(req
, &status
)) {
1418 tevent_req_received(req
);
1422 /* Steal possbile out parameters to the callers context */
1423 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
1426 *result
= state
->orig
.out
.result
;
1428 tevent_req_received(req
);
1429 return NT_STATUS_OK
;
1432 NTSTATUS
rpccli_eventlog_OpenBackupEventLogW(struct rpc_pipe_client
*cli
,
1433 TALLOC_CTX
*mem_ctx
,
1434 struct eventlog_OpenUnknown0
*unknown0
/* [in] [unique] */,
1435 struct lsa_String
*backup_logname
/* [in] [ref] */,
1436 uint32_t major_version
/* [in] */,
1437 uint32_t minor_version
/* [in] */,
1438 struct policy_handle
*handle
/* [out] [ref] */)
1440 struct eventlog_OpenBackupEventLogW r
;
1444 r
.in
.unknown0
= unknown0
;
1445 r
.in
.backup_logname
= backup_logname
;
1446 r
.in
.major_version
= major_version
;
1447 r
.in
.minor_version
= minor_version
;
1449 status
= cli
->dispatch(cli
,
1451 NDR_EVENTLOG_UUID
, NDR_EVENTLOG_VERSION
,
1452 NDR_EVENTLOG_OPENBACKUPEVENTLOGW
,
1455 if (!NT_STATUS_IS_OK(status
)) {
1459 if (NT_STATUS_IS_ERR(status
)) {
1463 /* Return variables */
1464 *handle
= *r
.out
.handle
;
1467 return r
.out
.result
;
1470 struct rpccli_eventlog_ReadEventLogW_state
{
1471 struct eventlog_ReadEventLogW orig
;
1472 struct eventlog_ReadEventLogW tmp
;
1473 TALLOC_CTX
*out_mem_ctx
;
1474 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
1477 static void rpccli_eventlog_ReadEventLogW_done(struct tevent_req
*subreq
);
1479 struct tevent_req
*rpccli_eventlog_ReadEventLogW_send(TALLOC_CTX
*mem_ctx
,
1480 struct tevent_context
*ev
,
1481 struct rpc_pipe_client
*cli
,
1482 struct policy_handle
*_handle
/* [in] [ref] */,
1483 uint32_t _flags
/* [in] */,
1484 uint32_t _offset
/* [in] */,
1485 uint32_t _number_of_bytes
/* [in] [range(0,0x7FFFF)] */,
1486 uint8_t *_data
/* [out] [ref,size_is(number_of_bytes)] */,
1487 uint32_t *_sent_size
/* [out] [ref] */,
1488 uint32_t *_real_size
/* [out] [ref] */)
1490 struct tevent_req
*req
;
1491 struct rpccli_eventlog_ReadEventLogW_state
*state
;
1492 struct tevent_req
*subreq
;
1494 req
= tevent_req_create(mem_ctx
, &state
,
1495 struct rpccli_eventlog_ReadEventLogW_state
);
1499 state
->out_mem_ctx
= NULL
;
1500 state
->dispatch_recv
= cli
->dispatch_recv
;
1503 state
->orig
.in
.handle
= _handle
;
1504 state
->orig
.in
.flags
= _flags
;
1505 state
->orig
.in
.offset
= _offset
;
1506 state
->orig
.in
.number_of_bytes
= _number_of_bytes
;
1508 /* Out parameters */
1509 state
->orig
.out
.data
= _data
;
1510 state
->orig
.out
.sent_size
= _sent_size
;
1511 state
->orig
.out
.real_size
= _real_size
;
1514 ZERO_STRUCT(state
->orig
.out
.result
);
1516 state
->out_mem_ctx
= talloc_named_const(state
, 0,
1517 "rpccli_eventlog_ReadEventLogW_out_memory");
1518 if (tevent_req_nomem(state
->out_mem_ctx
, req
)) {
1519 return tevent_req_post(req
, ev
);
1522 /* make a temporary copy, that we pass to the dispatch function */
1523 state
->tmp
= state
->orig
;
1525 subreq
= cli
->dispatch_send(state
, ev
, cli
,
1526 NDR_EVENTLOG_UUID
, NDR_EVENTLOG_VERSION
,
1527 NDR_EVENTLOG_READEVENTLOGW
,
1529 if (tevent_req_nomem(subreq
, req
)) {
1530 return tevent_req_post(req
, ev
);
1532 tevent_req_set_callback(subreq
, rpccli_eventlog_ReadEventLogW_done
, req
);
1536 static void rpccli_eventlog_ReadEventLogW_done(struct tevent_req
*subreq
)
1538 struct tevent_req
*req
= tevent_req_callback_data(
1539 subreq
, struct tevent_req
);
1540 struct rpccli_eventlog_ReadEventLogW_state
*state
= tevent_req_data(
1541 req
, struct rpccli_eventlog_ReadEventLogW_state
);
1543 TALLOC_CTX
*mem_ctx
;
1545 if (state
->out_mem_ctx
) {
1546 mem_ctx
= state
->out_mem_ctx
;
1551 status
= state
->dispatch_recv(subreq
, mem_ctx
);
1552 TALLOC_FREE(subreq
);
1553 if (!NT_STATUS_IS_OK(status
)) {
1554 tevent_req_nterror(req
, status
);
1558 /* Copy out parameters */
1559 memcpy(state
->orig
.out
.data
, state
->tmp
.out
.data
, state
->tmp
.in
.number_of_bytes
* sizeof(*state
->orig
.out
.data
));
1560 *state
->orig
.out
.sent_size
= *state
->tmp
.out
.sent_size
;
1561 *state
->orig
.out
.real_size
= *state
->tmp
.out
.real_size
;
1564 state
->orig
.out
.result
= state
->tmp
.out
.result
;
1566 /* Reset temporary structure */
1567 ZERO_STRUCT(state
->tmp
);
1569 tevent_req_done(req
);
1572 NTSTATUS
rpccli_eventlog_ReadEventLogW_recv(struct tevent_req
*req
,
1573 TALLOC_CTX
*mem_ctx
,
1576 struct rpccli_eventlog_ReadEventLogW_state
*state
= tevent_req_data(
1577 req
, struct rpccli_eventlog_ReadEventLogW_state
);
1580 if (tevent_req_is_nterror(req
, &status
)) {
1581 tevent_req_received(req
);
1585 /* Steal possbile out parameters to the callers context */
1586 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
1589 *result
= state
->orig
.out
.result
;
1591 tevent_req_received(req
);
1592 return NT_STATUS_OK
;
1595 NTSTATUS
rpccli_eventlog_ReadEventLogW(struct rpc_pipe_client
*cli
,
1596 TALLOC_CTX
*mem_ctx
,
1597 struct policy_handle
*handle
/* [in] [ref] */,
1598 uint32_t flags
/* [in] */,
1599 uint32_t offset
/* [in] */,
1600 uint32_t number_of_bytes
/* [in] [range(0,0x7FFFF)] */,
1601 uint8_t *data
/* [out] [ref,size_is(number_of_bytes)] */,
1602 uint32_t *sent_size
/* [out] [ref] */,
1603 uint32_t *real_size
/* [out] [ref] */)
1605 struct eventlog_ReadEventLogW r
;
1609 r
.in
.handle
= handle
;
1611 r
.in
.offset
= offset
;
1612 r
.in
.number_of_bytes
= number_of_bytes
;
1614 status
= cli
->dispatch(cli
,
1616 NDR_EVENTLOG_UUID
, NDR_EVENTLOG_VERSION
,
1617 NDR_EVENTLOG_READEVENTLOGW
,
1620 if (!NT_STATUS_IS_OK(status
)) {
1624 if (NT_STATUS_IS_ERR(status
)) {
1628 /* Return variables */
1629 memcpy(data
, r
.out
.data
, r
.in
.number_of_bytes
* sizeof(*data
));
1630 *sent_size
= *r
.out
.sent_size
;
1631 *real_size
= *r
.out
.real_size
;
1634 return r
.out
.result
;
1637 struct rpccli_eventlog_ReportEventW_state
{
1638 struct eventlog_ReportEventW orig
;
1639 struct eventlog_ReportEventW tmp
;
1640 TALLOC_CTX
*out_mem_ctx
;
1641 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
1644 static void rpccli_eventlog_ReportEventW_done(struct tevent_req
*subreq
);
1646 struct tevent_req
*rpccli_eventlog_ReportEventW_send(TALLOC_CTX
*mem_ctx
,
1647 struct tevent_context
*ev
,
1648 struct rpc_pipe_client
*cli
,
1649 struct policy_handle
*_handle
/* [in] [ref] */,
1650 time_t _timestamp
/* [in] */,
1651 enum eventlogEventTypes _event_type
/* [in] */,
1652 uint16_t _event_category
/* [in] */,
1653 uint32_t _event_id
/* [in] */,
1654 uint16_t _num_of_strings
/* [in] [range(0,256)] */,
1655 uint32_t _data_size
/* [in] [range(0,0x3FFFF)] */,
1656 struct lsa_String
*_servername
/* [in] [ref] */,
1657 struct dom_sid
*_user_sid
/* [in] [unique] */,
1658 struct lsa_String
**_strings
/* [in] [unique,size_is(num_of_strings)] */,
1659 uint8_t *_data
/* [in] [unique,size_is(data_size)] */,
1660 uint16_t _flags
/* [in] */,
1661 uint32_t *_record_number
/* [in,out] [unique] */,
1662 time_t *_time_written
/* [in,out] [unique] */)
1664 struct tevent_req
*req
;
1665 struct rpccli_eventlog_ReportEventW_state
*state
;
1666 struct tevent_req
*subreq
;
1668 req
= tevent_req_create(mem_ctx
, &state
,
1669 struct rpccli_eventlog_ReportEventW_state
);
1673 state
->out_mem_ctx
= NULL
;
1674 state
->dispatch_recv
= cli
->dispatch_recv
;
1677 state
->orig
.in
.handle
= _handle
;
1678 state
->orig
.in
.timestamp
= _timestamp
;
1679 state
->orig
.in
.event_type
= _event_type
;
1680 state
->orig
.in
.event_category
= _event_category
;
1681 state
->orig
.in
.event_id
= _event_id
;
1682 state
->orig
.in
.num_of_strings
= _num_of_strings
;
1683 state
->orig
.in
.data_size
= _data_size
;
1684 state
->orig
.in
.servername
= _servername
;
1685 state
->orig
.in
.user_sid
= _user_sid
;
1686 state
->orig
.in
.strings
= _strings
;
1687 state
->orig
.in
.data
= _data
;
1688 state
->orig
.in
.flags
= _flags
;
1689 state
->orig
.in
.record_number
= _record_number
;
1690 state
->orig
.in
.time_written
= _time_written
;
1692 /* Out parameters */
1693 state
->orig
.out
.record_number
= _record_number
;
1694 state
->orig
.out
.time_written
= _time_written
;
1697 ZERO_STRUCT(state
->orig
.out
.result
);
1699 state
->out_mem_ctx
= talloc_named_const(state
, 0,
1700 "rpccli_eventlog_ReportEventW_out_memory");
1701 if (tevent_req_nomem(state
->out_mem_ctx
, req
)) {
1702 return tevent_req_post(req
, ev
);
1705 /* make a temporary copy, that we pass to the dispatch function */
1706 state
->tmp
= state
->orig
;
1708 subreq
= cli
->dispatch_send(state
, ev
, cli
,
1709 NDR_EVENTLOG_UUID
, NDR_EVENTLOG_VERSION
,
1710 NDR_EVENTLOG_REPORTEVENTW
,
1712 if (tevent_req_nomem(subreq
, req
)) {
1713 return tevent_req_post(req
, ev
);
1715 tevent_req_set_callback(subreq
, rpccli_eventlog_ReportEventW_done
, req
);
1719 static void rpccli_eventlog_ReportEventW_done(struct tevent_req
*subreq
)
1721 struct tevent_req
*req
= tevent_req_callback_data(
1722 subreq
, struct tevent_req
);
1723 struct rpccli_eventlog_ReportEventW_state
*state
= tevent_req_data(
1724 req
, struct rpccli_eventlog_ReportEventW_state
);
1726 TALLOC_CTX
*mem_ctx
;
1728 if (state
->out_mem_ctx
) {
1729 mem_ctx
= state
->out_mem_ctx
;
1734 status
= state
->dispatch_recv(subreq
, mem_ctx
);
1735 TALLOC_FREE(subreq
);
1736 if (!NT_STATUS_IS_OK(status
)) {
1737 tevent_req_nterror(req
, status
);
1741 /* Copy out parameters */
1742 if (state
->orig
.out
.record_number
&& state
->tmp
.out
.record_number
) {
1743 *state
->orig
.out
.record_number
= *state
->tmp
.out
.record_number
;
1745 if (state
->orig
.out
.time_written
&& state
->tmp
.out
.time_written
) {
1746 *state
->orig
.out
.time_written
= *state
->tmp
.out
.time_written
;
1750 state
->orig
.out
.result
= state
->tmp
.out
.result
;
1752 /* Reset temporary structure */
1753 ZERO_STRUCT(state
->tmp
);
1755 tevent_req_done(req
);
1758 NTSTATUS
rpccli_eventlog_ReportEventW_recv(struct tevent_req
*req
,
1759 TALLOC_CTX
*mem_ctx
,
1762 struct rpccli_eventlog_ReportEventW_state
*state
= tevent_req_data(
1763 req
, struct rpccli_eventlog_ReportEventW_state
);
1766 if (tevent_req_is_nterror(req
, &status
)) {
1767 tevent_req_received(req
);
1771 /* Steal possbile out parameters to the callers context */
1772 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
1775 *result
= state
->orig
.out
.result
;
1777 tevent_req_received(req
);
1778 return NT_STATUS_OK
;
1781 NTSTATUS
rpccli_eventlog_ReportEventW(struct rpc_pipe_client
*cli
,
1782 TALLOC_CTX
*mem_ctx
,
1783 struct policy_handle
*handle
/* [in] [ref] */,
1784 time_t timestamp
/* [in] */,
1785 enum eventlogEventTypes event_type
/* [in] */,
1786 uint16_t event_category
/* [in] */,
1787 uint32_t event_id
/* [in] */,
1788 uint16_t num_of_strings
/* [in] [range(0,256)] */,
1789 uint32_t data_size
/* [in] [range(0,0x3FFFF)] */,
1790 struct lsa_String
*servername
/* [in] [ref] */,
1791 struct dom_sid
*user_sid
/* [in] [unique] */,
1792 struct lsa_String
**strings
/* [in] [unique,size_is(num_of_strings)] */,
1793 uint8_t *data
/* [in] [unique,size_is(data_size)] */,
1794 uint16_t flags
/* [in] */,
1795 uint32_t *record_number
/* [in,out] [unique] */,
1796 time_t *time_written
/* [in,out] [unique] */)
1798 struct eventlog_ReportEventW r
;
1802 r
.in
.handle
= handle
;
1803 r
.in
.timestamp
= timestamp
;
1804 r
.in
.event_type
= event_type
;
1805 r
.in
.event_category
= event_category
;
1806 r
.in
.event_id
= event_id
;
1807 r
.in
.num_of_strings
= num_of_strings
;
1808 r
.in
.data_size
= data_size
;
1809 r
.in
.servername
= servername
;
1810 r
.in
.user_sid
= user_sid
;
1811 r
.in
.strings
= strings
;
1814 r
.in
.record_number
= record_number
;
1815 r
.in
.time_written
= time_written
;
1817 status
= cli
->dispatch(cli
,
1819 NDR_EVENTLOG_UUID
, NDR_EVENTLOG_VERSION
,
1820 NDR_EVENTLOG_REPORTEVENTW
,
1823 if (!NT_STATUS_IS_OK(status
)) {
1827 if (NT_STATUS_IS_ERR(status
)) {
1831 /* Return variables */
1832 if (record_number
&& r
.out
.record_number
) {
1833 *record_number
= *r
.out
.record_number
;
1835 if (time_written
&& r
.out
.time_written
) {
1836 *time_written
= *r
.out
.time_written
;
1840 return r
.out
.result
;
1843 struct rpccli_eventlog_ClearEventLogA_state
{
1844 struct eventlog_ClearEventLogA orig
;
1845 struct eventlog_ClearEventLogA tmp
;
1846 TALLOC_CTX
*out_mem_ctx
;
1847 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
1850 static void rpccli_eventlog_ClearEventLogA_done(struct tevent_req
*subreq
);
1852 struct tevent_req
*rpccli_eventlog_ClearEventLogA_send(TALLOC_CTX
*mem_ctx
,
1853 struct tevent_context
*ev
,
1854 struct rpc_pipe_client
*cli
)
1856 struct tevent_req
*req
;
1857 struct rpccli_eventlog_ClearEventLogA_state
*state
;
1858 struct tevent_req
*subreq
;
1860 req
= tevent_req_create(mem_ctx
, &state
,
1861 struct rpccli_eventlog_ClearEventLogA_state
);
1865 state
->out_mem_ctx
= NULL
;
1866 state
->dispatch_recv
= cli
->dispatch_recv
;
1870 /* Out parameters */
1873 ZERO_STRUCT(state
->orig
.out
.result
);
1875 /* make a temporary copy, that we pass to the dispatch function */
1876 state
->tmp
= state
->orig
;
1878 subreq
= cli
->dispatch_send(state
, ev
, cli
,
1879 NDR_EVENTLOG_UUID
, NDR_EVENTLOG_VERSION
,
1880 NDR_EVENTLOG_CLEAREVENTLOGA
,
1882 if (tevent_req_nomem(subreq
, req
)) {
1883 return tevent_req_post(req
, ev
);
1885 tevent_req_set_callback(subreq
, rpccli_eventlog_ClearEventLogA_done
, req
);
1889 static void rpccli_eventlog_ClearEventLogA_done(struct tevent_req
*subreq
)
1891 struct tevent_req
*req
= tevent_req_callback_data(
1892 subreq
, struct tevent_req
);
1893 struct rpccli_eventlog_ClearEventLogA_state
*state
= tevent_req_data(
1894 req
, struct rpccli_eventlog_ClearEventLogA_state
);
1896 TALLOC_CTX
*mem_ctx
;
1898 if (state
->out_mem_ctx
) {
1899 mem_ctx
= state
->out_mem_ctx
;
1904 status
= state
->dispatch_recv(subreq
, mem_ctx
);
1905 TALLOC_FREE(subreq
);
1906 if (!NT_STATUS_IS_OK(status
)) {
1907 tevent_req_nterror(req
, status
);
1911 /* Copy out parameters */
1914 state
->orig
.out
.result
= state
->tmp
.out
.result
;
1916 /* Reset temporary structure */
1917 ZERO_STRUCT(state
->tmp
);
1919 tevent_req_done(req
);
1922 NTSTATUS
rpccli_eventlog_ClearEventLogA_recv(struct tevent_req
*req
,
1923 TALLOC_CTX
*mem_ctx
,
1926 struct rpccli_eventlog_ClearEventLogA_state
*state
= tevent_req_data(
1927 req
, struct rpccli_eventlog_ClearEventLogA_state
);
1930 if (tevent_req_is_nterror(req
, &status
)) {
1931 tevent_req_received(req
);
1935 /* Steal possbile out parameters to the callers context */
1936 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
1939 *result
= state
->orig
.out
.result
;
1941 tevent_req_received(req
);
1942 return NT_STATUS_OK
;
1945 NTSTATUS
rpccli_eventlog_ClearEventLogA(struct rpc_pipe_client
*cli
,
1946 TALLOC_CTX
*mem_ctx
)
1948 struct eventlog_ClearEventLogA r
;
1953 status
= cli
->dispatch(cli
,
1955 NDR_EVENTLOG_UUID
, NDR_EVENTLOG_VERSION
,
1956 NDR_EVENTLOG_CLEAREVENTLOGA
,
1959 if (!NT_STATUS_IS_OK(status
)) {
1963 if (NT_STATUS_IS_ERR(status
)) {
1967 /* Return variables */
1970 return r
.out
.result
;
1973 struct rpccli_eventlog_BackupEventLogA_state
{
1974 struct eventlog_BackupEventLogA orig
;
1975 struct eventlog_BackupEventLogA tmp
;
1976 TALLOC_CTX
*out_mem_ctx
;
1977 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
1980 static void rpccli_eventlog_BackupEventLogA_done(struct tevent_req
*subreq
);
1982 struct tevent_req
*rpccli_eventlog_BackupEventLogA_send(TALLOC_CTX
*mem_ctx
,
1983 struct tevent_context
*ev
,
1984 struct rpc_pipe_client
*cli
)
1986 struct tevent_req
*req
;
1987 struct rpccli_eventlog_BackupEventLogA_state
*state
;
1988 struct tevent_req
*subreq
;
1990 req
= tevent_req_create(mem_ctx
, &state
,
1991 struct rpccli_eventlog_BackupEventLogA_state
);
1995 state
->out_mem_ctx
= NULL
;
1996 state
->dispatch_recv
= cli
->dispatch_recv
;
2000 /* Out parameters */
2003 ZERO_STRUCT(state
->orig
.out
.result
);
2005 /* make a temporary copy, that we pass to the dispatch function */
2006 state
->tmp
= state
->orig
;
2008 subreq
= cli
->dispatch_send(state
, ev
, cli
,
2009 NDR_EVENTLOG_UUID
, NDR_EVENTLOG_VERSION
,
2010 NDR_EVENTLOG_BACKUPEVENTLOGA
,
2012 if (tevent_req_nomem(subreq
, req
)) {
2013 return tevent_req_post(req
, ev
);
2015 tevent_req_set_callback(subreq
, rpccli_eventlog_BackupEventLogA_done
, req
);
2019 static void rpccli_eventlog_BackupEventLogA_done(struct tevent_req
*subreq
)
2021 struct tevent_req
*req
= tevent_req_callback_data(
2022 subreq
, struct tevent_req
);
2023 struct rpccli_eventlog_BackupEventLogA_state
*state
= tevent_req_data(
2024 req
, struct rpccli_eventlog_BackupEventLogA_state
);
2026 TALLOC_CTX
*mem_ctx
;
2028 if (state
->out_mem_ctx
) {
2029 mem_ctx
= state
->out_mem_ctx
;
2034 status
= state
->dispatch_recv(subreq
, mem_ctx
);
2035 TALLOC_FREE(subreq
);
2036 if (!NT_STATUS_IS_OK(status
)) {
2037 tevent_req_nterror(req
, status
);
2041 /* Copy out parameters */
2044 state
->orig
.out
.result
= state
->tmp
.out
.result
;
2046 /* Reset temporary structure */
2047 ZERO_STRUCT(state
->tmp
);
2049 tevent_req_done(req
);
2052 NTSTATUS
rpccli_eventlog_BackupEventLogA_recv(struct tevent_req
*req
,
2053 TALLOC_CTX
*mem_ctx
,
2056 struct rpccli_eventlog_BackupEventLogA_state
*state
= tevent_req_data(
2057 req
, struct rpccli_eventlog_BackupEventLogA_state
);
2060 if (tevent_req_is_nterror(req
, &status
)) {
2061 tevent_req_received(req
);
2065 /* Steal possbile out parameters to the callers context */
2066 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
2069 *result
= state
->orig
.out
.result
;
2071 tevent_req_received(req
);
2072 return NT_STATUS_OK
;
2075 NTSTATUS
rpccli_eventlog_BackupEventLogA(struct rpc_pipe_client
*cli
,
2076 TALLOC_CTX
*mem_ctx
)
2078 struct eventlog_BackupEventLogA r
;
2083 status
= cli
->dispatch(cli
,
2085 NDR_EVENTLOG_UUID
, NDR_EVENTLOG_VERSION
,
2086 NDR_EVENTLOG_BACKUPEVENTLOGA
,
2089 if (!NT_STATUS_IS_OK(status
)) {
2093 if (NT_STATUS_IS_ERR(status
)) {
2097 /* Return variables */
2100 return r
.out
.result
;
2103 struct rpccli_eventlog_OpenEventLogA_state
{
2104 struct eventlog_OpenEventLogA orig
;
2105 struct eventlog_OpenEventLogA tmp
;
2106 TALLOC_CTX
*out_mem_ctx
;
2107 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
2110 static void rpccli_eventlog_OpenEventLogA_done(struct tevent_req
*subreq
);
2112 struct tevent_req
*rpccli_eventlog_OpenEventLogA_send(TALLOC_CTX
*mem_ctx
,
2113 struct tevent_context
*ev
,
2114 struct rpc_pipe_client
*cli
)
2116 struct tevent_req
*req
;
2117 struct rpccli_eventlog_OpenEventLogA_state
*state
;
2118 struct tevent_req
*subreq
;
2120 req
= tevent_req_create(mem_ctx
, &state
,
2121 struct rpccli_eventlog_OpenEventLogA_state
);
2125 state
->out_mem_ctx
= NULL
;
2126 state
->dispatch_recv
= cli
->dispatch_recv
;
2130 /* Out parameters */
2133 ZERO_STRUCT(state
->orig
.out
.result
);
2135 /* make a temporary copy, that we pass to the dispatch function */
2136 state
->tmp
= state
->orig
;
2138 subreq
= cli
->dispatch_send(state
, ev
, cli
,
2139 NDR_EVENTLOG_UUID
, NDR_EVENTLOG_VERSION
,
2140 NDR_EVENTLOG_OPENEVENTLOGA
,
2142 if (tevent_req_nomem(subreq
, req
)) {
2143 return tevent_req_post(req
, ev
);
2145 tevent_req_set_callback(subreq
, rpccli_eventlog_OpenEventLogA_done
, req
);
2149 static void rpccli_eventlog_OpenEventLogA_done(struct tevent_req
*subreq
)
2151 struct tevent_req
*req
= tevent_req_callback_data(
2152 subreq
, struct tevent_req
);
2153 struct rpccli_eventlog_OpenEventLogA_state
*state
= tevent_req_data(
2154 req
, struct rpccli_eventlog_OpenEventLogA_state
);
2156 TALLOC_CTX
*mem_ctx
;
2158 if (state
->out_mem_ctx
) {
2159 mem_ctx
= state
->out_mem_ctx
;
2164 status
= state
->dispatch_recv(subreq
, mem_ctx
);
2165 TALLOC_FREE(subreq
);
2166 if (!NT_STATUS_IS_OK(status
)) {
2167 tevent_req_nterror(req
, status
);
2171 /* Copy out parameters */
2174 state
->orig
.out
.result
= state
->tmp
.out
.result
;
2176 /* Reset temporary structure */
2177 ZERO_STRUCT(state
->tmp
);
2179 tevent_req_done(req
);
2182 NTSTATUS
rpccli_eventlog_OpenEventLogA_recv(struct tevent_req
*req
,
2183 TALLOC_CTX
*mem_ctx
,
2186 struct rpccli_eventlog_OpenEventLogA_state
*state
= tevent_req_data(
2187 req
, struct rpccli_eventlog_OpenEventLogA_state
);
2190 if (tevent_req_is_nterror(req
, &status
)) {
2191 tevent_req_received(req
);
2195 /* Steal possbile out parameters to the callers context */
2196 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
2199 *result
= state
->orig
.out
.result
;
2201 tevent_req_received(req
);
2202 return NT_STATUS_OK
;
2205 NTSTATUS
rpccli_eventlog_OpenEventLogA(struct rpc_pipe_client
*cli
,
2206 TALLOC_CTX
*mem_ctx
)
2208 struct eventlog_OpenEventLogA r
;
2213 status
= cli
->dispatch(cli
,
2215 NDR_EVENTLOG_UUID
, NDR_EVENTLOG_VERSION
,
2216 NDR_EVENTLOG_OPENEVENTLOGA
,
2219 if (!NT_STATUS_IS_OK(status
)) {
2223 if (NT_STATUS_IS_ERR(status
)) {
2227 /* Return variables */
2230 return r
.out
.result
;
2233 struct rpccli_eventlog_RegisterEventSourceA_state
{
2234 struct eventlog_RegisterEventSourceA orig
;
2235 struct eventlog_RegisterEventSourceA tmp
;
2236 TALLOC_CTX
*out_mem_ctx
;
2237 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
2240 static void rpccli_eventlog_RegisterEventSourceA_done(struct tevent_req
*subreq
);
2242 struct tevent_req
*rpccli_eventlog_RegisterEventSourceA_send(TALLOC_CTX
*mem_ctx
,
2243 struct tevent_context
*ev
,
2244 struct rpc_pipe_client
*cli
)
2246 struct tevent_req
*req
;
2247 struct rpccli_eventlog_RegisterEventSourceA_state
*state
;
2248 struct tevent_req
*subreq
;
2250 req
= tevent_req_create(mem_ctx
, &state
,
2251 struct rpccli_eventlog_RegisterEventSourceA_state
);
2255 state
->out_mem_ctx
= NULL
;
2256 state
->dispatch_recv
= cli
->dispatch_recv
;
2260 /* Out parameters */
2263 ZERO_STRUCT(state
->orig
.out
.result
);
2265 /* make a temporary copy, that we pass to the dispatch function */
2266 state
->tmp
= state
->orig
;
2268 subreq
= cli
->dispatch_send(state
, ev
, cli
,
2269 NDR_EVENTLOG_UUID
, NDR_EVENTLOG_VERSION
,
2270 NDR_EVENTLOG_REGISTEREVENTSOURCEA
,
2272 if (tevent_req_nomem(subreq
, req
)) {
2273 return tevent_req_post(req
, ev
);
2275 tevent_req_set_callback(subreq
, rpccli_eventlog_RegisterEventSourceA_done
, req
);
2279 static void rpccli_eventlog_RegisterEventSourceA_done(struct tevent_req
*subreq
)
2281 struct tevent_req
*req
= tevent_req_callback_data(
2282 subreq
, struct tevent_req
);
2283 struct rpccli_eventlog_RegisterEventSourceA_state
*state
= tevent_req_data(
2284 req
, struct rpccli_eventlog_RegisterEventSourceA_state
);
2286 TALLOC_CTX
*mem_ctx
;
2288 if (state
->out_mem_ctx
) {
2289 mem_ctx
= state
->out_mem_ctx
;
2294 status
= state
->dispatch_recv(subreq
, mem_ctx
);
2295 TALLOC_FREE(subreq
);
2296 if (!NT_STATUS_IS_OK(status
)) {
2297 tevent_req_nterror(req
, status
);
2301 /* Copy out parameters */
2304 state
->orig
.out
.result
= state
->tmp
.out
.result
;
2306 /* Reset temporary structure */
2307 ZERO_STRUCT(state
->tmp
);
2309 tevent_req_done(req
);
2312 NTSTATUS
rpccli_eventlog_RegisterEventSourceA_recv(struct tevent_req
*req
,
2313 TALLOC_CTX
*mem_ctx
,
2316 struct rpccli_eventlog_RegisterEventSourceA_state
*state
= tevent_req_data(
2317 req
, struct rpccli_eventlog_RegisterEventSourceA_state
);
2320 if (tevent_req_is_nterror(req
, &status
)) {
2321 tevent_req_received(req
);
2325 /* Steal possbile out parameters to the callers context */
2326 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
2329 *result
= state
->orig
.out
.result
;
2331 tevent_req_received(req
);
2332 return NT_STATUS_OK
;
2335 NTSTATUS
rpccli_eventlog_RegisterEventSourceA(struct rpc_pipe_client
*cli
,
2336 TALLOC_CTX
*mem_ctx
)
2338 struct eventlog_RegisterEventSourceA r
;
2343 status
= cli
->dispatch(cli
,
2345 NDR_EVENTLOG_UUID
, NDR_EVENTLOG_VERSION
,
2346 NDR_EVENTLOG_REGISTEREVENTSOURCEA
,
2349 if (!NT_STATUS_IS_OK(status
)) {
2353 if (NT_STATUS_IS_ERR(status
)) {
2357 /* Return variables */
2360 return r
.out
.result
;
2363 struct rpccli_eventlog_OpenBackupEventLogA_state
{
2364 struct eventlog_OpenBackupEventLogA orig
;
2365 struct eventlog_OpenBackupEventLogA tmp
;
2366 TALLOC_CTX
*out_mem_ctx
;
2367 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
2370 static void rpccli_eventlog_OpenBackupEventLogA_done(struct tevent_req
*subreq
);
2372 struct tevent_req
*rpccli_eventlog_OpenBackupEventLogA_send(TALLOC_CTX
*mem_ctx
,
2373 struct tevent_context
*ev
,
2374 struct rpc_pipe_client
*cli
)
2376 struct tevent_req
*req
;
2377 struct rpccli_eventlog_OpenBackupEventLogA_state
*state
;
2378 struct tevent_req
*subreq
;
2380 req
= tevent_req_create(mem_ctx
, &state
,
2381 struct rpccli_eventlog_OpenBackupEventLogA_state
);
2385 state
->out_mem_ctx
= NULL
;
2386 state
->dispatch_recv
= cli
->dispatch_recv
;
2390 /* Out parameters */
2393 ZERO_STRUCT(state
->orig
.out
.result
);
2395 /* make a temporary copy, that we pass to the dispatch function */
2396 state
->tmp
= state
->orig
;
2398 subreq
= cli
->dispatch_send(state
, ev
, cli
,
2399 NDR_EVENTLOG_UUID
, NDR_EVENTLOG_VERSION
,
2400 NDR_EVENTLOG_OPENBACKUPEVENTLOGA
,
2402 if (tevent_req_nomem(subreq
, req
)) {
2403 return tevent_req_post(req
, ev
);
2405 tevent_req_set_callback(subreq
, rpccli_eventlog_OpenBackupEventLogA_done
, req
);
2409 static void rpccli_eventlog_OpenBackupEventLogA_done(struct tevent_req
*subreq
)
2411 struct tevent_req
*req
= tevent_req_callback_data(
2412 subreq
, struct tevent_req
);
2413 struct rpccli_eventlog_OpenBackupEventLogA_state
*state
= tevent_req_data(
2414 req
, struct rpccli_eventlog_OpenBackupEventLogA_state
);
2416 TALLOC_CTX
*mem_ctx
;
2418 if (state
->out_mem_ctx
) {
2419 mem_ctx
= state
->out_mem_ctx
;
2424 status
= state
->dispatch_recv(subreq
, mem_ctx
);
2425 TALLOC_FREE(subreq
);
2426 if (!NT_STATUS_IS_OK(status
)) {
2427 tevent_req_nterror(req
, status
);
2431 /* Copy out parameters */
2434 state
->orig
.out
.result
= state
->tmp
.out
.result
;
2436 /* Reset temporary structure */
2437 ZERO_STRUCT(state
->tmp
);
2439 tevent_req_done(req
);
2442 NTSTATUS
rpccli_eventlog_OpenBackupEventLogA_recv(struct tevent_req
*req
,
2443 TALLOC_CTX
*mem_ctx
,
2446 struct rpccli_eventlog_OpenBackupEventLogA_state
*state
= tevent_req_data(
2447 req
, struct rpccli_eventlog_OpenBackupEventLogA_state
);
2450 if (tevent_req_is_nterror(req
, &status
)) {
2451 tevent_req_received(req
);
2455 /* Steal possbile out parameters to the callers context */
2456 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
2459 *result
= state
->orig
.out
.result
;
2461 tevent_req_received(req
);
2462 return NT_STATUS_OK
;
2465 NTSTATUS
rpccli_eventlog_OpenBackupEventLogA(struct rpc_pipe_client
*cli
,
2466 TALLOC_CTX
*mem_ctx
)
2468 struct eventlog_OpenBackupEventLogA r
;
2473 status
= cli
->dispatch(cli
,
2475 NDR_EVENTLOG_UUID
, NDR_EVENTLOG_VERSION
,
2476 NDR_EVENTLOG_OPENBACKUPEVENTLOGA
,
2479 if (!NT_STATUS_IS_OK(status
)) {
2483 if (NT_STATUS_IS_ERR(status
)) {
2487 /* Return variables */
2490 return r
.out
.result
;
2493 struct rpccli_eventlog_ReadEventLogA_state
{
2494 struct eventlog_ReadEventLogA orig
;
2495 struct eventlog_ReadEventLogA tmp
;
2496 TALLOC_CTX
*out_mem_ctx
;
2497 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
2500 static void rpccli_eventlog_ReadEventLogA_done(struct tevent_req
*subreq
);
2502 struct tevent_req
*rpccli_eventlog_ReadEventLogA_send(TALLOC_CTX
*mem_ctx
,
2503 struct tevent_context
*ev
,
2504 struct rpc_pipe_client
*cli
)
2506 struct tevent_req
*req
;
2507 struct rpccli_eventlog_ReadEventLogA_state
*state
;
2508 struct tevent_req
*subreq
;
2510 req
= tevent_req_create(mem_ctx
, &state
,
2511 struct rpccli_eventlog_ReadEventLogA_state
);
2515 state
->out_mem_ctx
= NULL
;
2516 state
->dispatch_recv
= cli
->dispatch_recv
;
2520 /* Out parameters */
2523 ZERO_STRUCT(state
->orig
.out
.result
);
2525 /* make a temporary copy, that we pass to the dispatch function */
2526 state
->tmp
= state
->orig
;
2528 subreq
= cli
->dispatch_send(state
, ev
, cli
,
2529 NDR_EVENTLOG_UUID
, NDR_EVENTLOG_VERSION
,
2530 NDR_EVENTLOG_READEVENTLOGA
,
2532 if (tevent_req_nomem(subreq
, req
)) {
2533 return tevent_req_post(req
, ev
);
2535 tevent_req_set_callback(subreq
, rpccli_eventlog_ReadEventLogA_done
, req
);
2539 static void rpccli_eventlog_ReadEventLogA_done(struct tevent_req
*subreq
)
2541 struct tevent_req
*req
= tevent_req_callback_data(
2542 subreq
, struct tevent_req
);
2543 struct rpccli_eventlog_ReadEventLogA_state
*state
= tevent_req_data(
2544 req
, struct rpccli_eventlog_ReadEventLogA_state
);
2546 TALLOC_CTX
*mem_ctx
;
2548 if (state
->out_mem_ctx
) {
2549 mem_ctx
= state
->out_mem_ctx
;
2554 status
= state
->dispatch_recv(subreq
, mem_ctx
);
2555 TALLOC_FREE(subreq
);
2556 if (!NT_STATUS_IS_OK(status
)) {
2557 tevent_req_nterror(req
, status
);
2561 /* Copy out parameters */
2564 state
->orig
.out
.result
= state
->tmp
.out
.result
;
2566 /* Reset temporary structure */
2567 ZERO_STRUCT(state
->tmp
);
2569 tevent_req_done(req
);
2572 NTSTATUS
rpccli_eventlog_ReadEventLogA_recv(struct tevent_req
*req
,
2573 TALLOC_CTX
*mem_ctx
,
2576 struct rpccli_eventlog_ReadEventLogA_state
*state
= tevent_req_data(
2577 req
, struct rpccli_eventlog_ReadEventLogA_state
);
2580 if (tevent_req_is_nterror(req
, &status
)) {
2581 tevent_req_received(req
);
2585 /* Steal possbile out parameters to the callers context */
2586 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
2589 *result
= state
->orig
.out
.result
;
2591 tevent_req_received(req
);
2592 return NT_STATUS_OK
;
2595 NTSTATUS
rpccli_eventlog_ReadEventLogA(struct rpc_pipe_client
*cli
,
2596 TALLOC_CTX
*mem_ctx
)
2598 struct eventlog_ReadEventLogA r
;
2603 status
= cli
->dispatch(cli
,
2605 NDR_EVENTLOG_UUID
, NDR_EVENTLOG_VERSION
,
2606 NDR_EVENTLOG_READEVENTLOGA
,
2609 if (!NT_STATUS_IS_OK(status
)) {
2613 if (NT_STATUS_IS_ERR(status
)) {
2617 /* Return variables */
2620 return r
.out
.result
;
2623 struct rpccli_eventlog_ReportEventA_state
{
2624 struct eventlog_ReportEventA orig
;
2625 struct eventlog_ReportEventA tmp
;
2626 TALLOC_CTX
*out_mem_ctx
;
2627 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
2630 static void rpccli_eventlog_ReportEventA_done(struct tevent_req
*subreq
);
2632 struct tevent_req
*rpccli_eventlog_ReportEventA_send(TALLOC_CTX
*mem_ctx
,
2633 struct tevent_context
*ev
,
2634 struct rpc_pipe_client
*cli
)
2636 struct tevent_req
*req
;
2637 struct rpccli_eventlog_ReportEventA_state
*state
;
2638 struct tevent_req
*subreq
;
2640 req
= tevent_req_create(mem_ctx
, &state
,
2641 struct rpccli_eventlog_ReportEventA_state
);
2645 state
->out_mem_ctx
= NULL
;
2646 state
->dispatch_recv
= cli
->dispatch_recv
;
2650 /* Out parameters */
2653 ZERO_STRUCT(state
->orig
.out
.result
);
2655 /* make a temporary copy, that we pass to the dispatch function */
2656 state
->tmp
= state
->orig
;
2658 subreq
= cli
->dispatch_send(state
, ev
, cli
,
2659 NDR_EVENTLOG_UUID
, NDR_EVENTLOG_VERSION
,
2660 NDR_EVENTLOG_REPORTEVENTA
,
2662 if (tevent_req_nomem(subreq
, req
)) {
2663 return tevent_req_post(req
, ev
);
2665 tevent_req_set_callback(subreq
, rpccli_eventlog_ReportEventA_done
, req
);
2669 static void rpccli_eventlog_ReportEventA_done(struct tevent_req
*subreq
)
2671 struct tevent_req
*req
= tevent_req_callback_data(
2672 subreq
, struct tevent_req
);
2673 struct rpccli_eventlog_ReportEventA_state
*state
= tevent_req_data(
2674 req
, struct rpccli_eventlog_ReportEventA_state
);
2676 TALLOC_CTX
*mem_ctx
;
2678 if (state
->out_mem_ctx
) {
2679 mem_ctx
= state
->out_mem_ctx
;
2684 status
= state
->dispatch_recv(subreq
, mem_ctx
);
2685 TALLOC_FREE(subreq
);
2686 if (!NT_STATUS_IS_OK(status
)) {
2687 tevent_req_nterror(req
, status
);
2691 /* Copy out parameters */
2694 state
->orig
.out
.result
= state
->tmp
.out
.result
;
2696 /* Reset temporary structure */
2697 ZERO_STRUCT(state
->tmp
);
2699 tevent_req_done(req
);
2702 NTSTATUS
rpccli_eventlog_ReportEventA_recv(struct tevent_req
*req
,
2703 TALLOC_CTX
*mem_ctx
,
2706 struct rpccli_eventlog_ReportEventA_state
*state
= tevent_req_data(
2707 req
, struct rpccli_eventlog_ReportEventA_state
);
2710 if (tevent_req_is_nterror(req
, &status
)) {
2711 tevent_req_received(req
);
2715 /* Steal possbile out parameters to the callers context */
2716 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
2719 *result
= state
->orig
.out
.result
;
2721 tevent_req_received(req
);
2722 return NT_STATUS_OK
;
2725 NTSTATUS
rpccli_eventlog_ReportEventA(struct rpc_pipe_client
*cli
,
2726 TALLOC_CTX
*mem_ctx
)
2728 struct eventlog_ReportEventA r
;
2733 status
= cli
->dispatch(cli
,
2735 NDR_EVENTLOG_UUID
, NDR_EVENTLOG_VERSION
,
2736 NDR_EVENTLOG_REPORTEVENTA
,
2739 if (!NT_STATUS_IS_OK(status
)) {
2743 if (NT_STATUS_IS_ERR(status
)) {
2747 /* Return variables */
2750 return r
.out
.result
;
2753 struct rpccli_eventlog_RegisterClusterSvc_state
{
2754 struct eventlog_RegisterClusterSvc orig
;
2755 struct eventlog_RegisterClusterSvc tmp
;
2756 TALLOC_CTX
*out_mem_ctx
;
2757 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
2760 static void rpccli_eventlog_RegisterClusterSvc_done(struct tevent_req
*subreq
);
2762 struct tevent_req
*rpccli_eventlog_RegisterClusterSvc_send(TALLOC_CTX
*mem_ctx
,
2763 struct tevent_context
*ev
,
2764 struct rpc_pipe_client
*cli
)
2766 struct tevent_req
*req
;
2767 struct rpccli_eventlog_RegisterClusterSvc_state
*state
;
2768 struct tevent_req
*subreq
;
2770 req
= tevent_req_create(mem_ctx
, &state
,
2771 struct rpccli_eventlog_RegisterClusterSvc_state
);
2775 state
->out_mem_ctx
= NULL
;
2776 state
->dispatch_recv
= cli
->dispatch_recv
;
2780 /* Out parameters */
2783 ZERO_STRUCT(state
->orig
.out
.result
);
2785 /* make a temporary copy, that we pass to the dispatch function */
2786 state
->tmp
= state
->orig
;
2788 subreq
= cli
->dispatch_send(state
, ev
, cli
,
2789 NDR_EVENTLOG_UUID
, NDR_EVENTLOG_VERSION
,
2790 NDR_EVENTLOG_REGISTERCLUSTERSVC
,
2792 if (tevent_req_nomem(subreq
, req
)) {
2793 return tevent_req_post(req
, ev
);
2795 tevent_req_set_callback(subreq
, rpccli_eventlog_RegisterClusterSvc_done
, req
);
2799 static void rpccli_eventlog_RegisterClusterSvc_done(struct tevent_req
*subreq
)
2801 struct tevent_req
*req
= tevent_req_callback_data(
2802 subreq
, struct tevent_req
);
2803 struct rpccli_eventlog_RegisterClusterSvc_state
*state
= tevent_req_data(
2804 req
, struct rpccli_eventlog_RegisterClusterSvc_state
);
2806 TALLOC_CTX
*mem_ctx
;
2808 if (state
->out_mem_ctx
) {
2809 mem_ctx
= state
->out_mem_ctx
;
2814 status
= state
->dispatch_recv(subreq
, mem_ctx
);
2815 TALLOC_FREE(subreq
);
2816 if (!NT_STATUS_IS_OK(status
)) {
2817 tevent_req_nterror(req
, status
);
2821 /* Copy out parameters */
2824 state
->orig
.out
.result
= state
->tmp
.out
.result
;
2826 /* Reset temporary structure */
2827 ZERO_STRUCT(state
->tmp
);
2829 tevent_req_done(req
);
2832 NTSTATUS
rpccli_eventlog_RegisterClusterSvc_recv(struct tevent_req
*req
,
2833 TALLOC_CTX
*mem_ctx
,
2836 struct rpccli_eventlog_RegisterClusterSvc_state
*state
= tevent_req_data(
2837 req
, struct rpccli_eventlog_RegisterClusterSvc_state
);
2840 if (tevent_req_is_nterror(req
, &status
)) {
2841 tevent_req_received(req
);
2845 /* Steal possbile out parameters to the callers context */
2846 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
2849 *result
= state
->orig
.out
.result
;
2851 tevent_req_received(req
);
2852 return NT_STATUS_OK
;
2855 NTSTATUS
rpccli_eventlog_RegisterClusterSvc(struct rpc_pipe_client
*cli
,
2856 TALLOC_CTX
*mem_ctx
)
2858 struct eventlog_RegisterClusterSvc r
;
2863 status
= cli
->dispatch(cli
,
2865 NDR_EVENTLOG_UUID
, NDR_EVENTLOG_VERSION
,
2866 NDR_EVENTLOG_REGISTERCLUSTERSVC
,
2869 if (!NT_STATUS_IS_OK(status
)) {
2873 if (NT_STATUS_IS_ERR(status
)) {
2877 /* Return variables */
2880 return r
.out
.result
;
2883 struct rpccli_eventlog_DeregisterClusterSvc_state
{
2884 struct eventlog_DeregisterClusterSvc orig
;
2885 struct eventlog_DeregisterClusterSvc tmp
;
2886 TALLOC_CTX
*out_mem_ctx
;
2887 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
2890 static void rpccli_eventlog_DeregisterClusterSvc_done(struct tevent_req
*subreq
);
2892 struct tevent_req
*rpccli_eventlog_DeregisterClusterSvc_send(TALLOC_CTX
*mem_ctx
,
2893 struct tevent_context
*ev
,
2894 struct rpc_pipe_client
*cli
)
2896 struct tevent_req
*req
;
2897 struct rpccli_eventlog_DeregisterClusterSvc_state
*state
;
2898 struct tevent_req
*subreq
;
2900 req
= tevent_req_create(mem_ctx
, &state
,
2901 struct rpccli_eventlog_DeregisterClusterSvc_state
);
2905 state
->out_mem_ctx
= NULL
;
2906 state
->dispatch_recv
= cli
->dispatch_recv
;
2910 /* Out parameters */
2913 ZERO_STRUCT(state
->orig
.out
.result
);
2915 /* make a temporary copy, that we pass to the dispatch function */
2916 state
->tmp
= state
->orig
;
2918 subreq
= cli
->dispatch_send(state
, ev
, cli
,
2919 NDR_EVENTLOG_UUID
, NDR_EVENTLOG_VERSION
,
2920 NDR_EVENTLOG_DEREGISTERCLUSTERSVC
,
2922 if (tevent_req_nomem(subreq
, req
)) {
2923 return tevent_req_post(req
, ev
);
2925 tevent_req_set_callback(subreq
, rpccli_eventlog_DeregisterClusterSvc_done
, req
);
2929 static void rpccli_eventlog_DeregisterClusterSvc_done(struct tevent_req
*subreq
)
2931 struct tevent_req
*req
= tevent_req_callback_data(
2932 subreq
, struct tevent_req
);
2933 struct rpccli_eventlog_DeregisterClusterSvc_state
*state
= tevent_req_data(
2934 req
, struct rpccli_eventlog_DeregisterClusterSvc_state
);
2936 TALLOC_CTX
*mem_ctx
;
2938 if (state
->out_mem_ctx
) {
2939 mem_ctx
= state
->out_mem_ctx
;
2944 status
= state
->dispatch_recv(subreq
, mem_ctx
);
2945 TALLOC_FREE(subreq
);
2946 if (!NT_STATUS_IS_OK(status
)) {
2947 tevent_req_nterror(req
, status
);
2951 /* Copy out parameters */
2954 state
->orig
.out
.result
= state
->tmp
.out
.result
;
2956 /* Reset temporary structure */
2957 ZERO_STRUCT(state
->tmp
);
2959 tevent_req_done(req
);
2962 NTSTATUS
rpccli_eventlog_DeregisterClusterSvc_recv(struct tevent_req
*req
,
2963 TALLOC_CTX
*mem_ctx
,
2966 struct rpccli_eventlog_DeregisterClusterSvc_state
*state
= tevent_req_data(
2967 req
, struct rpccli_eventlog_DeregisterClusterSvc_state
);
2970 if (tevent_req_is_nterror(req
, &status
)) {
2971 tevent_req_received(req
);
2975 /* Steal possbile out parameters to the callers context */
2976 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
2979 *result
= state
->orig
.out
.result
;
2981 tevent_req_received(req
);
2982 return NT_STATUS_OK
;
2985 NTSTATUS
rpccli_eventlog_DeregisterClusterSvc(struct rpc_pipe_client
*cli
,
2986 TALLOC_CTX
*mem_ctx
)
2988 struct eventlog_DeregisterClusterSvc r
;
2993 status
= cli
->dispatch(cli
,
2995 NDR_EVENTLOG_UUID
, NDR_EVENTLOG_VERSION
,
2996 NDR_EVENTLOG_DEREGISTERCLUSTERSVC
,
2999 if (!NT_STATUS_IS_OK(status
)) {
3003 if (NT_STATUS_IS_ERR(status
)) {
3007 /* Return variables */
3010 return r
.out
.result
;
3013 struct rpccli_eventlog_WriteClusterEvents_state
{
3014 struct eventlog_WriteClusterEvents orig
;
3015 struct eventlog_WriteClusterEvents tmp
;
3016 TALLOC_CTX
*out_mem_ctx
;
3017 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
3020 static void rpccli_eventlog_WriteClusterEvents_done(struct tevent_req
*subreq
);
3022 struct tevent_req
*rpccli_eventlog_WriteClusterEvents_send(TALLOC_CTX
*mem_ctx
,
3023 struct tevent_context
*ev
,
3024 struct rpc_pipe_client
*cli
)
3026 struct tevent_req
*req
;
3027 struct rpccli_eventlog_WriteClusterEvents_state
*state
;
3028 struct tevent_req
*subreq
;
3030 req
= tevent_req_create(mem_ctx
, &state
,
3031 struct rpccli_eventlog_WriteClusterEvents_state
);
3035 state
->out_mem_ctx
= NULL
;
3036 state
->dispatch_recv
= cli
->dispatch_recv
;
3040 /* Out parameters */
3043 ZERO_STRUCT(state
->orig
.out
.result
);
3045 /* make a temporary copy, that we pass to the dispatch function */
3046 state
->tmp
= state
->orig
;
3048 subreq
= cli
->dispatch_send(state
, ev
, cli
,
3049 NDR_EVENTLOG_UUID
, NDR_EVENTLOG_VERSION
,
3050 NDR_EVENTLOG_WRITECLUSTEREVENTS
,
3052 if (tevent_req_nomem(subreq
, req
)) {
3053 return tevent_req_post(req
, ev
);
3055 tevent_req_set_callback(subreq
, rpccli_eventlog_WriteClusterEvents_done
, req
);
3059 static void rpccli_eventlog_WriteClusterEvents_done(struct tevent_req
*subreq
)
3061 struct tevent_req
*req
= tevent_req_callback_data(
3062 subreq
, struct tevent_req
);
3063 struct rpccli_eventlog_WriteClusterEvents_state
*state
= tevent_req_data(
3064 req
, struct rpccli_eventlog_WriteClusterEvents_state
);
3066 TALLOC_CTX
*mem_ctx
;
3068 if (state
->out_mem_ctx
) {
3069 mem_ctx
= state
->out_mem_ctx
;
3074 status
= state
->dispatch_recv(subreq
, mem_ctx
);
3075 TALLOC_FREE(subreq
);
3076 if (!NT_STATUS_IS_OK(status
)) {
3077 tevent_req_nterror(req
, status
);
3081 /* Copy out parameters */
3084 state
->orig
.out
.result
= state
->tmp
.out
.result
;
3086 /* Reset temporary structure */
3087 ZERO_STRUCT(state
->tmp
);
3089 tevent_req_done(req
);
3092 NTSTATUS
rpccli_eventlog_WriteClusterEvents_recv(struct tevent_req
*req
,
3093 TALLOC_CTX
*mem_ctx
,
3096 struct rpccli_eventlog_WriteClusterEvents_state
*state
= tevent_req_data(
3097 req
, struct rpccli_eventlog_WriteClusterEvents_state
);
3100 if (tevent_req_is_nterror(req
, &status
)) {
3101 tevent_req_received(req
);
3105 /* Steal possbile out parameters to the callers context */
3106 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
3109 *result
= state
->orig
.out
.result
;
3111 tevent_req_received(req
);
3112 return NT_STATUS_OK
;
3115 NTSTATUS
rpccli_eventlog_WriteClusterEvents(struct rpc_pipe_client
*cli
,
3116 TALLOC_CTX
*mem_ctx
)
3118 struct eventlog_WriteClusterEvents r
;
3123 status
= cli
->dispatch(cli
,
3125 NDR_EVENTLOG_UUID
, NDR_EVENTLOG_VERSION
,
3126 NDR_EVENTLOG_WRITECLUSTEREVENTS
,
3129 if (!NT_STATUS_IS_OK(status
)) {
3133 if (NT_STATUS_IS_ERR(status
)) {
3137 /* Return variables */
3140 return r
.out
.result
;
3143 struct rpccli_eventlog_GetLogInformation_state
{
3144 struct eventlog_GetLogInformation orig
;
3145 struct eventlog_GetLogInformation tmp
;
3146 TALLOC_CTX
*out_mem_ctx
;
3147 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
3150 static void rpccli_eventlog_GetLogInformation_done(struct tevent_req
*subreq
);
3152 struct tevent_req
*rpccli_eventlog_GetLogInformation_send(TALLOC_CTX
*mem_ctx
,
3153 struct tevent_context
*ev
,
3154 struct rpc_pipe_client
*cli
,
3155 struct policy_handle
*_handle
/* [in] [ref] */,
3156 uint32_t _level
/* [in] */,
3157 uint8_t *_buffer
/* [out] [ref,size_is(buf_size)] */,
3158 uint32_t _buf_size
/* [in] [range(0,1024)] */,
3159 uint32_t *_bytes_needed
/* [out] [ref] */)
3161 struct tevent_req
*req
;
3162 struct rpccli_eventlog_GetLogInformation_state
*state
;
3163 struct tevent_req
*subreq
;
3165 req
= tevent_req_create(mem_ctx
, &state
,
3166 struct rpccli_eventlog_GetLogInformation_state
);
3170 state
->out_mem_ctx
= NULL
;
3171 state
->dispatch_recv
= cli
->dispatch_recv
;
3174 state
->orig
.in
.handle
= _handle
;
3175 state
->orig
.in
.level
= _level
;
3176 state
->orig
.in
.buf_size
= _buf_size
;
3178 /* Out parameters */
3179 state
->orig
.out
.buffer
= _buffer
;
3180 state
->orig
.out
.bytes_needed
= _bytes_needed
;
3183 ZERO_STRUCT(state
->orig
.out
.result
);
3185 state
->out_mem_ctx
= talloc_named_const(state
, 0,
3186 "rpccli_eventlog_GetLogInformation_out_memory");
3187 if (tevent_req_nomem(state
->out_mem_ctx
, req
)) {
3188 return tevent_req_post(req
, ev
);
3191 /* make a temporary copy, that we pass to the dispatch function */
3192 state
->tmp
= state
->orig
;
3194 subreq
= cli
->dispatch_send(state
, ev
, cli
,
3195 NDR_EVENTLOG_UUID
, NDR_EVENTLOG_VERSION
,
3196 NDR_EVENTLOG_GETLOGINFORMATION
,
3198 if (tevent_req_nomem(subreq
, req
)) {
3199 return tevent_req_post(req
, ev
);
3201 tevent_req_set_callback(subreq
, rpccli_eventlog_GetLogInformation_done
, req
);
3205 static void rpccli_eventlog_GetLogInformation_done(struct tevent_req
*subreq
)
3207 struct tevent_req
*req
= tevent_req_callback_data(
3208 subreq
, struct tevent_req
);
3209 struct rpccli_eventlog_GetLogInformation_state
*state
= tevent_req_data(
3210 req
, struct rpccli_eventlog_GetLogInformation_state
);
3212 TALLOC_CTX
*mem_ctx
;
3214 if (state
->out_mem_ctx
) {
3215 mem_ctx
= state
->out_mem_ctx
;
3220 status
= state
->dispatch_recv(subreq
, mem_ctx
);
3221 TALLOC_FREE(subreq
);
3222 if (!NT_STATUS_IS_OK(status
)) {
3223 tevent_req_nterror(req
, status
);
3227 /* Copy out parameters */
3228 memcpy(state
->orig
.out
.buffer
, state
->tmp
.out
.buffer
, state
->tmp
.in
.buf_size
* sizeof(*state
->orig
.out
.buffer
));
3229 *state
->orig
.out
.bytes_needed
= *state
->tmp
.out
.bytes_needed
;
3232 state
->orig
.out
.result
= state
->tmp
.out
.result
;
3234 /* Reset temporary structure */
3235 ZERO_STRUCT(state
->tmp
);
3237 tevent_req_done(req
);
3240 NTSTATUS
rpccli_eventlog_GetLogInformation_recv(struct tevent_req
*req
,
3241 TALLOC_CTX
*mem_ctx
,
3244 struct rpccli_eventlog_GetLogInformation_state
*state
= tevent_req_data(
3245 req
, struct rpccli_eventlog_GetLogInformation_state
);
3248 if (tevent_req_is_nterror(req
, &status
)) {
3249 tevent_req_received(req
);
3253 /* Steal possbile out parameters to the callers context */
3254 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
3257 *result
= state
->orig
.out
.result
;
3259 tevent_req_received(req
);
3260 return NT_STATUS_OK
;
3263 NTSTATUS
rpccli_eventlog_GetLogInformation(struct rpc_pipe_client
*cli
,
3264 TALLOC_CTX
*mem_ctx
,
3265 struct policy_handle
*handle
/* [in] [ref] */,
3266 uint32_t level
/* [in] */,
3267 uint8_t *buffer
/* [out] [ref,size_is(buf_size)] */,
3268 uint32_t buf_size
/* [in] [range(0,1024)] */,
3269 uint32_t *bytes_needed
/* [out] [ref] */)
3271 struct eventlog_GetLogInformation r
;
3275 r
.in
.handle
= handle
;
3277 r
.in
.buf_size
= buf_size
;
3279 status
= cli
->dispatch(cli
,
3281 NDR_EVENTLOG_UUID
, NDR_EVENTLOG_VERSION
,
3282 NDR_EVENTLOG_GETLOGINFORMATION
,
3285 if (!NT_STATUS_IS_OK(status
)) {
3289 if (NT_STATUS_IS_ERR(status
)) {
3293 /* Return variables */
3294 memcpy(buffer
, r
.out
.buffer
, r
.in
.buf_size
* sizeof(*buffer
));
3295 *bytes_needed
= *r
.out
.bytes_needed
;
3298 return r
.out
.result
;
3301 struct rpccli_eventlog_FlushEventLog_state
{
3302 struct eventlog_FlushEventLog orig
;
3303 struct eventlog_FlushEventLog tmp
;
3304 TALLOC_CTX
*out_mem_ctx
;
3305 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
3308 static void rpccli_eventlog_FlushEventLog_done(struct tevent_req
*subreq
);
3310 struct tevent_req
*rpccli_eventlog_FlushEventLog_send(TALLOC_CTX
*mem_ctx
,
3311 struct tevent_context
*ev
,
3312 struct rpc_pipe_client
*cli
,
3313 struct policy_handle
*_handle
/* [in] [ref] */)
3315 struct tevent_req
*req
;
3316 struct rpccli_eventlog_FlushEventLog_state
*state
;
3317 struct tevent_req
*subreq
;
3319 req
= tevent_req_create(mem_ctx
, &state
,
3320 struct rpccli_eventlog_FlushEventLog_state
);
3324 state
->out_mem_ctx
= NULL
;
3325 state
->dispatch_recv
= cli
->dispatch_recv
;
3328 state
->orig
.in
.handle
= _handle
;
3330 /* Out parameters */
3333 ZERO_STRUCT(state
->orig
.out
.result
);
3335 /* make a temporary copy, that we pass to the dispatch function */
3336 state
->tmp
= state
->orig
;
3338 subreq
= cli
->dispatch_send(state
, ev
, cli
,
3339 NDR_EVENTLOG_UUID
, NDR_EVENTLOG_VERSION
,
3340 NDR_EVENTLOG_FLUSHEVENTLOG
,
3342 if (tevent_req_nomem(subreq
, req
)) {
3343 return tevent_req_post(req
, ev
);
3345 tevent_req_set_callback(subreq
, rpccli_eventlog_FlushEventLog_done
, req
);
3349 static void rpccli_eventlog_FlushEventLog_done(struct tevent_req
*subreq
)
3351 struct tevent_req
*req
= tevent_req_callback_data(
3352 subreq
, struct tevent_req
);
3353 struct rpccli_eventlog_FlushEventLog_state
*state
= tevent_req_data(
3354 req
, struct rpccli_eventlog_FlushEventLog_state
);
3356 TALLOC_CTX
*mem_ctx
;
3358 if (state
->out_mem_ctx
) {
3359 mem_ctx
= state
->out_mem_ctx
;
3364 status
= state
->dispatch_recv(subreq
, mem_ctx
);
3365 TALLOC_FREE(subreq
);
3366 if (!NT_STATUS_IS_OK(status
)) {
3367 tevent_req_nterror(req
, status
);
3371 /* Copy out parameters */
3374 state
->orig
.out
.result
= state
->tmp
.out
.result
;
3376 /* Reset temporary structure */
3377 ZERO_STRUCT(state
->tmp
);
3379 tevent_req_done(req
);
3382 NTSTATUS
rpccli_eventlog_FlushEventLog_recv(struct tevent_req
*req
,
3383 TALLOC_CTX
*mem_ctx
,
3386 struct rpccli_eventlog_FlushEventLog_state
*state
= tevent_req_data(
3387 req
, struct rpccli_eventlog_FlushEventLog_state
);
3390 if (tevent_req_is_nterror(req
, &status
)) {
3391 tevent_req_received(req
);
3395 /* Steal possbile out parameters to the callers context */
3396 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
3399 *result
= state
->orig
.out
.result
;
3401 tevent_req_received(req
);
3402 return NT_STATUS_OK
;
3405 NTSTATUS
rpccli_eventlog_FlushEventLog(struct rpc_pipe_client
*cli
,
3406 TALLOC_CTX
*mem_ctx
,
3407 struct policy_handle
*handle
/* [in] [ref] */)
3409 struct eventlog_FlushEventLog r
;
3413 r
.in
.handle
= handle
;
3415 status
= cli
->dispatch(cli
,
3417 NDR_EVENTLOG_UUID
, NDR_EVENTLOG_VERSION
,
3418 NDR_EVENTLOG_FLUSHEVENTLOG
,
3421 if (!NT_STATUS_IS_OK(status
)) {
3425 if (NT_STATUS_IS_ERR(status
)) {
3429 /* Return variables */
3432 return r
.out
.result
;
3435 struct rpccli_eventlog_ReportEventAndSourceW_state
{
3436 struct eventlog_ReportEventAndSourceW orig
;
3437 struct eventlog_ReportEventAndSourceW tmp
;
3438 TALLOC_CTX
*out_mem_ctx
;
3439 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
3442 static void rpccli_eventlog_ReportEventAndSourceW_done(struct tevent_req
*subreq
);
3444 struct tevent_req
*rpccli_eventlog_ReportEventAndSourceW_send(TALLOC_CTX
*mem_ctx
,
3445 struct tevent_context
*ev
,
3446 struct rpc_pipe_client
*cli
,
3447 struct policy_handle
*_handle
/* [in] [ref] */,
3448 time_t _timestamp
/* [in] */,
3449 enum eventlogEventTypes _event_type
/* [in] */,
3450 uint16_t _event_category
/* [in] */,
3451 uint32_t _event_id
/* [in] */,
3452 struct lsa_String
*_sourcename
/* [in] [ref] */,
3453 uint16_t _num_of_strings
/* [in] [range(0,256)] */,
3454 uint32_t _data_size
/* [in] [range(0,0x3FFFF)] */,
3455 struct lsa_String
*_servername
/* [in] [ref] */,
3456 struct dom_sid
*_user_sid
/* [in] [unique] */,
3457 struct lsa_String
**_strings
/* [in] [unique,size_is(num_of_strings)] */,
3458 uint8_t *_data
/* [in] [unique,size_is(data_size)] */,
3459 uint16_t _flags
/* [in] */,
3460 uint32_t *_record_number
/* [in,out] [unique] */,
3461 time_t *_time_written
/* [in,out] [unique] */)
3463 struct tevent_req
*req
;
3464 struct rpccli_eventlog_ReportEventAndSourceW_state
*state
;
3465 struct tevent_req
*subreq
;
3467 req
= tevent_req_create(mem_ctx
, &state
,
3468 struct rpccli_eventlog_ReportEventAndSourceW_state
);
3472 state
->out_mem_ctx
= NULL
;
3473 state
->dispatch_recv
= cli
->dispatch_recv
;
3476 state
->orig
.in
.handle
= _handle
;
3477 state
->orig
.in
.timestamp
= _timestamp
;
3478 state
->orig
.in
.event_type
= _event_type
;
3479 state
->orig
.in
.event_category
= _event_category
;
3480 state
->orig
.in
.event_id
= _event_id
;
3481 state
->orig
.in
.sourcename
= _sourcename
;
3482 state
->orig
.in
.num_of_strings
= _num_of_strings
;
3483 state
->orig
.in
.data_size
= _data_size
;
3484 state
->orig
.in
.servername
= _servername
;
3485 state
->orig
.in
.user_sid
= _user_sid
;
3486 state
->orig
.in
.strings
= _strings
;
3487 state
->orig
.in
.data
= _data
;
3488 state
->orig
.in
.flags
= _flags
;
3489 state
->orig
.in
.record_number
= _record_number
;
3490 state
->orig
.in
.time_written
= _time_written
;
3492 /* Out parameters */
3493 state
->orig
.out
.record_number
= _record_number
;
3494 state
->orig
.out
.time_written
= _time_written
;
3497 ZERO_STRUCT(state
->orig
.out
.result
);
3499 state
->out_mem_ctx
= talloc_named_const(state
, 0,
3500 "rpccli_eventlog_ReportEventAndSourceW_out_memory");
3501 if (tevent_req_nomem(state
->out_mem_ctx
, req
)) {
3502 return tevent_req_post(req
, ev
);
3505 /* make a temporary copy, that we pass to the dispatch function */
3506 state
->tmp
= state
->orig
;
3508 subreq
= cli
->dispatch_send(state
, ev
, cli
,
3509 NDR_EVENTLOG_UUID
, NDR_EVENTLOG_VERSION
,
3510 NDR_EVENTLOG_REPORTEVENTANDSOURCEW
,
3512 if (tevent_req_nomem(subreq
, req
)) {
3513 return tevent_req_post(req
, ev
);
3515 tevent_req_set_callback(subreq
, rpccli_eventlog_ReportEventAndSourceW_done
, req
);
3519 static void rpccli_eventlog_ReportEventAndSourceW_done(struct tevent_req
*subreq
)
3521 struct tevent_req
*req
= tevent_req_callback_data(
3522 subreq
, struct tevent_req
);
3523 struct rpccli_eventlog_ReportEventAndSourceW_state
*state
= tevent_req_data(
3524 req
, struct rpccli_eventlog_ReportEventAndSourceW_state
);
3526 TALLOC_CTX
*mem_ctx
;
3528 if (state
->out_mem_ctx
) {
3529 mem_ctx
= state
->out_mem_ctx
;
3534 status
= state
->dispatch_recv(subreq
, mem_ctx
);
3535 TALLOC_FREE(subreq
);
3536 if (!NT_STATUS_IS_OK(status
)) {
3537 tevent_req_nterror(req
, status
);
3541 /* Copy out parameters */
3542 if (state
->orig
.out
.record_number
&& state
->tmp
.out
.record_number
) {
3543 *state
->orig
.out
.record_number
= *state
->tmp
.out
.record_number
;
3545 if (state
->orig
.out
.time_written
&& state
->tmp
.out
.time_written
) {
3546 *state
->orig
.out
.time_written
= *state
->tmp
.out
.time_written
;
3550 state
->orig
.out
.result
= state
->tmp
.out
.result
;
3552 /* Reset temporary structure */
3553 ZERO_STRUCT(state
->tmp
);
3555 tevent_req_done(req
);
3558 NTSTATUS
rpccli_eventlog_ReportEventAndSourceW_recv(struct tevent_req
*req
,
3559 TALLOC_CTX
*mem_ctx
,
3562 struct rpccli_eventlog_ReportEventAndSourceW_state
*state
= tevent_req_data(
3563 req
, struct rpccli_eventlog_ReportEventAndSourceW_state
);
3566 if (tevent_req_is_nterror(req
, &status
)) {
3567 tevent_req_received(req
);
3571 /* Steal possbile out parameters to the callers context */
3572 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
3575 *result
= state
->orig
.out
.result
;
3577 tevent_req_received(req
);
3578 return NT_STATUS_OK
;
3581 NTSTATUS
rpccli_eventlog_ReportEventAndSourceW(struct rpc_pipe_client
*cli
,
3582 TALLOC_CTX
*mem_ctx
,
3583 struct policy_handle
*handle
/* [in] [ref] */,
3584 time_t timestamp
/* [in] */,
3585 enum eventlogEventTypes event_type
/* [in] */,
3586 uint16_t event_category
/* [in] */,
3587 uint32_t event_id
/* [in] */,
3588 struct lsa_String
*sourcename
/* [in] [ref] */,
3589 uint16_t num_of_strings
/* [in] [range(0,256)] */,
3590 uint32_t data_size
/* [in] [range(0,0x3FFFF)] */,
3591 struct lsa_String
*servername
/* [in] [ref] */,
3592 struct dom_sid
*user_sid
/* [in] [unique] */,
3593 struct lsa_String
**strings
/* [in] [unique,size_is(num_of_strings)] */,
3594 uint8_t *data
/* [in] [unique,size_is(data_size)] */,
3595 uint16_t flags
/* [in] */,
3596 uint32_t *record_number
/* [in,out] [unique] */,
3597 time_t *time_written
/* [in,out] [unique] */)
3599 struct eventlog_ReportEventAndSourceW r
;
3603 r
.in
.handle
= handle
;
3604 r
.in
.timestamp
= timestamp
;
3605 r
.in
.event_type
= event_type
;
3606 r
.in
.event_category
= event_category
;
3607 r
.in
.event_id
= event_id
;
3608 r
.in
.sourcename
= sourcename
;
3609 r
.in
.num_of_strings
= num_of_strings
;
3610 r
.in
.data_size
= data_size
;
3611 r
.in
.servername
= servername
;
3612 r
.in
.user_sid
= user_sid
;
3613 r
.in
.strings
= strings
;
3616 r
.in
.record_number
= record_number
;
3617 r
.in
.time_written
= time_written
;
3619 status
= cli
->dispatch(cli
,
3621 NDR_EVENTLOG_UUID
, NDR_EVENTLOG_VERSION
,
3622 NDR_EVENTLOG_REPORTEVENTANDSOURCEW
,
3625 if (!NT_STATUS_IS_OK(status
)) {
3629 if (NT_STATUS_IS_ERR(status
)) {
3633 /* Return variables */
3634 if (record_number
&& r
.out
.record_number
) {
3635 *record_number
= *r
.out
.record_number
;
3637 if (time_written
&& r
.out
.time_written
) {
3638 *time_written
= *r
.out
.time_written
;
3642 return r
.out
.result
;