?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge branch 'master' of /home/tridge/samba/git/combined
[Samba/aatanasov.git] / librpc / gen_ndr / cli_eventlog.c
bloba53ca13eb41779745256d2ba1f4469e695c99d81
1 /*
2 * Unix SMB/CIFS implementation.
3 * client auto-generated by pidl. DO NOT MODIFY!
4 */
5
6 #include "includes.h"
7 #include "../librpc/gen_ndr/cli_eventlog.h"
8
9 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);
14 };
15
16 static void rpccli_eventlog_ClearEventLogW_done(struct tevent_req *subreq);
17
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] */)
23 {
24 struct tevent_req *req;
25 struct rpccli_eventlog_ClearEventLogW_state *state;
26 struct tevent_req *subreq;
27
28 req = tevent_req_create(mem_ctx, &state,
29 struct rpccli_eventlog_ClearEventLogW_state);
30 if (req == NULL) {
31 return NULL;
32 }
33 state->out_mem_ctx = NULL;
34 state->dispatch_recv = cli->dispatch_recv;
35
36 /* In parameters */
37 state->orig.in.handle = _handle;
38 state->orig.in.backupfile = _backupfile;
39
40 /* Out parameters */
41
42 /* Result */
43 ZERO_STRUCT(state->orig.out.result);
44
45 if (DEBUGLEVEL >= 10) {
46 NDR_PRINT_IN_DEBUG(eventlog_ClearEventLogW, &state->orig);
47 }
48
49 /* make a temporary copy, that we pass to the dispatch function */
50 state->tmp = state->orig;
51
52 subreq = cli->dispatch_send(state, ev, cli,
53 &ndr_table_eventlog,
54 NDR_EVENTLOG_CLEAREVENTLOGW,
55 &state->tmp);
56 if (tevent_req_nomem(subreq, req)) {
57 return tevent_req_post(req, ev);
58 }
59 tevent_req_set_callback(subreq, rpccli_eventlog_ClearEventLogW_done, req);
60 return req;
61 }
62
63 static void rpccli_eventlog_ClearEventLogW_done(struct tevent_req *subreq)
64 {
65 struct tevent_req *req = tevent_req_callback_data(
66 subreq, struct tevent_req);
67 struct rpccli_eventlog_ClearEventLogW_state *state = tevent_req_data(
68 req, struct rpccli_eventlog_ClearEventLogW_state);
69 NTSTATUS status;
70 TALLOC_CTX *mem_ctx;
71
72 if (state->out_mem_ctx) {
73 mem_ctx = state->out_mem_ctx;
74 } else {
75 mem_ctx = state;
76 }
77
78 status = state->dispatch_recv(subreq, mem_ctx);
79 TALLOC_FREE(subreq);
80 if (!NT_STATUS_IS_OK(status)) {
81 tevent_req_nterror(req, status);
82 return;
83 }
84
85 /* Copy out parameters */
86
87 /* Copy result */
88 state->orig.out.result = state->tmp.out.result;
89
90 /* Reset temporary structure */
91 ZERO_STRUCT(state->tmp);
92
93 if (DEBUGLEVEL >= 10) {
94 NDR_PRINT_OUT_DEBUG(eventlog_ClearEventLogW, &state->orig);
95 }
96
97 tevent_req_done(req);
98 }
99
100 NTSTATUS rpccli_eventlog_ClearEventLogW_recv(struct tevent_req *req,
101 TALLOC_CTX *mem_ctx,
102 NTSTATUS *result)
103 {
104 struct rpccli_eventlog_ClearEventLogW_state *state = tevent_req_data(
105 req, struct rpccli_eventlog_ClearEventLogW_state);
106 NTSTATUS status;
107
108 if (tevent_req_is_nterror(req, &status)) {
109 tevent_req_received(req);
110 return status;
111 }
112
113 /* Steal possbile out parameters to the callers context */
114 talloc_steal(mem_ctx, state->out_mem_ctx);
115
116 /* Return result */
117 *result = state->orig.out.result;
118
119 tevent_req_received(req);
120 return NT_STATUS_OK;
121 }
122
123 NTSTATUS rpccli_eventlog_ClearEventLogW(struct rpc_pipe_client *cli,
124 TALLOC_CTX *mem_ctx,
125 struct policy_handle *handle /* [in] [ref] */,
126 struct lsa_String *backupfile /* [in] [unique] */)
127 {
128 struct eventlog_ClearEventLogW r;
129 NTSTATUS status;
130
131 /* In parameters */
132 r.in.handle = handle;
133 r.in.backupfile = backupfile;
134
135 if (DEBUGLEVEL >= 10) {
136 NDR_PRINT_IN_DEBUG(eventlog_ClearEventLogW, &r);
137 }
138
139 status = cli->dispatch(cli,
140 mem_ctx,
141 &ndr_table_eventlog,
142 NDR_EVENTLOG_CLEAREVENTLOGW,
143 &r);
144
145 if (!NT_STATUS_IS_OK(status)) {
146 return status;
147 }
148
149 if (DEBUGLEVEL >= 10) {
150 NDR_PRINT_OUT_DEBUG(eventlog_ClearEventLogW, &r);
151 }
152
153 if (NT_STATUS_IS_ERR(status)) {
154 return status;
155 }
156
157 /* Return variables */
158
159 /* Return result */
160 return r.out.result;
161 }
162
163 struct rpccli_eventlog_BackupEventLogW_state {
164 struct eventlog_BackupEventLogW orig;
165 struct eventlog_BackupEventLogW tmp;
166 TALLOC_CTX *out_mem_ctx;
167 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
168 };
169
170 static void rpccli_eventlog_BackupEventLogW_done(struct tevent_req *subreq);
171
172 struct tevent_req *rpccli_eventlog_BackupEventLogW_send(TALLOC_CTX *mem_ctx,
173 struct tevent_context *ev,
174 struct rpc_pipe_client *cli,
175 struct policy_handle *_handle /* [in] [ref] */,
176 struct lsa_String *_backup_filename /* [in] [ref] */)
177 {
178 struct tevent_req *req;
179 struct rpccli_eventlog_BackupEventLogW_state *state;
180 struct tevent_req *subreq;
181
182 req = tevent_req_create(mem_ctx, &state,
183 struct rpccli_eventlog_BackupEventLogW_state);
184 if (req == NULL) {
185 return NULL;
186 }
187 state->out_mem_ctx = NULL;
188 state->dispatch_recv = cli->dispatch_recv;
189
190 /* In parameters */
191 state->orig.in.handle = _handle;
192 state->orig.in.backup_filename = _backup_filename;
193
194 /* Out parameters */
195
196 /* Result */
197 ZERO_STRUCT(state->orig.out.result);
198
199 if (DEBUGLEVEL >= 10) {
200 NDR_PRINT_IN_DEBUG(eventlog_BackupEventLogW, &state->orig);
201 }
202
203 /* make a temporary copy, that we pass to the dispatch function */
204 state->tmp = state->orig;
205
206 subreq = cli->dispatch_send(state, ev, cli,
207 &ndr_table_eventlog,
208 NDR_EVENTLOG_BACKUPEVENTLOGW,
209 &state->tmp);
210 if (tevent_req_nomem(subreq, req)) {
211 return tevent_req_post(req, ev);
212 }
213 tevent_req_set_callback(subreq, rpccli_eventlog_BackupEventLogW_done, req);
214 return req;
215 }
216
217 static void rpccli_eventlog_BackupEventLogW_done(struct tevent_req *subreq)
218 {
219 struct tevent_req *req = tevent_req_callback_data(
220 subreq, struct tevent_req);
221 struct rpccli_eventlog_BackupEventLogW_state *state = tevent_req_data(
222 req, struct rpccli_eventlog_BackupEventLogW_state);
223 NTSTATUS status;
224 TALLOC_CTX *mem_ctx;
225
226 if (state->out_mem_ctx) {
227 mem_ctx = state->out_mem_ctx;
228 } else {
229 mem_ctx = state;
230 }
231
232 status = state->dispatch_recv(subreq, mem_ctx);
233 TALLOC_FREE(subreq);
234 if (!NT_STATUS_IS_OK(status)) {
235 tevent_req_nterror(req, status);
236 return;
237 }
238
239 /* Copy out parameters */
240
241 /* Copy result */
242 state->orig.out.result = state->tmp.out.result;
243
244 /* Reset temporary structure */
245 ZERO_STRUCT(state->tmp);
246
247 if (DEBUGLEVEL >= 10) {
248 NDR_PRINT_OUT_DEBUG(eventlog_BackupEventLogW, &state->orig);
249 }
250
251 tevent_req_done(req);
252 }
253
254 NTSTATUS rpccli_eventlog_BackupEventLogW_recv(struct tevent_req *req,
255 TALLOC_CTX *mem_ctx,
256 NTSTATUS *result)
257 {
258 struct rpccli_eventlog_BackupEventLogW_state *state = tevent_req_data(
259 req, struct rpccli_eventlog_BackupEventLogW_state);
260 NTSTATUS status;
261
262 if (tevent_req_is_nterror(req, &status)) {
263 tevent_req_received(req);
264 return status;
265 }
266
267 /* Steal possbile out parameters to the callers context */
268 talloc_steal(mem_ctx, state->out_mem_ctx);
269
270 /* Return result */
271 *result = state->orig.out.result;
272
273 tevent_req_received(req);
274 return NT_STATUS_OK;
275 }
276
277 NTSTATUS rpccli_eventlog_BackupEventLogW(struct rpc_pipe_client *cli,
278 TALLOC_CTX *mem_ctx,
279 struct policy_handle *handle /* [in] [ref] */,
280 struct lsa_String *backup_filename /* [in] [ref] */)
281 {
282 struct eventlog_BackupEventLogW r;
283 NTSTATUS status;
284
285 /* In parameters */
286 r.in.handle = handle;
287 r.in.backup_filename = backup_filename;
288
289 if (DEBUGLEVEL >= 10) {
290 NDR_PRINT_IN_DEBUG(eventlog_BackupEventLogW, &r);
291 }
292
293 status = cli->dispatch(cli,
294 mem_ctx,
295 &ndr_table_eventlog,
296 NDR_EVENTLOG_BACKUPEVENTLOGW,
297 &r);
298
299 if (!NT_STATUS_IS_OK(status)) {
300 return status;
301 }
302
303 if (DEBUGLEVEL >= 10) {
304 NDR_PRINT_OUT_DEBUG(eventlog_BackupEventLogW, &r);
305 }
306
307 if (NT_STATUS_IS_ERR(status)) {
308 return status;
309 }
310
311 /* Return variables */
312
313 /* Return result */
314 return r.out.result;
315 }
316
317 struct rpccli_eventlog_CloseEventLog_state {
318 struct eventlog_CloseEventLog orig;
319 struct eventlog_CloseEventLog tmp;
320 TALLOC_CTX *out_mem_ctx;
321 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
322 };
323
324 static void rpccli_eventlog_CloseEventLog_done(struct tevent_req *subreq);
325
326 struct tevent_req *rpccli_eventlog_CloseEventLog_send(TALLOC_CTX *mem_ctx,
327 struct tevent_context *ev,
328 struct rpc_pipe_client *cli,
329 struct policy_handle *_handle /* [in,out] [ref] */)
330 {
331 struct tevent_req *req;
332 struct rpccli_eventlog_CloseEventLog_state *state;
333 struct tevent_req *subreq;
334
335 req = tevent_req_create(mem_ctx, &state,
336 struct rpccli_eventlog_CloseEventLog_state);
337 if (req == NULL) {
338 return NULL;
339 }
340 state->out_mem_ctx = NULL;
341 state->dispatch_recv = cli->dispatch_recv;
342
343 /* In parameters */
344 state->orig.in.handle = _handle;
345
346 /* Out parameters */
347 state->orig.out.handle = _handle;
348
349 /* Result */
350 ZERO_STRUCT(state->orig.out.result);
351
352 if (DEBUGLEVEL >= 10) {
353 NDR_PRINT_IN_DEBUG(eventlog_CloseEventLog, &state->orig);
354 }
355
356 state->out_mem_ctx = talloc_named_const(state, 0,
357 "rpccli_eventlog_CloseEventLog_out_memory");
358 if (tevent_req_nomem(state->out_mem_ctx, req)) {
359 return tevent_req_post(req, ev);
360 }
361
362 /* make a temporary copy, that we pass to the dispatch function */
363 state->tmp = state->orig;
364
365 subreq = cli->dispatch_send(state, ev, cli,
366 &ndr_table_eventlog,
367 NDR_EVENTLOG_CLOSEEVENTLOG,
368 &state->tmp);
369 if (tevent_req_nomem(subreq, req)) {
370 return tevent_req_post(req, ev);
371 }
372 tevent_req_set_callback(subreq, rpccli_eventlog_CloseEventLog_done, req);
373 return req;
374 }
375
376 static void rpccli_eventlog_CloseEventLog_done(struct tevent_req *subreq)
377 {
378 struct tevent_req *req = tevent_req_callback_data(
379 subreq, struct tevent_req);
380 struct rpccli_eventlog_CloseEventLog_state *state = tevent_req_data(
381 req, struct rpccli_eventlog_CloseEventLog_state);
382 NTSTATUS status;
383 TALLOC_CTX *mem_ctx;
384
385 if (state->out_mem_ctx) {
386 mem_ctx = state->out_mem_ctx;
387 } else {
388 mem_ctx = state;
389 }
390
391 status = state->dispatch_recv(subreq, mem_ctx);
392 TALLOC_FREE(subreq);
393 if (!NT_STATUS_IS_OK(status)) {
394 tevent_req_nterror(req, status);
395 return;
396 }
397
398 /* Copy out parameters */
399 *state->orig.out.handle = *state->tmp.out.handle;
400
401 /* Copy result */
402 state->orig.out.result = state->tmp.out.result;
403
404 /* Reset temporary structure */
405 ZERO_STRUCT(state->tmp);
406
407 if (DEBUGLEVEL >= 10) {
408 NDR_PRINT_OUT_DEBUG(eventlog_CloseEventLog, &state->orig);
409 }
410
411 tevent_req_done(req);
412 }
413
414 NTSTATUS rpccli_eventlog_CloseEventLog_recv(struct tevent_req *req,
415 TALLOC_CTX *mem_ctx,
416 NTSTATUS *result)
417 {
418 struct rpccli_eventlog_CloseEventLog_state *state = tevent_req_data(
419 req, struct rpccli_eventlog_CloseEventLog_state);
420 NTSTATUS status;
421
422 if (tevent_req_is_nterror(req, &status)) {
423 tevent_req_received(req);
424 return status;
425 }
426
427 /* Steal possbile out parameters to the callers context */
428 talloc_steal(mem_ctx, state->out_mem_ctx);
429
430 /* Return result */
431 *result = state->orig.out.result;
432
433 tevent_req_received(req);
434 return NT_STATUS_OK;
435 }
436
437 NTSTATUS rpccli_eventlog_CloseEventLog(struct rpc_pipe_client *cli,
438 TALLOC_CTX *mem_ctx,
439 struct policy_handle *handle /* [in,out] [ref] */)
440 {
441 struct eventlog_CloseEventLog r;
442 NTSTATUS status;
443
444 /* In parameters */
445 r.in.handle = handle;
446
447 if (DEBUGLEVEL >= 10) {
448 NDR_PRINT_IN_DEBUG(eventlog_CloseEventLog, &r);
449 }
450
451 status = cli->dispatch(cli,
452 mem_ctx,
453 &ndr_table_eventlog,
454 NDR_EVENTLOG_CLOSEEVENTLOG,
455 &r);
456
457 if (!NT_STATUS_IS_OK(status)) {
458 return status;
459 }
460
461 if (DEBUGLEVEL >= 10) {
462 NDR_PRINT_OUT_DEBUG(eventlog_CloseEventLog, &r);
463 }
464
465 if (NT_STATUS_IS_ERR(status)) {
466 return status;
467 }
468
469 /* Return variables */
470 *handle = *r.out.handle;
471
472 /* Return result */
473 return r.out.result;
474 }
475
476 struct rpccli_eventlog_DeregisterEventSource_state {
477 struct eventlog_DeregisterEventSource orig;
478 struct eventlog_DeregisterEventSource tmp;
479 TALLOC_CTX *out_mem_ctx;
480 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
481 };
482
483 static void rpccli_eventlog_DeregisterEventSource_done(struct tevent_req *subreq);
484
485 struct tevent_req *rpccli_eventlog_DeregisterEventSource_send(TALLOC_CTX *mem_ctx,
486 struct tevent_context *ev,
487 struct rpc_pipe_client *cli,
488 struct policy_handle *_handle /* [in,out] [ref] */)
489 {
490 struct tevent_req *req;
491 struct rpccli_eventlog_DeregisterEventSource_state *state;
492 struct tevent_req *subreq;
493
494 req = tevent_req_create(mem_ctx, &state,
495 struct rpccli_eventlog_DeregisterEventSource_state);
496 if (req == NULL) {
497 return NULL;
498 }
499 state->out_mem_ctx = NULL;
500 state->dispatch_recv = cli->dispatch_recv;
501
502 /* In parameters */
503 state->orig.in.handle = _handle;
504
505 /* Out parameters */
506 state->orig.out.handle = _handle;
507
508 /* Result */
509 ZERO_STRUCT(state->orig.out.result);
510
511 if (DEBUGLEVEL >= 10) {
512 NDR_PRINT_IN_DEBUG(eventlog_DeregisterEventSource, &state->orig);
513 }
514
515 state->out_mem_ctx = talloc_named_const(state, 0,
516 "rpccli_eventlog_DeregisterEventSource_out_memory");
517 if (tevent_req_nomem(state->out_mem_ctx, req)) {
518 return tevent_req_post(req, ev);
519 }
520
521 /* make a temporary copy, that we pass to the dispatch function */
522 state->tmp = state->orig;
523
524 subreq = cli->dispatch_send(state, ev, cli,
525 &ndr_table_eventlog,
526 NDR_EVENTLOG_DEREGISTEREVENTSOURCE,
527 &state->tmp);
528 if (tevent_req_nomem(subreq, req)) {
529 return tevent_req_post(req, ev);
530 }
531 tevent_req_set_callback(subreq, rpccli_eventlog_DeregisterEventSource_done, req);
532 return req;
533 }
534
535 static void rpccli_eventlog_DeregisterEventSource_done(struct tevent_req *subreq)
536 {
537 struct tevent_req *req = tevent_req_callback_data(
538 subreq, struct tevent_req);
539 struct rpccli_eventlog_DeregisterEventSource_state *state = tevent_req_data(
540 req, struct rpccli_eventlog_DeregisterEventSource_state);
541 NTSTATUS status;
542 TALLOC_CTX *mem_ctx;
543
544 if (state->out_mem_ctx) {
545 mem_ctx = state->out_mem_ctx;
546 } else {
547 mem_ctx = state;
548 }
549
550 status = state->dispatch_recv(subreq, mem_ctx);
551 TALLOC_FREE(subreq);
552 if (!NT_STATUS_IS_OK(status)) {
553 tevent_req_nterror(req, status);
554 return;
555 }
556
557 /* Copy out parameters */
558 *state->orig.out.handle = *state->tmp.out.handle;
559
560 /* Copy result */
561 state->orig.out.result = state->tmp.out.result;
562
563 /* Reset temporary structure */
564 ZERO_STRUCT(state->tmp);
565
566 if (DEBUGLEVEL >= 10) {
567 NDR_PRINT_OUT_DEBUG(eventlog_DeregisterEventSource, &state->orig);
568 }
569
570 tevent_req_done(req);
571 }
572
573 NTSTATUS rpccli_eventlog_DeregisterEventSource_recv(struct tevent_req *req,
574 TALLOC_CTX *mem_ctx,
575 NTSTATUS *result)
576 {
577 struct rpccli_eventlog_DeregisterEventSource_state *state = tevent_req_data(
578 req, struct rpccli_eventlog_DeregisterEventSource_state);
579 NTSTATUS status;
580
581 if (tevent_req_is_nterror(req, &status)) {
582 tevent_req_received(req);
583 return status;
584 }
585
586 /* Steal possbile out parameters to the callers context */
587 talloc_steal(mem_ctx, state->out_mem_ctx);
588
589 /* Return result */
590 *result = state->orig.out.result;
591
592 tevent_req_received(req);
593 return NT_STATUS_OK;
594 }
595
596 NTSTATUS rpccli_eventlog_DeregisterEventSource(struct rpc_pipe_client *cli,
597 TALLOC_CTX *mem_ctx,
598 struct policy_handle *handle /* [in,out] [ref] */)
599 {
600 struct eventlog_DeregisterEventSource r;
601 NTSTATUS status;
602
603 /* In parameters */
604 r.in.handle = handle;
605
606 if (DEBUGLEVEL >= 10) {
607 NDR_PRINT_IN_DEBUG(eventlog_DeregisterEventSource, &r);
608 }
609
610 status = cli->dispatch(cli,
611 mem_ctx,
612 &ndr_table_eventlog,
613 NDR_EVENTLOG_DEREGISTEREVENTSOURCE,
614 &r);
615
616 if (!NT_STATUS_IS_OK(status)) {
617 return status;
618 }
619
620 if (DEBUGLEVEL >= 10) {
621 NDR_PRINT_OUT_DEBUG(eventlog_DeregisterEventSource, &r);
622 }
623
624 if (NT_STATUS_IS_ERR(status)) {
625 return status;
626 }
627
628 /* Return variables */
629 *handle = *r.out.handle;
630
631 /* Return result */
632 return r.out.result;
633 }
634
635 struct rpccli_eventlog_GetNumRecords_state {
636 struct eventlog_GetNumRecords orig;
637 struct eventlog_GetNumRecords tmp;
638 TALLOC_CTX *out_mem_ctx;
639 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
640 };
641
642 static void rpccli_eventlog_GetNumRecords_done(struct tevent_req *subreq);
643
644 struct tevent_req *rpccli_eventlog_GetNumRecords_send(TALLOC_CTX *mem_ctx,
645 struct tevent_context *ev,
646 struct rpc_pipe_client *cli,
647 struct policy_handle *_handle /* [in] [ref] */,
648 uint32_t *_number /* [out] [ref] */)
649 {
650 struct tevent_req *req;
651 struct rpccli_eventlog_GetNumRecords_state *state;
652 struct tevent_req *subreq;
653
654 req = tevent_req_create(mem_ctx, &state,
655 struct rpccli_eventlog_GetNumRecords_state);
656 if (req == NULL) {
657 return NULL;
658 }
659 state->out_mem_ctx = NULL;
660 state->dispatch_recv = cli->dispatch_recv;
661
662 /* In parameters */
663 state->orig.in.handle = _handle;
664
665 /* Out parameters */
666 state->orig.out.number = _number;
667
668 /* Result */
669 ZERO_STRUCT(state->orig.out.result);
670
671 if (DEBUGLEVEL >= 10) {
672 NDR_PRINT_IN_DEBUG(eventlog_GetNumRecords, &state->orig);
673 }
674
675 state->out_mem_ctx = talloc_named_const(state, 0,
676 "rpccli_eventlog_GetNumRecords_out_memory");
677 if (tevent_req_nomem(state->out_mem_ctx, req)) {
678 return tevent_req_post(req, ev);
679 }
680
681 /* make a temporary copy, that we pass to the dispatch function */
682 state->tmp = state->orig;
683
684 subreq = cli->dispatch_send(state, ev, cli,
685 &ndr_table_eventlog,
686 NDR_EVENTLOG_GETNUMRECORDS,
687 &state->tmp);
688 if (tevent_req_nomem(subreq, req)) {
689 return tevent_req_post(req, ev);
690 }
691 tevent_req_set_callback(subreq, rpccli_eventlog_GetNumRecords_done, req);
692 return req;
693 }
694
695 static void rpccli_eventlog_GetNumRecords_done(struct tevent_req *subreq)
696 {
697 struct tevent_req *req = tevent_req_callback_data(
698 subreq, struct tevent_req);
699 struct rpccli_eventlog_GetNumRecords_state *state = tevent_req_data(
700 req, struct rpccli_eventlog_GetNumRecords_state);
701 NTSTATUS status;
702 TALLOC_CTX *mem_ctx;
703
704 if (state->out_mem_ctx) {
705 mem_ctx = state->out_mem_ctx;
706 } else {
707 mem_ctx = state;
708 }
709
710 status = state->dispatch_recv(subreq, mem_ctx);
711 TALLOC_FREE(subreq);
712 if (!NT_STATUS_IS_OK(status)) {
713 tevent_req_nterror(req, status);
714 return;
715 }
716
717 /* Copy out parameters */
718 *state->orig.out.number = *state->tmp.out.number;
719
720 /* Copy result */
721 state->orig.out.result = state->tmp.out.result;
722
723 /* Reset temporary structure */
724 ZERO_STRUCT(state->tmp);
725
726 if (DEBUGLEVEL >= 10) {
727 NDR_PRINT_OUT_DEBUG(eventlog_GetNumRecords, &state->orig);
728 }
729
730 tevent_req_done(req);
731 }
732
733 NTSTATUS rpccli_eventlog_GetNumRecords_recv(struct tevent_req *req,
734 TALLOC_CTX *mem_ctx,
735 NTSTATUS *result)
736 {
737 struct rpccli_eventlog_GetNumRecords_state *state = tevent_req_data(
738 req, struct rpccli_eventlog_GetNumRecords_state);
739 NTSTATUS status;
740
741 if (tevent_req_is_nterror(req, &status)) {
742 tevent_req_received(req);
743 return status;
744 }
745
746 /* Steal possbile out parameters to the callers context */
747 talloc_steal(mem_ctx, state->out_mem_ctx);
748
749 /* Return result */
750 *result = state->orig.out.result;
751
752 tevent_req_received(req);
753 return NT_STATUS_OK;
754 }
755
756 NTSTATUS rpccli_eventlog_GetNumRecords(struct rpc_pipe_client *cli,
757 TALLOC_CTX *mem_ctx,
758 struct policy_handle *handle /* [in] [ref] */,
759 uint32_t *number /* [out] [ref] */)
760 {
761 struct eventlog_GetNumRecords r;
762 NTSTATUS status;
763
764 /* In parameters */
765 r.in.handle = handle;
766
767 if (DEBUGLEVEL >= 10) {
768 NDR_PRINT_IN_DEBUG(eventlog_GetNumRecords, &r);
769 }
770
771 status = cli->dispatch(cli,
772 mem_ctx,
773 &ndr_table_eventlog,
774 NDR_EVENTLOG_GETNUMRECORDS,
775 &r);
776
777 if (!NT_STATUS_IS_OK(status)) {
778 return status;
779 }
780
781 if (DEBUGLEVEL >= 10) {
782 NDR_PRINT_OUT_DEBUG(eventlog_GetNumRecords, &r);
783 }
784
785 if (NT_STATUS_IS_ERR(status)) {
786 return status;
787 }
788
789 /* Return variables */
790 *number = *r.out.number;
791
792 /* Return result */
793 return r.out.result;
794 }
795
796 struct rpccli_eventlog_GetOldestRecord_state {
797 struct eventlog_GetOldestRecord orig;
798 struct eventlog_GetOldestRecord tmp;
799 TALLOC_CTX *out_mem_ctx;
800 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
801 };
802
803 static void rpccli_eventlog_GetOldestRecord_done(struct tevent_req *subreq);
804
805 struct tevent_req *rpccli_eventlog_GetOldestRecord_send(TALLOC_CTX *mem_ctx,
806 struct tevent_context *ev,
807 struct rpc_pipe_client *cli,
808 struct policy_handle *_handle /* [in] [ref] */,
809 uint32_t *_oldest_entry /* [out] [ref] */)
810 {
811 struct tevent_req *req;
812 struct rpccli_eventlog_GetOldestRecord_state *state;
813 struct tevent_req *subreq;
814
815 req = tevent_req_create(mem_ctx, &state,
816 struct rpccli_eventlog_GetOldestRecord_state);
817 if (req == NULL) {
818 return NULL;
819 }
820 state->out_mem_ctx = NULL;
821 state->dispatch_recv = cli->dispatch_recv;
822
823 /* In parameters */
824 state->orig.in.handle = _handle;
825
826 /* Out parameters */
827 state->orig.out.oldest_entry = _oldest_entry;
828
829 /* Result */
830 ZERO_STRUCT(state->orig.out.result);
831
832 if (DEBUGLEVEL >= 10) {
833 NDR_PRINT_IN_DEBUG(eventlog_GetOldestRecord, &state->orig);
834 }
835
836 state->out_mem_ctx = talloc_named_const(state, 0,
837 "rpccli_eventlog_GetOldestRecord_out_memory");
838 if (tevent_req_nomem(state->out_mem_ctx, req)) {
839 return tevent_req_post(req, ev);
840 }
841
842 /* make a temporary copy, that we pass to the dispatch function */
843 state->tmp = state->orig;
844
845 subreq = cli->dispatch_send(state, ev, cli,
846 &ndr_table_eventlog,
847 NDR_EVENTLOG_GETOLDESTRECORD,
848 &state->tmp);
849 if (tevent_req_nomem(subreq, req)) {
850 return tevent_req_post(req, ev);
851 }
852 tevent_req_set_callback(subreq, rpccli_eventlog_GetOldestRecord_done, req);
853 return req;
854 }
855
856 static void rpccli_eventlog_GetOldestRecord_done(struct tevent_req *subreq)
857 {
858 struct tevent_req *req = tevent_req_callback_data(
859 subreq, struct tevent_req);
860 struct rpccli_eventlog_GetOldestRecord_state *state = tevent_req_data(
861 req, struct rpccli_eventlog_GetOldestRecord_state);
862 NTSTATUS status;
863 TALLOC_CTX *mem_ctx;
864
865 if (state->out_mem_ctx) {
866 mem_ctx = state->out_mem_ctx;
867 } else {
868 mem_ctx = state;
869 }
870
871 status = state->dispatch_recv(subreq, mem_ctx);
872 TALLOC_FREE(subreq);
873 if (!NT_STATUS_IS_OK(status)) {
874 tevent_req_nterror(req, status);
875 return;
876 }
877
878 /* Copy out parameters */
879 *state->orig.out.oldest_entry = *state->tmp.out.oldest_entry;
880
881 /* Copy result */
882 state->orig.out.result = state->tmp.out.result;
883
884 /* Reset temporary structure */
885 ZERO_STRUCT(state->tmp);
886
887 if (DEBUGLEVEL >= 10) {
888 NDR_PRINT_OUT_DEBUG(eventlog_GetOldestRecord, &state->orig);
889 }
890
891 tevent_req_done(req);
892 }
893
894 NTSTATUS rpccli_eventlog_GetOldestRecord_recv(struct tevent_req *req,
895 TALLOC_CTX *mem_ctx,
896 NTSTATUS *result)
897 {
898 struct rpccli_eventlog_GetOldestRecord_state *state = tevent_req_data(
899 req, struct rpccli_eventlog_GetOldestRecord_state);
900 NTSTATUS status;
901
902 if (tevent_req_is_nterror(req, &status)) {
903 tevent_req_received(req);
904 return status;
905 }
906
907 /* Steal possbile out parameters to the callers context */
908 talloc_steal(mem_ctx, state->out_mem_ctx);
909
910 /* Return result */
911 *result = state->orig.out.result;
912
913 tevent_req_received(req);
914 return NT_STATUS_OK;
915 }
916
917 NTSTATUS rpccli_eventlog_GetOldestRecord(struct rpc_pipe_client *cli,
918 TALLOC_CTX *mem_ctx,
919 struct policy_handle *handle /* [in] [ref] */,
920 uint32_t *oldest_entry /* [out] [ref] */)
921 {
922 struct eventlog_GetOldestRecord r;
923 NTSTATUS status;
924
925 /* In parameters */
926 r.in.handle = handle;
927
928 if (DEBUGLEVEL >= 10) {
929 NDR_PRINT_IN_DEBUG(eventlog_GetOldestRecord, &r);
930 }
931
932 status = cli->dispatch(cli,
933 mem_ctx,
934 &ndr_table_eventlog,
935 NDR_EVENTLOG_GETOLDESTRECORD,
936 &r);
937
938 if (!NT_STATUS_IS_OK(status)) {
939 return status;
940 }
941
942 if (DEBUGLEVEL >= 10) {
943 NDR_PRINT_OUT_DEBUG(eventlog_GetOldestRecord, &r);
944 }
945
946 if (NT_STATUS_IS_ERR(status)) {
947 return status;
948 }
949
950 /* Return variables */
951 *oldest_entry = *r.out.oldest_entry;
952
953 /* Return result */
954 return r.out.result;
955 }
956
957 struct rpccli_eventlog_ChangeNotify_state {
958 struct eventlog_ChangeNotify orig;
959 struct eventlog_ChangeNotify tmp;
960 TALLOC_CTX *out_mem_ctx;
961 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
962 };
963
964 static void rpccli_eventlog_ChangeNotify_done(struct tevent_req *subreq);
965
966 struct tevent_req *rpccli_eventlog_ChangeNotify_send(TALLOC_CTX *mem_ctx,
967 struct tevent_context *ev,
968 struct rpc_pipe_client *cli)
969 {
970 struct tevent_req *req;
971 struct rpccli_eventlog_ChangeNotify_state *state;
972 struct tevent_req *subreq;
973
974 req = tevent_req_create(mem_ctx, &state,
975 struct rpccli_eventlog_ChangeNotify_state);
976 if (req == NULL) {
977 return NULL;
978 }
979 state->out_mem_ctx = NULL;
980 state->dispatch_recv = cli->dispatch_recv;
981
982 /* In parameters */
983
984 /* Out parameters */
985
986 /* Result */
987 ZERO_STRUCT(state->orig.out.result);
988
989 if (DEBUGLEVEL >= 10) {
990 NDR_PRINT_IN_DEBUG(eventlog_ChangeNotify, &state->orig);
991 }
992
993 /* make a temporary copy, that we pass to the dispatch function */
994 state->tmp = state->orig;
995
996 subreq = cli->dispatch_send(state, ev, cli,
997 &ndr_table_eventlog,
998 NDR_EVENTLOG_CHANGENOTIFY,
999 &state->tmp);
1000 if (tevent_req_nomem(subreq, req)) {
1001 return tevent_req_post(req, ev);
1002 }
1003 tevent_req_set_callback(subreq, rpccli_eventlog_ChangeNotify_done, req);
1004 return req;
1005 }
1006
1007 static void rpccli_eventlog_ChangeNotify_done(struct tevent_req *subreq)
1008 {
1009 struct tevent_req *req = tevent_req_callback_data(
1010 subreq, struct tevent_req);
1011 struct rpccli_eventlog_ChangeNotify_state *state = tevent_req_data(
1012 req, struct rpccli_eventlog_ChangeNotify_state);
1013 NTSTATUS status;
1014 TALLOC_CTX *mem_ctx;
1015
1016 if (state->out_mem_ctx) {
1017 mem_ctx = state->out_mem_ctx;
1018 } else {
1019 mem_ctx = state;
1020 }
1021
1022 status = state->dispatch_recv(subreq, mem_ctx);
1023 TALLOC_FREE(subreq);
1024 if (!NT_STATUS_IS_OK(status)) {
1025 tevent_req_nterror(req, status);
1026 return;
1027 }
1028
1029 /* Copy out parameters */
1030
1031 /* Copy result */
1032 state->orig.out.result = state->tmp.out.result;
1033
1034 /* Reset temporary structure */
1035 ZERO_STRUCT(state->tmp);
1036
1037 if (DEBUGLEVEL >= 10) {
1038 NDR_PRINT_OUT_DEBUG(eventlog_ChangeNotify, &state->orig);
1039 }
1040
1041 tevent_req_done(req);
1042 }
1043
1044 NTSTATUS rpccli_eventlog_ChangeNotify_recv(struct tevent_req *req,
1045 TALLOC_CTX *mem_ctx,
1046 NTSTATUS *result)
1047 {
1048 struct rpccli_eventlog_ChangeNotify_state *state = tevent_req_data(
1049 req, struct rpccli_eventlog_ChangeNotify_state);
1050 NTSTATUS status;
1051
1052 if (tevent_req_is_nterror(req, &status)) {
1053 tevent_req_received(req);
1054 return status;
1055 }
1056
1057 /* Steal possbile out parameters to the callers context */
1058 talloc_steal(mem_ctx, state->out_mem_ctx);
1059
1060 /* Return result */
1061 *result = state->orig.out.result;
1062
1063 tevent_req_received(req);
1064 return NT_STATUS_OK;
1065 }
1066
1067 NTSTATUS rpccli_eventlog_ChangeNotify(struct rpc_pipe_client *cli,
1068 TALLOC_CTX *mem_ctx)
1069 {
1070 struct eventlog_ChangeNotify r;
1071 NTSTATUS status;
1072
1073 /* In parameters */
1074
1075 if (DEBUGLEVEL >= 10) {
1076 NDR_PRINT_IN_DEBUG(eventlog_ChangeNotify, &r);
1077 }
1078
1079 status = cli->dispatch(cli,
1080 mem_ctx,
1081 &ndr_table_eventlog,
1082 NDR_EVENTLOG_CHANGENOTIFY,
1083 &r);
1084
1085 if (!NT_STATUS_IS_OK(status)) {
1086 return status;
1087 }
1088
1089 if (DEBUGLEVEL >= 10) {
1090 NDR_PRINT_OUT_DEBUG(eventlog_ChangeNotify, &r);
1091 }
1092
1093 if (NT_STATUS_IS_ERR(status)) {
1094 return status;
1095 }
1096
1097 /* Return variables */
1098
1099 /* Return result */
1100 return r.out.result;
1101 }
1102
1103 struct rpccli_eventlog_OpenEventLogW_state {
1104 struct eventlog_OpenEventLogW orig;
1105 struct eventlog_OpenEventLogW tmp;
1106 TALLOC_CTX *out_mem_ctx;
1107 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
1108 };
1109
1110 static void rpccli_eventlog_OpenEventLogW_done(struct tevent_req *subreq);
1111
1112 struct tevent_req *rpccli_eventlog_OpenEventLogW_send(TALLOC_CTX *mem_ctx,
1113 struct tevent_context *ev,
1114 struct rpc_pipe_client *cli,
1115 struct eventlog_OpenUnknown0 *_unknown0 /* [in] [unique] */,
1116 struct lsa_String *_logname /* [in] [ref] */,
1117 struct lsa_String *_servername /* [in] [ref] */,
1118 uint32_t _major_version /* [in] */,
1119 uint32_t _minor_version /* [in] */,
1120 struct policy_handle *_handle /* [out] [ref] */)
1121 {
1122 struct tevent_req *req;
1123 struct rpccli_eventlog_OpenEventLogW_state *state;
1124 struct tevent_req *subreq;
1125
1126 req = tevent_req_create(mem_ctx, &state,
1127 struct rpccli_eventlog_OpenEventLogW_state);
1128 if (req == NULL) {
1129 return NULL;
1130 }
1131 state->out_mem_ctx = NULL;
1132 state->dispatch_recv = cli->dispatch_recv;
1133
1134 /* In parameters */
1135 state->orig.in.unknown0 = _unknown0;
1136 state->orig.in.logname = _logname;
1137 state->orig.in.servername = _servername;
1138 state->orig.in.major_version = _major_version;
1139 state->orig.in.minor_version = _minor_version;
1140
1141 /* Out parameters */
1142 state->orig.out.handle = _handle;
1143
1144 /* Result */
1145 ZERO_STRUCT(state->orig.out.result);
1146
1147 if (DEBUGLEVEL >= 10) {
1148 NDR_PRINT_IN_DEBUG(eventlog_OpenEventLogW, &state->orig);
1149 }
1150
1151 state->out_mem_ctx = talloc_named_const(state, 0,
1152 "rpccli_eventlog_OpenEventLogW_out_memory");
1153 if (tevent_req_nomem(state->out_mem_ctx, req)) {
1154 return tevent_req_post(req, ev);
1155 }
1156
1157 /* make a temporary copy, that we pass to the dispatch function */
1158 state->tmp = state->orig;
1159
1160 subreq = cli->dispatch_send(state, ev, cli,
1161 &ndr_table_eventlog,
1162 NDR_EVENTLOG_OPENEVENTLOGW,
1163 &state->tmp);
1164 if (tevent_req_nomem(subreq, req)) {
1165 return tevent_req_post(req, ev);
1166 }
1167 tevent_req_set_callback(subreq, rpccli_eventlog_OpenEventLogW_done, req);
1168 return req;
1169 }
1170
1171 static void rpccli_eventlog_OpenEventLogW_done(struct tevent_req *subreq)
1172 {
1173 struct tevent_req *req = tevent_req_callback_data(
1174 subreq, struct tevent_req);
1175 struct rpccli_eventlog_OpenEventLogW_state *state = tevent_req_data(
1176 req, struct rpccli_eventlog_OpenEventLogW_state);
1177 NTSTATUS status;
1178 TALLOC_CTX *mem_ctx;
1179
1180 if (state->out_mem_ctx) {
1181 mem_ctx = state->out_mem_ctx;
1182 } else {
1183 mem_ctx = state;
1184 }
1185
1186 status = state->dispatch_recv(subreq, mem_ctx);
1187 TALLOC_FREE(subreq);
1188 if (!NT_STATUS_IS_OK(status)) {
1189 tevent_req_nterror(req, status);
1190 return;
1191 }
1192
1193 /* Copy out parameters */
1194 *state->orig.out.handle = *state->tmp.out.handle;
1195
1196 /* Copy result */
1197 state->orig.out.result = state->tmp.out.result;
1198
1199 /* Reset temporary structure */
1200 ZERO_STRUCT(state->tmp);
1201
1202 if (DEBUGLEVEL >= 10) {
1203 NDR_PRINT_OUT_DEBUG(eventlog_OpenEventLogW, &state->orig);
1204 }
1205
1206 tevent_req_done(req);
1207 }
1208
1209 NTSTATUS rpccli_eventlog_OpenEventLogW_recv(struct tevent_req *req,
1210 TALLOC_CTX *mem_ctx,
1211 NTSTATUS *result)
1212 {
1213 struct rpccli_eventlog_OpenEventLogW_state *state = tevent_req_data(
1214 req, struct rpccli_eventlog_OpenEventLogW_state);
1215 NTSTATUS status;
1216
1217 if (tevent_req_is_nterror(req, &status)) {
1218 tevent_req_received(req);
1219 return status;
1220 }
1221
1222 /* Steal possbile out parameters to the callers context */
1223 talloc_steal(mem_ctx, state->out_mem_ctx);
1224
1225 /* Return result */
1226 *result = state->orig.out.result;
1227
1228 tevent_req_received(req);
1229 return NT_STATUS_OK;
1230 }
1231
1232 NTSTATUS rpccli_eventlog_OpenEventLogW(struct rpc_pipe_client *cli,
1233 TALLOC_CTX *mem_ctx,
1234 struct eventlog_OpenUnknown0 *unknown0 /* [in] [unique] */,
1235 struct lsa_String *logname /* [in] [ref] */,
1236 struct lsa_String *servername /* [in] [ref] */,
1237 uint32_t major_version /* [in] */,
1238 uint32_t minor_version /* [in] */,
1239 struct policy_handle *handle /* [out] [ref] */)
1240 {
1241 struct eventlog_OpenEventLogW r;
1242 NTSTATUS status;
1243
1244 /* In parameters */
1245 r.in.unknown0 = unknown0;
1246 r.in.logname = logname;
1247 r.in.servername = servername;
1248 r.in.major_version = major_version;
1249 r.in.minor_version = minor_version;
1250
1251 if (DEBUGLEVEL >= 10) {
1252 NDR_PRINT_IN_DEBUG(eventlog_OpenEventLogW, &r);
1253 }
1254
1255 status = cli->dispatch(cli,
1256 mem_ctx,
1257 &ndr_table_eventlog,
1258 NDR_EVENTLOG_OPENEVENTLOGW,
1259 &r);
1260
1261 if (!NT_STATUS_IS_OK(status)) {
1262 return status;
1263 }
1264
1265 if (DEBUGLEVEL >= 10) {
1266 NDR_PRINT_OUT_DEBUG(eventlog_OpenEventLogW, &r);
1267 }
1268
1269 if (NT_STATUS_IS_ERR(status)) {
1270 return status;
1271 }
1272
1273 /* Return variables */
1274 *handle = *r.out.handle;
1275
1276 /* Return result */
1277 return r.out.result;
1278 }
1279
1280 struct rpccli_eventlog_RegisterEventSourceW_state {
1281 struct eventlog_RegisterEventSourceW orig;
1282 struct eventlog_RegisterEventSourceW tmp;
1283 TALLOC_CTX *out_mem_ctx;
1284 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
1285 };
1286
1287 static void rpccli_eventlog_RegisterEventSourceW_done(struct tevent_req *subreq);
1288
1289 struct tevent_req *rpccli_eventlog_RegisterEventSourceW_send(TALLOC_CTX *mem_ctx,
1290 struct tevent_context *ev,
1291 struct rpc_pipe_client *cli,
1292 struct eventlog_OpenUnknown0 *_unknown0 /* [in] [unique] */,
1293 struct lsa_String *_module_name /* [in] [ref] */,
1294 struct lsa_String *_reg_module_name /* [in] [ref] */,
1295 uint32_t _major_version /* [in] */,
1296 uint32_t _minor_version /* [in] */,
1297 struct policy_handle *_log_handle /* [out] [ref] */)
1298 {
1299 struct tevent_req *req;
1300 struct rpccli_eventlog_RegisterEventSourceW_state *state;
1301 struct tevent_req *subreq;
1302
1303 req = tevent_req_create(mem_ctx, &state,
1304 struct rpccli_eventlog_RegisterEventSourceW_state);
1305 if (req == NULL) {
1306 return NULL;
1307 }
1308 state->out_mem_ctx = NULL;
1309 state->dispatch_recv = cli->dispatch_recv;
1310
1311 /* In parameters */
1312 state->orig.in.unknown0 = _unknown0;
1313 state->orig.in.module_name = _module_name;
1314 state->orig.in.reg_module_name = _reg_module_name;
1315 state->orig.in.major_version = _major_version;
1316 state->orig.in.minor_version = _minor_version;
1317
1318 /* Out parameters */
1319 state->orig.out.log_handle = _log_handle;
1320
1321 /* Result */
1322 ZERO_STRUCT(state->orig.out.result);
1323
1324 if (DEBUGLEVEL >= 10) {
1325 NDR_PRINT_IN_DEBUG(eventlog_RegisterEventSourceW, &state->orig);
1326 }
1327
1328 state->out_mem_ctx = talloc_named_const(state, 0,
1329 "rpccli_eventlog_RegisterEventSourceW_out_memory");
1330 if (tevent_req_nomem(state->out_mem_ctx, req)) {
1331 return tevent_req_post(req, ev);
1332 }
1333
1334 /* make a temporary copy, that we pass to the dispatch function */
1335 state->tmp = state->orig;
1336
1337 subreq = cli->dispatch_send(state, ev, cli,
1338 &ndr_table_eventlog,
1339 NDR_EVENTLOG_REGISTEREVENTSOURCEW,
1340 &state->tmp);
1341 if (tevent_req_nomem(subreq, req)) {
1342 return tevent_req_post(req, ev);
1343 }
1344 tevent_req_set_callback(subreq, rpccli_eventlog_RegisterEventSourceW_done, req);
1345 return req;
1346 }
1347
1348 static void rpccli_eventlog_RegisterEventSourceW_done(struct tevent_req *subreq)
1349 {
1350 struct tevent_req *req = tevent_req_callback_data(
1351 subreq, struct tevent_req);
1352 struct rpccli_eventlog_RegisterEventSourceW_state *state = tevent_req_data(
1353 req, struct rpccli_eventlog_RegisterEventSourceW_state);
1354 NTSTATUS status;
1355 TALLOC_CTX *mem_ctx;
1356
1357 if (state->out_mem_ctx) {
1358 mem_ctx = state->out_mem_ctx;
1359 } else {
1360 mem_ctx = state;
1361 }
1362
1363 status = state->dispatch_recv(subreq, mem_ctx);
1364 TALLOC_FREE(subreq);
1365 if (!NT_STATUS_IS_OK(status)) {
1366 tevent_req_nterror(req, status);
1367 return;
1368 }
1369
1370 /* Copy out parameters */
1371 *state->orig.out.log_handle = *state->tmp.out.log_handle;
1372
1373 /* Copy result */
1374 state->orig.out.result = state->tmp.out.result;
1375
1376 /* Reset temporary structure */
1377 ZERO_STRUCT(state->tmp);
1378
1379 if (DEBUGLEVEL >= 10) {
1380 NDR_PRINT_OUT_DEBUG(eventlog_RegisterEventSourceW, &state->orig);
1381 }
1382
1383 tevent_req_done(req);
1384 }
1385
1386 NTSTATUS rpccli_eventlog_RegisterEventSourceW_recv(struct tevent_req *req,
1387 TALLOC_CTX *mem_ctx,
1388 NTSTATUS *result)
1389 {
1390 struct rpccli_eventlog_RegisterEventSourceW_state *state = tevent_req_data(
1391 req, struct rpccli_eventlog_RegisterEventSourceW_state);
1392 NTSTATUS status;
1393
1394 if (tevent_req_is_nterror(req, &status)) {
1395 tevent_req_received(req);
1396 return status;
1397 }
1398
1399 /* Steal possbile out parameters to the callers context */
1400 talloc_steal(mem_ctx, state->out_mem_ctx);
1401
1402 /* Return result */
1403 *result = state->orig.out.result;
1404
1405 tevent_req_received(req);
1406 return NT_STATUS_OK;
1407 }
1408
1409 NTSTATUS rpccli_eventlog_RegisterEventSourceW(struct rpc_pipe_client *cli,
1410 TALLOC_CTX *mem_ctx,
1411 struct eventlog_OpenUnknown0 *unknown0 /* [in] [unique] */,
1412 struct lsa_String *module_name /* [in] [ref] */,
1413 struct lsa_String *reg_module_name /* [in] [ref] */,
1414 uint32_t major_version /* [in] */,
1415 uint32_t minor_version /* [in] */,
1416 struct policy_handle *log_handle /* [out] [ref] */)
1417 {
1418 struct eventlog_RegisterEventSourceW r;
1419 NTSTATUS status;
1420
1421 /* In parameters */
1422 r.in.unknown0 = unknown0;
1423 r.in.module_name = module_name;
1424 r.in.reg_module_name = reg_module_name;
1425 r.in.major_version = major_version;
1426 r.in.minor_version = minor_version;
1427
1428 if (DEBUGLEVEL >= 10) {
1429 NDR_PRINT_IN_DEBUG(eventlog_RegisterEventSourceW, &r);
1430 }
1431
1432 status = cli->dispatch(cli,
1433 mem_ctx,
1434 &ndr_table_eventlog,
1435 NDR_EVENTLOG_REGISTEREVENTSOURCEW,
1436 &r);
1437
1438 if (!NT_STATUS_IS_OK(status)) {
1439 return status;
1440 }
1441
1442 if (DEBUGLEVEL >= 10) {
1443 NDR_PRINT_OUT_DEBUG(eventlog_RegisterEventSourceW, &r);
1444 }
1445
1446 if (NT_STATUS_IS_ERR(status)) {
1447 return status;
1448 }
1449
1450 /* Return variables */
1451 *log_handle = *r.out.log_handle;
1452
1453 /* Return result */
1454 return r.out.result;
1455 }
1456
1457 struct rpccli_eventlog_OpenBackupEventLogW_state {
1458 struct eventlog_OpenBackupEventLogW orig;
1459 struct eventlog_OpenBackupEventLogW tmp;
1460 TALLOC_CTX *out_mem_ctx;
1461 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
1462 };
1463
1464 static void rpccli_eventlog_OpenBackupEventLogW_done(struct tevent_req *subreq);
1465
1466 struct tevent_req *rpccli_eventlog_OpenBackupEventLogW_send(TALLOC_CTX *mem_ctx,
1467 struct tevent_context *ev,
1468 struct rpc_pipe_client *cli,
1469 struct eventlog_OpenUnknown0 *_unknown0 /* [in] [unique] */,
1470 struct lsa_String *_backup_logname /* [in] [ref] */,
1471 uint32_t _major_version /* [in] */,
1472 uint32_t _minor_version /* [in] */,
1473 struct policy_handle *_handle /* [out] [ref] */)
1474 {
1475 struct tevent_req *req;
1476 struct rpccli_eventlog_OpenBackupEventLogW_state *state;
1477 struct tevent_req *subreq;
1478
1479 req = tevent_req_create(mem_ctx, &state,
1480 struct rpccli_eventlog_OpenBackupEventLogW_state);
1481 if (req == NULL) {
1482 return NULL;
1483 }
1484 state->out_mem_ctx = NULL;
1485 state->dispatch_recv = cli->dispatch_recv;
1486
1487 /* In parameters */
1488 state->orig.in.unknown0 = _unknown0;
1489 state->orig.in.backup_logname = _backup_logname;
1490 state->orig.in.major_version = _major_version;
1491 state->orig.in.minor_version = _minor_version;
1492
1493 /* Out parameters */
1494 state->orig.out.handle = _handle;
1495
1496 /* Result */
1497 ZERO_STRUCT(state->orig.out.result);
1498
1499 if (DEBUGLEVEL >= 10) {
1500 NDR_PRINT_IN_DEBUG(eventlog_OpenBackupEventLogW, &state->orig);
1501 }
1502
1503 state->out_mem_ctx = talloc_named_const(state, 0,
1504 "rpccli_eventlog_OpenBackupEventLogW_out_memory");
1505 if (tevent_req_nomem(state->out_mem_ctx, req)) {
1506 return tevent_req_post(req, ev);
1507 }
1508
1509 /* make a temporary copy, that we pass to the dispatch function */
1510 state->tmp = state->orig;
1511
1512 subreq = cli->dispatch_send(state, ev, cli,
1513 &ndr_table_eventlog,
1514 NDR_EVENTLOG_OPENBACKUPEVENTLOGW,
1515 &state->tmp);
1516 if (tevent_req_nomem(subreq, req)) {
1517 return tevent_req_post(req, ev);
1518 }
1519 tevent_req_set_callback(subreq, rpccli_eventlog_OpenBackupEventLogW_done, req);
1520 return req;
1521 }
1522
1523 static void rpccli_eventlog_OpenBackupEventLogW_done(struct tevent_req *subreq)
1524 {
1525 struct tevent_req *req = tevent_req_callback_data(
1526 subreq, struct tevent_req);
1527 struct rpccli_eventlog_OpenBackupEventLogW_state *state = tevent_req_data(
1528 req, struct rpccli_eventlog_OpenBackupEventLogW_state);
1529 NTSTATUS status;
1530 TALLOC_CTX *mem_ctx;
1531
1532 if (state->out_mem_ctx) {
1533 mem_ctx = state->out_mem_ctx;
1534 } else {
1535 mem_ctx = state;
1536 }
1537
1538 status = state->dispatch_recv(subreq, mem_ctx);
1539 TALLOC_FREE(subreq);
1540 if (!NT_STATUS_IS_OK(status)) {
1541 tevent_req_nterror(req, status);
1542 return;
1543 }
1544
1545 /* Copy out parameters */
1546 *state->orig.out.handle = *state->tmp.out.handle;
1547
1548 /* Copy result */
1549 state->orig.out.result = state->tmp.out.result;
1550
1551 /* Reset temporary structure */
1552 ZERO_STRUCT(state->tmp);
1553
1554 if (DEBUGLEVEL >= 10) {
1555 NDR_PRINT_OUT_DEBUG(eventlog_OpenBackupEventLogW, &state->orig);
1556 }
1557
1558 tevent_req_done(req);
1559 }
1560
1561 NTSTATUS rpccli_eventlog_OpenBackupEventLogW_recv(struct tevent_req *req,
1562 TALLOC_CTX *mem_ctx,
1563 NTSTATUS *result)
1564 {
1565 struct rpccli_eventlog_OpenBackupEventLogW_state *state = tevent_req_data(
1566 req, struct rpccli_eventlog_OpenBackupEventLogW_state);
1567 NTSTATUS status;
1568
1569 if (tevent_req_is_nterror(req, &status)) {
1570 tevent_req_received(req);
1571 return status;
1572 }
1573
1574 /* Steal possbile out parameters to the callers context */
1575 talloc_steal(mem_ctx, state->out_mem_ctx);
1576
1577 /* Return result */
1578 *result = state->orig.out.result;
1579
1580 tevent_req_received(req);
1581 return NT_STATUS_OK;
1582 }
1583
1584 NTSTATUS rpccli_eventlog_OpenBackupEventLogW(struct rpc_pipe_client *cli,
1585 TALLOC_CTX *mem_ctx,
1586 struct eventlog_OpenUnknown0 *unknown0 /* [in] [unique] */,
1587 struct lsa_String *backup_logname /* [in] [ref] */,
1588 uint32_t major_version /* [in] */,
1589 uint32_t minor_version /* [in] */,
1590 struct policy_handle *handle /* [out] [ref] */)
1591 {
1592 struct eventlog_OpenBackupEventLogW r;
1593 NTSTATUS status;
1594
1595 /* In parameters */
1596 r.in.unknown0 = unknown0;
1597 r.in.backup_logname = backup_logname;
1598 r.in.major_version = major_version;
1599 r.in.minor_version = minor_version;
1600
1601 if (DEBUGLEVEL >= 10) {
1602 NDR_PRINT_IN_DEBUG(eventlog_OpenBackupEventLogW, &r);
1603 }
1604
1605 status = cli->dispatch(cli,
1606 mem_ctx,
1607 &ndr_table_eventlog,
1608 NDR_EVENTLOG_OPENBACKUPEVENTLOGW,
1609 &r);
1610
1611 if (!NT_STATUS_IS_OK(status)) {
1612 return status;
1613 }
1614
1615 if (DEBUGLEVEL >= 10) {
1616 NDR_PRINT_OUT_DEBUG(eventlog_OpenBackupEventLogW, &r);
1617 }
1618
1619 if (NT_STATUS_IS_ERR(status)) {
1620 return status;
1621 }
1622
1623 /* Return variables */
1624 *handle = *r.out.handle;
1625
1626 /* Return result */
1627 return r.out.result;
1628 }
1629
1630 struct rpccli_eventlog_ReadEventLogW_state {
1631 struct eventlog_ReadEventLogW orig;
1632 struct eventlog_ReadEventLogW tmp;
1633 TALLOC_CTX *out_mem_ctx;
1634 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
1635 };
1636
1637 static void rpccli_eventlog_ReadEventLogW_done(struct tevent_req *subreq);
1638
1639 struct tevent_req *rpccli_eventlog_ReadEventLogW_send(TALLOC_CTX *mem_ctx,
1640 struct tevent_context *ev,
1641 struct rpc_pipe_client *cli,
1642 struct policy_handle *_handle /* [in] [ref] */,
1643 uint32_t _flags /* [in] */,
1644 uint32_t _offset /* [in] */,
1645 uint32_t _number_of_bytes /* [in] [range(0,0x7FFFF)] */,
1646 uint8_t *_data /* [out] [ref,size_is(number_of_bytes)] */,
1647 uint32_t *_sent_size /* [out] [ref] */,
1648 uint32_t *_real_size /* [out] [ref] */)
1649 {
1650 struct tevent_req *req;
1651 struct rpccli_eventlog_ReadEventLogW_state *state;
1652 struct tevent_req *subreq;
1653
1654 req = tevent_req_create(mem_ctx, &state,
1655 struct rpccli_eventlog_ReadEventLogW_state);
1656 if (req == NULL) {
1657 return NULL;
1658 }
1659 state->out_mem_ctx = NULL;
1660 state->dispatch_recv = cli->dispatch_recv;
1661
1662 /* In parameters */
1663 state->orig.in.handle = _handle;
1664 state->orig.in.flags = _flags;
1665 state->orig.in.offset = _offset;
1666 state->orig.in.number_of_bytes = _number_of_bytes;
1667
1668 /* Out parameters */
1669 state->orig.out.data = _data;
1670 state->orig.out.sent_size = _sent_size;
1671 state->orig.out.real_size = _real_size;
1672
1673 /* Result */
1674 ZERO_STRUCT(state->orig.out.result);
1675
1676 if (DEBUGLEVEL >= 10) {
1677 NDR_PRINT_IN_DEBUG(eventlog_ReadEventLogW, &state->orig);
1678 }
1679
1680 state->out_mem_ctx = talloc_named_const(state, 0,
1681 "rpccli_eventlog_ReadEventLogW_out_memory");
1682 if (tevent_req_nomem(state->out_mem_ctx, req)) {
1683 return tevent_req_post(req, ev);
1684 }
1685
1686 /* make a temporary copy, that we pass to the dispatch function */
1687 state->tmp = state->orig;
1688
1689 subreq = cli->dispatch_send(state, ev, cli,
1690 &ndr_table_eventlog,
1691 NDR_EVENTLOG_READEVENTLOGW,
1692 &state->tmp);
1693 if (tevent_req_nomem(subreq, req)) {
1694 return tevent_req_post(req, ev);
1695 }
1696 tevent_req_set_callback(subreq, rpccli_eventlog_ReadEventLogW_done, req);
1697 return req;
1698 }
1699
1700 static void rpccli_eventlog_ReadEventLogW_done(struct tevent_req *subreq)
1701 {
1702 struct tevent_req *req = tevent_req_callback_data(
1703 subreq, struct tevent_req);
1704 struct rpccli_eventlog_ReadEventLogW_state *state = tevent_req_data(
1705 req, struct rpccli_eventlog_ReadEventLogW_state);
1706 NTSTATUS status;
1707 TALLOC_CTX *mem_ctx;
1708
1709 if (state->out_mem_ctx) {
1710 mem_ctx = state->out_mem_ctx;
1711 } else {
1712 mem_ctx = state;
1713 }
1714
1715 status = state->dispatch_recv(subreq, mem_ctx);
1716 TALLOC_FREE(subreq);
1717 if (!NT_STATUS_IS_OK(status)) {
1718 tevent_req_nterror(req, status);
1719 return;
1720 }
1721
1722 /* Copy out parameters */
1723 memcpy(state->orig.out.data, state->tmp.out.data, state->tmp.in.number_of_bytes * sizeof(*state->orig.out.data));
1724 *state->orig.out.sent_size = *state->tmp.out.sent_size;
1725 *state->orig.out.real_size = *state->tmp.out.real_size;
1726
1727 /* Copy result */
1728 state->orig.out.result = state->tmp.out.result;
1729
1730 /* Reset temporary structure */
1731 ZERO_STRUCT(state->tmp);
1732
1733 if (DEBUGLEVEL >= 10) {
1734 NDR_PRINT_OUT_DEBUG(eventlog_ReadEventLogW, &state->orig);
1735 }
1736
1737 tevent_req_done(req);
1738 }
1739
1740 NTSTATUS rpccli_eventlog_ReadEventLogW_recv(struct tevent_req *req,
1741 TALLOC_CTX *mem_ctx,
1742 NTSTATUS *result)
1743 {
1744 struct rpccli_eventlog_ReadEventLogW_state *state = tevent_req_data(
1745 req, struct rpccli_eventlog_ReadEventLogW_state);
1746 NTSTATUS status;
1747
1748 if (tevent_req_is_nterror(req, &status)) {
1749 tevent_req_received(req);
1750 return status;
1751 }
1752
1753 /* Steal possbile out parameters to the callers context */
1754 talloc_steal(mem_ctx, state->out_mem_ctx);
1755
1756 /* Return result */
1757 *result = state->orig.out.result;
1758
1759 tevent_req_received(req);
1760 return NT_STATUS_OK;
1761 }
1762
1763 NTSTATUS rpccli_eventlog_ReadEventLogW(struct rpc_pipe_client *cli,
1764 TALLOC_CTX *mem_ctx,
1765 struct policy_handle *handle /* [in] [ref] */,
1766 uint32_t flags /* [in] */,
1767 uint32_t offset /* [in] */,
1768 uint32_t number_of_bytes /* [in] [range(0,0x7FFFF)] */,
1769 uint8_t *data /* [out] [ref,size_is(number_of_bytes)] */,
1770 uint32_t *sent_size /* [out] [ref] */,
1771 uint32_t *real_size /* [out] [ref] */)
1772 {
1773 struct eventlog_ReadEventLogW r;
1774 NTSTATUS status;
1775
1776 /* In parameters */
1777 r.in.handle = handle;
1778 r.in.flags = flags;
1779 r.in.offset = offset;
1780 r.in.number_of_bytes = number_of_bytes;
1781
1782 if (DEBUGLEVEL >= 10) {
1783 NDR_PRINT_IN_DEBUG(eventlog_ReadEventLogW, &r);
1784 }
1785
1786 status = cli->dispatch(cli,
1787 mem_ctx,
1788 &ndr_table_eventlog,
1789 NDR_EVENTLOG_READEVENTLOGW,
1790 &r);
1791
1792 if (!NT_STATUS_IS_OK(status)) {
1793 return status;
1794 }
1795
1796 if (DEBUGLEVEL >= 10) {
1797 NDR_PRINT_OUT_DEBUG(eventlog_ReadEventLogW, &r);
1798 }
1799
1800 if (NT_STATUS_IS_ERR(status)) {
1801 return status;
1802 }
1803
1804 /* Return variables */
1805 memcpy(data, r.out.data, r.in.number_of_bytes * sizeof(*data));
1806 *sent_size = *r.out.sent_size;
1807 *real_size = *r.out.real_size;
1808
1809 /* Return result */
1810 return r.out.result;
1811 }
1812
1813 struct rpccli_eventlog_ReportEventW_state {
1814 struct eventlog_ReportEventW orig;
1815 struct eventlog_ReportEventW tmp;
1816 TALLOC_CTX *out_mem_ctx;
1817 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
1818 };
1819
1820 static void rpccli_eventlog_ReportEventW_done(struct tevent_req *subreq);
1821
1822 struct tevent_req *rpccli_eventlog_ReportEventW_send(TALLOC_CTX *mem_ctx,
1823 struct tevent_context *ev,
1824 struct rpc_pipe_client *cli,
1825 struct policy_handle *_handle /* [in] [ref] */,
1826 time_t _timestamp /* [in] */,
1827 enum eventlogEventTypes _event_type /* [in] */,
1828 uint16_t _event_category /* [in] */,
1829 uint32_t _event_id /* [in] */,
1830 uint16_t _num_of_strings /* [in] [range(0,256)] */,
1831 uint32_t _data_size /* [in] [range(0,0x3FFFF)] */,
1832 struct lsa_String *_servername /* [in] [ref] */,
1833 struct dom_sid *_user_sid /* [in] [unique] */,
1834 struct lsa_String **_strings /* [in] [unique,size_is(num_of_strings)] */,
1835 uint8_t *_data /* [in] [unique,size_is(data_size)] */,
1836 uint16_t _flags /* [in] */,
1837 uint32_t *_record_number /* [in,out] [unique] */,
1838 time_t *_time_written /* [in,out] [unique] */)
1839 {
1840 struct tevent_req *req;
1841 struct rpccli_eventlog_ReportEventW_state *state;
1842 struct tevent_req *subreq;
1843
1844 req = tevent_req_create(mem_ctx, &state,
1845 struct rpccli_eventlog_ReportEventW_state);
1846 if (req == NULL) {
1847 return NULL;
1848 }
1849 state->out_mem_ctx = NULL;
1850 state->dispatch_recv = cli->dispatch_recv;
1851
1852 /* In parameters */
1853 state->orig.in.handle = _handle;
1854 state->orig.in.timestamp = _timestamp;
1855 state->orig.in.event_type = _event_type;
1856 state->orig.in.event_category = _event_category;
1857 state->orig.in.event_id = _event_id;
1858 state->orig.in.num_of_strings = _num_of_strings;
1859 state->orig.in.data_size = _data_size;
1860 state->orig.in.servername = _servername;
1861 state->orig.in.user_sid = _user_sid;
1862 state->orig.in.strings = _strings;
1863 state->orig.in.data = _data;
1864 state->orig.in.flags = _flags;
1865 state->orig.in.record_number = _record_number;
1866 state->orig.in.time_written = _time_written;
1867
1868 /* Out parameters */
1869 state->orig.out.record_number = _record_number;
1870 state->orig.out.time_written = _time_written;
1871
1872 /* Result */
1873 ZERO_STRUCT(state->orig.out.result);
1874
1875 if (DEBUGLEVEL >= 10) {
1876 NDR_PRINT_IN_DEBUG(eventlog_ReportEventW, &state->orig);
1877 }
1878
1879 state->out_mem_ctx = talloc_named_const(state, 0,
1880 "rpccli_eventlog_ReportEventW_out_memory");
1881 if (tevent_req_nomem(state->out_mem_ctx, req)) {
1882 return tevent_req_post(req, ev);
1883 }
1884
1885 /* make a temporary copy, that we pass to the dispatch function */
1886 state->tmp = state->orig;
1887
1888 subreq = cli->dispatch_send(state, ev, cli,
1889 &ndr_table_eventlog,
1890 NDR_EVENTLOG_REPORTEVENTW,
1891 &state->tmp);
1892 if (tevent_req_nomem(subreq, req)) {
1893 return tevent_req_post(req, ev);
1894 }
1895 tevent_req_set_callback(subreq, rpccli_eventlog_ReportEventW_done, req);
1896 return req;
1897 }
1898
1899 static void rpccli_eventlog_ReportEventW_done(struct tevent_req *subreq)
1900 {
1901 struct tevent_req *req = tevent_req_callback_data(
1902 subreq, struct tevent_req);
1903 struct rpccli_eventlog_ReportEventW_state *state = tevent_req_data(
1904 req, struct rpccli_eventlog_ReportEventW_state);
1905 NTSTATUS status;
1906 TALLOC_CTX *mem_ctx;
1907
1908 if (state->out_mem_ctx) {
1909 mem_ctx = state->out_mem_ctx;
1910 } else {
1911 mem_ctx = state;
1912 }
1913
1914 status = state->dispatch_recv(subreq, mem_ctx);
1915 TALLOC_FREE(subreq);
1916 if (!NT_STATUS_IS_OK(status)) {
1917 tevent_req_nterror(req, status);
1918 return;
1919 }
1920
1921 /* Copy out parameters */
1922 if (state->orig.out.record_number && state->tmp.out.record_number) {
1923 *state->orig.out.record_number = *state->tmp.out.record_number;
1924 }
1925 if (state->orig.out.time_written && state->tmp.out.time_written) {
1926 *state->orig.out.time_written = *state->tmp.out.time_written;
1927 }
1928
1929 /* Copy result */
1930 state->orig.out.result = state->tmp.out.result;
1931
1932 /* Reset temporary structure */
1933 ZERO_STRUCT(state->tmp);
1934
1935 if (DEBUGLEVEL >= 10) {
1936 NDR_PRINT_OUT_DEBUG(eventlog_ReportEventW, &state->orig);
1937 }
1938
1939 tevent_req_done(req);
1940 }
1941
1942 NTSTATUS rpccli_eventlog_ReportEventW_recv(struct tevent_req *req,
1943 TALLOC_CTX *mem_ctx,
1944 NTSTATUS *result)
1945 {
1946 struct rpccli_eventlog_ReportEventW_state *state = tevent_req_data(
1947 req, struct rpccli_eventlog_ReportEventW_state);
1948 NTSTATUS status;
1949
1950 if (tevent_req_is_nterror(req, &status)) {
1951 tevent_req_received(req);
1952 return status;
1953 }
1954
1955 /* Steal possbile out parameters to the callers context */
1956 talloc_steal(mem_ctx, state->out_mem_ctx);
1957
1958 /* Return result */
1959 *result = state->orig.out.result;
1960
1961 tevent_req_received(req);
1962 return NT_STATUS_OK;
1963 }
1964
1965 NTSTATUS rpccli_eventlog_ReportEventW(struct rpc_pipe_client *cli,
1966 TALLOC_CTX *mem_ctx,
1967 struct policy_handle *handle /* [in] [ref] */,
1968 time_t timestamp /* [in] */,
1969 enum eventlogEventTypes event_type /* [in] */,
1970 uint16_t event_category /* [in] */,
1971 uint32_t event_id /* [in] */,
1972 uint16_t num_of_strings /* [in] [range(0,256)] */,
1973 uint32_t data_size /* [in] [range(0,0x3FFFF)] */,
1974 struct lsa_String *servername /* [in] [ref] */,
1975 struct dom_sid *user_sid /* [in] [unique] */,
1976 struct lsa_String **strings /* [in] [unique,size_is(num_of_strings)] */,
1977 uint8_t *data /* [in] [unique,size_is(data_size)] */,
1978 uint16_t flags /* [in] */,
1979 uint32_t *record_number /* [in,out] [unique] */,
1980 time_t *time_written /* [in,out] [unique] */)
1981 {
1982 struct eventlog_ReportEventW r;
1983 NTSTATUS status;
1984
1985 /* In parameters */
1986 r.in.handle = handle;
1987 r.in.timestamp = timestamp;
1988 r.in.event_type = event_type;
1989 r.in.event_category = event_category;
1990 r.in.event_id = event_id;
1991 r.in.num_of_strings = num_of_strings;
1992 r.in.data_size = data_size;
1993 r.in.servername = servername;
1994 r.in.user_sid = user_sid;
1995 r.in.strings = strings;
1996 r.in.data = data;
1997 r.in.flags = flags;
1998 r.in.record_number = record_number;
1999 r.in.time_written = time_written;
2000
2001 if (DEBUGLEVEL >= 10) {
2002 NDR_PRINT_IN_DEBUG(eventlog_ReportEventW, &r);
2003 }
2004
2005 status = cli->dispatch(cli,
2006 mem_ctx,
2007 &ndr_table_eventlog,
2008 NDR_EVENTLOG_REPORTEVENTW,
2009 &r);
2010
2011 if (!NT_STATUS_IS_OK(status)) {
2012 return status;
2013 }
2014
2015 if (DEBUGLEVEL >= 10) {
2016 NDR_PRINT_OUT_DEBUG(eventlog_ReportEventW, &r);
2017 }
2018
2019 if (NT_STATUS_IS_ERR(status)) {
2020 return status;
2021 }
2022
2023 /* Return variables */
2024 if (record_number && r.out.record_number) {
2025 *record_number = *r.out.record_number;
2026 }
2027 if (time_written && r.out.time_written) {
2028 *time_written = *r.out.time_written;
2029 }
2030
2031 /* Return result */
2032 return r.out.result;
2033 }
2034
2035 struct rpccli_eventlog_ClearEventLogA_state {
2036 struct eventlog_ClearEventLogA orig;
2037 struct eventlog_ClearEventLogA tmp;
2038 TALLOC_CTX *out_mem_ctx;
2039 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
2040 };
2041
2042 static void rpccli_eventlog_ClearEventLogA_done(struct tevent_req *subreq);
2043
2044 struct tevent_req *rpccli_eventlog_ClearEventLogA_send(TALLOC_CTX *mem_ctx,
2045 struct tevent_context *ev,
2046 struct rpc_pipe_client *cli)
2047 {
2048 struct tevent_req *req;
2049 struct rpccli_eventlog_ClearEventLogA_state *state;
2050 struct tevent_req *subreq;
2051
2052 req = tevent_req_create(mem_ctx, &state,
2053 struct rpccli_eventlog_ClearEventLogA_state);
2054 if (req == NULL) {
2055 return NULL;
2056 }
2057 state->out_mem_ctx = NULL;
2058 state->dispatch_recv = cli->dispatch_recv;
2059
2060 /* In parameters */
2061
2062 /* Out parameters */
2063
2064 /* Result */
2065 ZERO_STRUCT(state->orig.out.result);
2066
2067 if (DEBUGLEVEL >= 10) {
2068 NDR_PRINT_IN_DEBUG(eventlog_ClearEventLogA, &state->orig);
2069 }
2070
2071 /* make a temporary copy, that we pass to the dispatch function */
2072 state->tmp = state->orig;
2073
2074 subreq = cli->dispatch_send(state, ev, cli,
2075 &ndr_table_eventlog,
2076 NDR_EVENTLOG_CLEAREVENTLOGA,
2077 &state->tmp);
2078 if (tevent_req_nomem(subreq, req)) {
2079 return tevent_req_post(req, ev);
2080 }
2081 tevent_req_set_callback(subreq, rpccli_eventlog_ClearEventLogA_done, req);
2082 return req;
2083 }
2084
2085 static void rpccli_eventlog_ClearEventLogA_done(struct tevent_req *subreq)
2086 {
2087 struct tevent_req *req = tevent_req_callback_data(
2088 subreq, struct tevent_req);
2089 struct rpccli_eventlog_ClearEventLogA_state *state = tevent_req_data(
2090 req, struct rpccli_eventlog_ClearEventLogA_state);
2091 NTSTATUS status;
2092 TALLOC_CTX *mem_ctx;
2093
2094 if (state->out_mem_ctx) {
2095 mem_ctx = state->out_mem_ctx;
2096 } else {
2097 mem_ctx = state;
2098 }
2099
2100 status = state->dispatch_recv(subreq, mem_ctx);
2101 TALLOC_FREE(subreq);
2102 if (!NT_STATUS_IS_OK(status)) {
2103 tevent_req_nterror(req, status);
2104 return;
2105 }
2106
2107 /* Copy out parameters */
2108
2109 /* Copy result */
2110 state->orig.out.result = state->tmp.out.result;
2111
2112 /* Reset temporary structure */
2113 ZERO_STRUCT(state->tmp);
2114
2115 if (DEBUGLEVEL >= 10) {
2116 NDR_PRINT_OUT_DEBUG(eventlog_ClearEventLogA, &state->orig);
2117 }
2118
2119 tevent_req_done(req);
2120 }
2121
2122 NTSTATUS rpccli_eventlog_ClearEventLogA_recv(struct tevent_req *req,
2123 TALLOC_CTX *mem_ctx,
2124 NTSTATUS *result)
2125 {
2126 struct rpccli_eventlog_ClearEventLogA_state *state = tevent_req_data(
2127 req, struct rpccli_eventlog_ClearEventLogA_state);
2128 NTSTATUS status;
2129
2130 if (tevent_req_is_nterror(req, &status)) {
2131 tevent_req_received(req);
2132 return status;
2133 }
2134
2135 /* Steal possbile out parameters to the callers context */
2136 talloc_steal(mem_ctx, state->out_mem_ctx);
2137
2138 /* Return result */
2139 *result = state->orig.out.result;
2140
2141 tevent_req_received(req);
2142 return NT_STATUS_OK;
2143 }
2144
2145 NTSTATUS rpccli_eventlog_ClearEventLogA(struct rpc_pipe_client *cli,
2146 TALLOC_CTX *mem_ctx)
2147 {
2148 struct eventlog_ClearEventLogA r;
2149 NTSTATUS status;
2150
2151 /* In parameters */
2152
2153 if (DEBUGLEVEL >= 10) {
2154 NDR_PRINT_IN_DEBUG(eventlog_ClearEventLogA, &r);
2155 }
2156
2157 status = cli->dispatch(cli,
2158 mem_ctx,
2159 &ndr_table_eventlog,
2160 NDR_EVENTLOG_CLEAREVENTLOGA,
2161 &r);
2162
2163 if (!NT_STATUS_IS_OK(status)) {
2164 return status;
2165 }
2166
2167 if (DEBUGLEVEL >= 10) {
2168 NDR_PRINT_OUT_DEBUG(eventlog_ClearEventLogA, &r);
2169 }
2170
2171 if (NT_STATUS_IS_ERR(status)) {
2172 return status;
2173 }
2174
2175 /* Return variables */
2176
2177 /* Return result */
2178 return r.out.result;
2179 }
2180
2181 struct rpccli_eventlog_BackupEventLogA_state {
2182 struct eventlog_BackupEventLogA orig;
2183 struct eventlog_BackupEventLogA tmp;
2184 TALLOC_CTX *out_mem_ctx;
2185 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
2186 };
2187
2188 static void rpccli_eventlog_BackupEventLogA_done(struct tevent_req *subreq);
2189
2190 struct tevent_req *rpccli_eventlog_BackupEventLogA_send(TALLOC_CTX *mem_ctx,
2191 struct tevent_context *ev,
2192 struct rpc_pipe_client *cli)
2193 {
2194 struct tevent_req *req;
2195 struct rpccli_eventlog_BackupEventLogA_state *state;
2196 struct tevent_req *subreq;
2197
2198 req = tevent_req_create(mem_ctx, &state,
2199 struct rpccli_eventlog_BackupEventLogA_state);
2200 if (req == NULL) {
2201 return NULL;
2202 }
2203 state->out_mem_ctx = NULL;
2204 state->dispatch_recv = cli->dispatch_recv;
2205
2206 /* In parameters */
2207
2208 /* Out parameters */
2209
2210 /* Result */
2211 ZERO_STRUCT(state->orig.out.result);
2212
2213 if (DEBUGLEVEL >= 10) {
2214 NDR_PRINT_IN_DEBUG(eventlog_BackupEventLogA, &state->orig);
2215 }
2216
2217 /* make a temporary copy, that we pass to the dispatch function */
2218 state->tmp = state->orig;
2219
2220 subreq = cli->dispatch_send(state, ev, cli,
2221 &ndr_table_eventlog,
2222 NDR_EVENTLOG_BACKUPEVENTLOGA,
2223 &state->tmp);
2224 if (tevent_req_nomem(subreq, req)) {
2225 return tevent_req_post(req, ev);
2226 }
2227 tevent_req_set_callback(subreq, rpccli_eventlog_BackupEventLogA_done, req);
2228 return req;
2229 }
2230
2231 static void rpccli_eventlog_BackupEventLogA_done(struct tevent_req *subreq)
2232 {
2233 struct tevent_req *req = tevent_req_callback_data(
2234 subreq, struct tevent_req);
2235 struct rpccli_eventlog_BackupEventLogA_state *state = tevent_req_data(
2236 req, struct rpccli_eventlog_BackupEventLogA_state);
2237 NTSTATUS status;
2238 TALLOC_CTX *mem_ctx;
2239
2240 if (state->out_mem_ctx) {
2241 mem_ctx = state->out_mem_ctx;
2242 } else {
2243 mem_ctx = state;
2244 }
2245
2246 status = state->dispatch_recv(subreq, mem_ctx);
2247 TALLOC_FREE(subreq);
2248 if (!NT_STATUS_IS_OK(status)) {
2249 tevent_req_nterror(req, status);
2250 return;
2251 }
2252
2253 /* Copy out parameters */
2254
2255 /* Copy result */
2256 state->orig.out.result = state->tmp.out.result;
2257
2258 /* Reset temporary structure */
2259 ZERO_STRUCT(state->tmp);
2260
2261 if (DEBUGLEVEL >= 10) {
2262 NDR_PRINT_OUT_DEBUG(eventlog_BackupEventLogA, &state->orig);
2263 }
2264
2265 tevent_req_done(req);
2266 }
2267
2268 NTSTATUS rpccli_eventlog_BackupEventLogA_recv(struct tevent_req *req,
2269 TALLOC_CTX *mem_ctx,
2270 NTSTATUS *result)
2271 {
2272 struct rpccli_eventlog_BackupEventLogA_state *state = tevent_req_data(
2273 req, struct rpccli_eventlog_BackupEventLogA_state);
2274 NTSTATUS status;
2275
2276 if (tevent_req_is_nterror(req, &status)) {
2277 tevent_req_received(req);
2278 return status;
2279 }
2280
2281 /* Steal possbile out parameters to the callers context */
2282 talloc_steal(mem_ctx, state->out_mem_ctx);
2283
2284 /* Return result */
2285 *result = state->orig.out.result;
2286
2287 tevent_req_received(req);
2288 return NT_STATUS_OK;
2289 }
2290
2291 NTSTATUS rpccli_eventlog_BackupEventLogA(struct rpc_pipe_client *cli,
2292 TALLOC_CTX *mem_ctx)
2293 {
2294 struct eventlog_BackupEventLogA r;
2295 NTSTATUS status;
2296
2297 /* In parameters */
2298
2299 if (DEBUGLEVEL >= 10) {
2300 NDR_PRINT_IN_DEBUG(eventlog_BackupEventLogA, &r);
2301 }
2302
2303 status = cli->dispatch(cli,
2304 mem_ctx,
2305 &ndr_table_eventlog,
2306 NDR_EVENTLOG_BACKUPEVENTLOGA,
2307 &r);
2308
2309 if (!NT_STATUS_IS_OK(status)) {
2310 return status;
2311 }
2312
2313 if (DEBUGLEVEL >= 10) {
2314 NDR_PRINT_OUT_DEBUG(eventlog_BackupEventLogA, &r);
2315 }
2316
2317 if (NT_STATUS_IS_ERR(status)) {
2318 return status;
2319 }
2320
2321 /* Return variables */
2322
2323 /* Return result */
2324 return r.out.result;
2325 }
2326
2327 struct rpccli_eventlog_OpenEventLogA_state {
2328 struct eventlog_OpenEventLogA orig;
2329 struct eventlog_OpenEventLogA tmp;
2330 TALLOC_CTX *out_mem_ctx;
2331 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
2332 };
2333
2334 static void rpccli_eventlog_OpenEventLogA_done(struct tevent_req *subreq);
2335
2336 struct tevent_req *rpccli_eventlog_OpenEventLogA_send(TALLOC_CTX *mem_ctx,
2337 struct tevent_context *ev,
2338 struct rpc_pipe_client *cli)
2339 {
2340 struct tevent_req *req;
2341 struct rpccli_eventlog_OpenEventLogA_state *state;
2342 struct tevent_req *subreq;
2343
2344 req = tevent_req_create(mem_ctx, &state,
2345 struct rpccli_eventlog_OpenEventLogA_state);
2346 if (req == NULL) {
2347 return NULL;
2348 }
2349 state->out_mem_ctx = NULL;
2350 state->dispatch_recv = cli->dispatch_recv;
2351
2352 /* In parameters */
2353
2354 /* Out parameters */
2355
2356 /* Result */
2357 ZERO_STRUCT(state->orig.out.result);
2358
2359 if (DEBUGLEVEL >= 10) {
2360 NDR_PRINT_IN_DEBUG(eventlog_OpenEventLogA, &state->orig);
2361 }
2362
2363 /* make a temporary copy, that we pass to the dispatch function */
2364 state->tmp = state->orig;
2365
2366 subreq = cli->dispatch_send(state, ev, cli,
2367 &ndr_table_eventlog,
2368 NDR_EVENTLOG_OPENEVENTLOGA,
2369 &state->tmp);
2370 if (tevent_req_nomem(subreq, req)) {
2371 return tevent_req_post(req, ev);
2372 }
2373 tevent_req_set_callback(subreq, rpccli_eventlog_OpenEventLogA_done, req);
2374 return req;
2375 }
2376
2377 static void rpccli_eventlog_OpenEventLogA_done(struct tevent_req *subreq)
2378 {
2379 struct tevent_req *req = tevent_req_callback_data(
2380 subreq, struct tevent_req);
2381 struct rpccli_eventlog_OpenEventLogA_state *state = tevent_req_data(
2382 req, struct rpccli_eventlog_OpenEventLogA_state);
2383 NTSTATUS status;
2384 TALLOC_CTX *mem_ctx;
2385
2386 if (state->out_mem_ctx) {
2387 mem_ctx = state->out_mem_ctx;
2388 } else {
2389 mem_ctx = state;
2390 }
2391
2392 status = state->dispatch_recv(subreq, mem_ctx);
2393 TALLOC_FREE(subreq);
2394 if (!NT_STATUS_IS_OK(status)) {
2395 tevent_req_nterror(req, status);
2396 return;
2397 }
2398
2399 /* Copy out parameters */
2400
2401 /* Copy result */
2402 state->orig.out.result = state->tmp.out.result;
2403
2404 /* Reset temporary structure */
2405 ZERO_STRUCT(state->tmp);
2406
2407 if (DEBUGLEVEL >= 10) {
2408 NDR_PRINT_OUT_DEBUG(eventlog_OpenEventLogA, &state->orig);
2409 }
2410
2411 tevent_req_done(req);
2412 }
2413
2414 NTSTATUS rpccli_eventlog_OpenEventLogA_recv(struct tevent_req *req,
2415 TALLOC_CTX *mem_ctx,
2416 NTSTATUS *result)
2417 {
2418 struct rpccli_eventlog_OpenEventLogA_state *state = tevent_req_data(
2419 req, struct rpccli_eventlog_OpenEventLogA_state);
2420 NTSTATUS status;
2421
2422 if (tevent_req_is_nterror(req, &status)) {
2423 tevent_req_received(req);
2424 return status;
2425 }
2426
2427 /* Steal possbile out parameters to the callers context */
2428 talloc_steal(mem_ctx, state->out_mem_ctx);
2429
2430 /* Return result */
2431 *result = state->orig.out.result;
2432
2433 tevent_req_received(req);
2434 return NT_STATUS_OK;
2435 }
2436
2437 NTSTATUS rpccli_eventlog_OpenEventLogA(struct rpc_pipe_client *cli,
2438 TALLOC_CTX *mem_ctx)
2439 {
2440 struct eventlog_OpenEventLogA r;
2441 NTSTATUS status;
2442
2443 /* In parameters */
2444
2445 if (DEBUGLEVEL >= 10) {
2446 NDR_PRINT_IN_DEBUG(eventlog_OpenEventLogA, &r);
2447 }
2448
2449 status = cli->dispatch(cli,
2450 mem_ctx,
2451 &ndr_table_eventlog,
2452 NDR_EVENTLOG_OPENEVENTLOGA,
2453 &r);
2454
2455 if (!NT_STATUS_IS_OK(status)) {
2456 return status;
2457 }
2458
2459 if (DEBUGLEVEL >= 10) {
2460 NDR_PRINT_OUT_DEBUG(eventlog_OpenEventLogA, &r);
2461 }
2462
2463 if (NT_STATUS_IS_ERR(status)) {
2464 return status;
2465 }
2466
2467 /* Return variables */
2468
2469 /* Return result */
2470 return r.out.result;
2471 }
2472
2473 struct rpccli_eventlog_RegisterEventSourceA_state {
2474 struct eventlog_RegisterEventSourceA orig;
2475 struct eventlog_RegisterEventSourceA tmp;
2476 TALLOC_CTX *out_mem_ctx;
2477 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
2478 };
2479
2480 static void rpccli_eventlog_RegisterEventSourceA_done(struct tevent_req *subreq);
2481
2482 struct tevent_req *rpccli_eventlog_RegisterEventSourceA_send(TALLOC_CTX *mem_ctx,
2483 struct tevent_context *ev,
2484 struct rpc_pipe_client *cli)
2485 {
2486 struct tevent_req *req;
2487 struct rpccli_eventlog_RegisterEventSourceA_state *state;
2488 struct tevent_req *subreq;
2489
2490 req = tevent_req_create(mem_ctx, &state,
2491 struct rpccli_eventlog_RegisterEventSourceA_state);
2492 if (req == NULL) {
2493 return NULL;
2494 }
2495 state->out_mem_ctx = NULL;
2496 state->dispatch_recv = cli->dispatch_recv;
2497
2498 /* In parameters */
2499
2500 /* Out parameters */
2501
2502 /* Result */
2503 ZERO_STRUCT(state->orig.out.result);
2504
2505 if (DEBUGLEVEL >= 10) {
2506 NDR_PRINT_IN_DEBUG(eventlog_RegisterEventSourceA, &state->orig);
2507 }
2508
2509 /* make a temporary copy, that we pass to the dispatch function */
2510 state->tmp = state->orig;
2511
2512 subreq = cli->dispatch_send(state, ev, cli,
2513 &ndr_table_eventlog,
2514 NDR_EVENTLOG_REGISTEREVENTSOURCEA,
2515 &state->tmp);
2516 if (tevent_req_nomem(subreq, req)) {
2517 return tevent_req_post(req, ev);
2518 }
2519 tevent_req_set_callback(subreq, rpccli_eventlog_RegisterEventSourceA_done, req);
2520 return req;
2521 }
2522
2523 static void rpccli_eventlog_RegisterEventSourceA_done(struct tevent_req *subreq)
2524 {
2525 struct tevent_req *req = tevent_req_callback_data(
2526 subreq, struct tevent_req);
2527 struct rpccli_eventlog_RegisterEventSourceA_state *state = tevent_req_data(
2528 req, struct rpccli_eventlog_RegisterEventSourceA_state);
2529 NTSTATUS status;
2530 TALLOC_CTX *mem_ctx;
2531
2532 if (state->out_mem_ctx) {
2533 mem_ctx = state->out_mem_ctx;
2534 } else {
2535 mem_ctx = state;
2536 }
2537
2538 status = state->dispatch_recv(subreq, mem_ctx);
2539 TALLOC_FREE(subreq);
2540 if (!NT_STATUS_IS_OK(status)) {
2541 tevent_req_nterror(req, status);
2542 return;
2543 }
2544
2545 /* Copy out parameters */
2546
2547 /* Copy result */
2548 state->orig.out.result = state->tmp.out.result;
2549
2550 /* Reset temporary structure */
2551 ZERO_STRUCT(state->tmp);
2552
2553 if (DEBUGLEVEL >= 10) {
2554 NDR_PRINT_OUT_DEBUG(eventlog_RegisterEventSourceA, &state->orig);
2555 }
2556
2557 tevent_req_done(req);
2558 }
2559
2560 NTSTATUS rpccli_eventlog_RegisterEventSourceA_recv(struct tevent_req *req,
2561 TALLOC_CTX *mem_ctx,
2562 NTSTATUS *result)
2563 {
2564 struct rpccli_eventlog_RegisterEventSourceA_state *state = tevent_req_data(
2565 req, struct rpccli_eventlog_RegisterEventSourceA_state);
2566 NTSTATUS status;
2567
2568 if (tevent_req_is_nterror(req, &status)) {
2569 tevent_req_received(req);
2570 return status;
2571 }
2572
2573 /* Steal possbile out parameters to the callers context */
2574 talloc_steal(mem_ctx, state->out_mem_ctx);
2575
2576 /* Return result */
2577 *result = state->orig.out.result;
2578
2579 tevent_req_received(req);
2580 return NT_STATUS_OK;
2581 }
2582
2583 NTSTATUS rpccli_eventlog_RegisterEventSourceA(struct rpc_pipe_client *cli,
2584 TALLOC_CTX *mem_ctx)
2585 {
2586 struct eventlog_RegisterEventSourceA r;
2587 NTSTATUS status;
2588
2589 /* In parameters */
2590
2591 if (DEBUGLEVEL >= 10) {
2592 NDR_PRINT_IN_DEBUG(eventlog_RegisterEventSourceA, &r);
2593 }
2594
2595 status = cli->dispatch(cli,
2596 mem_ctx,
2597 &ndr_table_eventlog,
2598 NDR_EVENTLOG_REGISTEREVENTSOURCEA,
2599 &r);
2600
2601 if (!NT_STATUS_IS_OK(status)) {
2602 return status;
2603 }
2604
2605 if (DEBUGLEVEL >= 10) {
2606 NDR_PRINT_OUT_DEBUG(eventlog_RegisterEventSourceA, &r);
2607 }
2608
2609 if (NT_STATUS_IS_ERR(status)) {
2610 return status;
2611 }
2612
2613 /* Return variables */
2614
2615 /* Return result */
2616 return r.out.result;
2617 }
2618
2619 struct rpccli_eventlog_OpenBackupEventLogA_state {
2620 struct eventlog_OpenBackupEventLogA orig;
2621 struct eventlog_OpenBackupEventLogA tmp;
2622 TALLOC_CTX *out_mem_ctx;
2623 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
2624 };
2625
2626 static void rpccli_eventlog_OpenBackupEventLogA_done(struct tevent_req *subreq);
2627
2628 struct tevent_req *rpccli_eventlog_OpenBackupEventLogA_send(TALLOC_CTX *mem_ctx,
2629 struct tevent_context *ev,
2630 struct rpc_pipe_client *cli)
2631 {
2632 struct tevent_req *req;
2633 struct rpccli_eventlog_OpenBackupEventLogA_state *state;
2634 struct tevent_req *subreq;
2635
2636 req = tevent_req_create(mem_ctx, &state,
2637 struct rpccli_eventlog_OpenBackupEventLogA_state);
2638 if (req == NULL) {
2639 return NULL;
2640 }
2641 state->out_mem_ctx = NULL;
2642 state->dispatch_recv = cli->dispatch_recv;
2643
2644 /* In parameters */
2645
2646 /* Out parameters */
2647
2648 /* Result */
2649 ZERO_STRUCT(state->orig.out.result);
2650
2651 if (DEBUGLEVEL >= 10) {
2652 NDR_PRINT_IN_DEBUG(eventlog_OpenBackupEventLogA, &state->orig);
2653 }
2654
2655 /* make a temporary copy, that we pass to the dispatch function */
2656 state->tmp = state->orig;
2657
2658 subreq = cli->dispatch_send(state, ev, cli,
2659 &ndr_table_eventlog,
2660 NDR_EVENTLOG_OPENBACKUPEVENTLOGA,
2661 &state->tmp);
2662 if (tevent_req_nomem(subreq, req)) {
2663 return tevent_req_post(req, ev);
2664 }
2665 tevent_req_set_callback(subreq, rpccli_eventlog_OpenBackupEventLogA_done, req);
2666 return req;
2667 }
2668
2669 static void rpccli_eventlog_OpenBackupEventLogA_done(struct tevent_req *subreq)
2670 {
2671 struct tevent_req *req = tevent_req_callback_data(
2672 subreq, struct tevent_req);
2673 struct rpccli_eventlog_OpenBackupEventLogA_state *state = tevent_req_data(
2674 req, struct rpccli_eventlog_OpenBackupEventLogA_state);
2675 NTSTATUS status;
2676 TALLOC_CTX *mem_ctx;
2677
2678 if (state->out_mem_ctx) {
2679 mem_ctx = state->out_mem_ctx;
2680 } else {
2681 mem_ctx = state;
2682 }
2683
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);
2688 return;
2689 }
2690
2691 /* Copy out parameters */
2692
2693 /* Copy result */
2694 state->orig.out.result = state->tmp.out.result;
2695
2696 /* Reset temporary structure */
2697 ZERO_STRUCT(state->tmp);
2698
2699 if (DEBUGLEVEL >= 10) {
2700 NDR_PRINT_OUT_DEBUG(eventlog_OpenBackupEventLogA, &state->orig);
2701 }
2702
2703 tevent_req_done(req);
2704 }
2705
2706 NTSTATUS rpccli_eventlog_OpenBackupEventLogA_recv(struct tevent_req *req,
2707 TALLOC_CTX *mem_ctx,
2708 NTSTATUS *result)
2709 {
2710 struct rpccli_eventlog_OpenBackupEventLogA_state *state = tevent_req_data(
2711 req, struct rpccli_eventlog_OpenBackupEventLogA_state);
2712 NTSTATUS status;
2713
2714 if (tevent_req_is_nterror(req, &status)) {
2715 tevent_req_received(req);
2716 return status;
2717 }
2718
2719 /* Steal possbile out parameters to the callers context */
2720 talloc_steal(mem_ctx, state->out_mem_ctx);
2721
2722 /* Return result */
2723 *result = state->orig.out.result;
2724
2725 tevent_req_received(req);
2726 return NT_STATUS_OK;
2727 }
2728
2729 NTSTATUS rpccli_eventlog_OpenBackupEventLogA(struct rpc_pipe_client *cli,
2730 TALLOC_CTX *mem_ctx)
2731 {
2732 struct eventlog_OpenBackupEventLogA r;
2733 NTSTATUS status;
2734
2735 /* In parameters */
2736
2737 if (DEBUGLEVEL >= 10) {
2738 NDR_PRINT_IN_DEBUG(eventlog_OpenBackupEventLogA, &r);
2739 }
2740
2741 status = cli->dispatch(cli,
2742 mem_ctx,
2743 &ndr_table_eventlog,
2744 NDR_EVENTLOG_OPENBACKUPEVENTLOGA,
2745 &r);
2746
2747 if (!NT_STATUS_IS_OK(status)) {
2748 return status;
2749 }
2750
2751 if (DEBUGLEVEL >= 10) {
2752 NDR_PRINT_OUT_DEBUG(eventlog_OpenBackupEventLogA, &r);
2753 }
2754
2755 if (NT_STATUS_IS_ERR(status)) {
2756 return status;
2757 }
2758
2759 /* Return variables */
2760
2761 /* Return result */
2762 return r.out.result;
2763 }
2764
2765 struct rpccli_eventlog_ReadEventLogA_state {
2766 struct eventlog_ReadEventLogA orig;
2767 struct eventlog_ReadEventLogA tmp;
2768 TALLOC_CTX *out_mem_ctx;
2769 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
2770 };
2771
2772 static void rpccli_eventlog_ReadEventLogA_done(struct tevent_req *subreq);
2773
2774 struct tevent_req *rpccli_eventlog_ReadEventLogA_send(TALLOC_CTX *mem_ctx,
2775 struct tevent_context *ev,
2776 struct rpc_pipe_client *cli)
2777 {
2778 struct tevent_req *req;
2779 struct rpccli_eventlog_ReadEventLogA_state *state;
2780 struct tevent_req *subreq;
2781
2782 req = tevent_req_create(mem_ctx, &state,
2783 struct rpccli_eventlog_ReadEventLogA_state);
2784 if (req == NULL) {
2785 return NULL;
2786 }
2787 state->out_mem_ctx = NULL;
2788 state->dispatch_recv = cli->dispatch_recv;
2789
2790 /* In parameters */
2791
2792 /* Out parameters */
2793
2794 /* Result */
2795 ZERO_STRUCT(state->orig.out.result);
2796
2797 if (DEBUGLEVEL >= 10) {
2798 NDR_PRINT_IN_DEBUG(eventlog_ReadEventLogA, &state->orig);
2799 }
2800
2801 /* make a temporary copy, that we pass to the dispatch function */
2802 state->tmp = state->orig;
2803
2804 subreq = cli->dispatch_send(state, ev, cli,
2805 &ndr_table_eventlog,
2806 NDR_EVENTLOG_READEVENTLOGA,
2807 &state->tmp);
2808 if (tevent_req_nomem(subreq, req)) {
2809 return tevent_req_post(req, ev);
2810 }
2811 tevent_req_set_callback(subreq, rpccli_eventlog_ReadEventLogA_done, req);
2812 return req;
2813 }
2814
2815 static void rpccli_eventlog_ReadEventLogA_done(struct tevent_req *subreq)
2816 {
2817 struct tevent_req *req = tevent_req_callback_data(
2818 subreq, struct tevent_req);
2819 struct rpccli_eventlog_ReadEventLogA_state *state = tevent_req_data(
2820 req, struct rpccli_eventlog_ReadEventLogA_state);
2821 NTSTATUS status;
2822 TALLOC_CTX *mem_ctx;
2823
2824 if (state->out_mem_ctx) {
2825 mem_ctx = state->out_mem_ctx;
2826 } else {
2827 mem_ctx = state;
2828 }
2829
2830 status = state->dispatch_recv(subreq, mem_ctx);
2831 TALLOC_FREE(subreq);
2832 if (!NT_STATUS_IS_OK(status)) {
2833 tevent_req_nterror(req, status);
2834 return;
2835 }
2836
2837 /* Copy out parameters */
2838
2839 /* Copy result */
2840 state->orig.out.result = state->tmp.out.result;
2841
2842 /* Reset temporary structure */
2843 ZERO_STRUCT(state->tmp);
2844
2845 if (DEBUGLEVEL >= 10) {
2846 NDR_PRINT_OUT_DEBUG(eventlog_ReadEventLogA, &state->orig);
2847 }
2848
2849 tevent_req_done(req);
2850 }
2851
2852 NTSTATUS rpccli_eventlog_ReadEventLogA_recv(struct tevent_req *req,
2853 TALLOC_CTX *mem_ctx,
2854 NTSTATUS *result)
2855 {
2856 struct rpccli_eventlog_ReadEventLogA_state *state = tevent_req_data(
2857 req, struct rpccli_eventlog_ReadEventLogA_state);
2858 NTSTATUS status;
2859
2860 if (tevent_req_is_nterror(req, &status)) {
2861 tevent_req_received(req);
2862 return status;
2863 }
2864
2865 /* Steal possbile out parameters to the callers context */
2866 talloc_steal(mem_ctx, state->out_mem_ctx);
2867
2868 /* Return result */
2869 *result = state->orig.out.result;
2870
2871 tevent_req_received(req);
2872 return NT_STATUS_OK;
2873 }
2874
2875 NTSTATUS rpccli_eventlog_ReadEventLogA(struct rpc_pipe_client *cli,
2876 TALLOC_CTX *mem_ctx)
2877 {
2878 struct eventlog_ReadEventLogA r;
2879 NTSTATUS status;
2880
2881 /* In parameters */
2882
2883 if (DEBUGLEVEL >= 10) {
2884 NDR_PRINT_IN_DEBUG(eventlog_ReadEventLogA, &r);
2885 }
2886
2887 status = cli->dispatch(cli,
2888 mem_ctx,
2889 &ndr_table_eventlog,
2890 NDR_EVENTLOG_READEVENTLOGA,
2891 &r);
2892
2893 if (!NT_STATUS_IS_OK(status)) {
2894 return status;
2895 }
2896
2897 if (DEBUGLEVEL >= 10) {
2898 NDR_PRINT_OUT_DEBUG(eventlog_ReadEventLogA, &r);
2899 }
2900
2901 if (NT_STATUS_IS_ERR(status)) {
2902 return status;
2903 }
2904
2905 /* Return variables */
2906
2907 /* Return result */
2908 return r.out.result;
2909 }
2910
2911 struct rpccli_eventlog_ReportEventA_state {
2912 struct eventlog_ReportEventA orig;
2913 struct eventlog_ReportEventA tmp;
2914 TALLOC_CTX *out_mem_ctx;
2915 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
2916 };
2917
2918 static void rpccli_eventlog_ReportEventA_done(struct tevent_req *subreq);
2919
2920 struct tevent_req *rpccli_eventlog_ReportEventA_send(TALLOC_CTX *mem_ctx,
2921 struct tevent_context *ev,
2922 struct rpc_pipe_client *cli)
2923 {
2924 struct tevent_req *req;
2925 struct rpccli_eventlog_ReportEventA_state *state;
2926 struct tevent_req *subreq;
2927
2928 req = tevent_req_create(mem_ctx, &state,
2929 struct rpccli_eventlog_ReportEventA_state);
2930 if (req == NULL) {
2931 return NULL;
2932 }
2933 state->out_mem_ctx = NULL;
2934 state->dispatch_recv = cli->dispatch_recv;
2935
2936 /* In parameters */
2937
2938 /* Out parameters */
2939
2940 /* Result */
2941 ZERO_STRUCT(state->orig.out.result);
2942
2943 if (DEBUGLEVEL >= 10) {
2944 NDR_PRINT_IN_DEBUG(eventlog_ReportEventA, &state->orig);
2945 }
2946
2947 /* make a temporary copy, that we pass to the dispatch function */
2948 state->tmp = state->orig;
2949
2950 subreq = cli->dispatch_send(state, ev, cli,
2951 &ndr_table_eventlog,
2952 NDR_EVENTLOG_REPORTEVENTA,
2953 &state->tmp);
2954 if (tevent_req_nomem(subreq, req)) {
2955 return tevent_req_post(req, ev);
2956 }
2957 tevent_req_set_callback(subreq, rpccli_eventlog_ReportEventA_done, req);
2958 return req;
2959 }
2960
2961 static void rpccli_eventlog_ReportEventA_done(struct tevent_req *subreq)
2962 {
2963 struct tevent_req *req = tevent_req_callback_data(
2964 subreq, struct tevent_req);
2965 struct rpccli_eventlog_ReportEventA_state *state = tevent_req_data(
2966 req, struct rpccli_eventlog_ReportEventA_state);
2967 NTSTATUS status;
2968 TALLOC_CTX *mem_ctx;
2969
2970 if (state->out_mem_ctx) {
2971 mem_ctx = state->out_mem_ctx;
2972 } else {
2973 mem_ctx = state;
2974 }
2975
2976 status = state->dispatch_recv(subreq, mem_ctx);
2977 TALLOC_FREE(subreq);
2978 if (!NT_STATUS_IS_OK(status)) {
2979 tevent_req_nterror(req, status);
2980 return;
2981 }
2982
2983 /* Copy out parameters */
2984
2985 /* Copy result */
2986 state->orig.out.result = state->tmp.out.result;
2987
2988 /* Reset temporary structure */
2989 ZERO_STRUCT(state->tmp);
2990
2991 if (DEBUGLEVEL >= 10) {
2992 NDR_PRINT_OUT_DEBUG(eventlog_ReportEventA, &state->orig);
2993 }
2994
2995 tevent_req_done(req);
2996 }
2997
2998 NTSTATUS rpccli_eventlog_ReportEventA_recv(struct tevent_req *req,
2999 TALLOC_CTX *mem_ctx,
3000 NTSTATUS *result)
3001 {
3002 struct rpccli_eventlog_ReportEventA_state *state = tevent_req_data(
3003 req, struct rpccli_eventlog_ReportEventA_state);
3004 NTSTATUS status;
3005
3006 if (tevent_req_is_nterror(req, &status)) {
3007 tevent_req_received(req);
3008 return status;
3009 }
3010
3011 /* Steal possbile out parameters to the callers context */
3012 talloc_steal(mem_ctx, state->out_mem_ctx);
3013
3014 /* Return result */
3015 *result = state->orig.out.result;
3016
3017 tevent_req_received(req);
3018 return NT_STATUS_OK;
3019 }
3020
3021 NTSTATUS rpccli_eventlog_ReportEventA(struct rpc_pipe_client *cli,
3022 TALLOC_CTX *mem_ctx)
3023 {
3024 struct eventlog_ReportEventA r;
3025 NTSTATUS status;
3026
3027 /* In parameters */
3028
3029 if (DEBUGLEVEL >= 10) {
3030 NDR_PRINT_IN_DEBUG(eventlog_ReportEventA, &r);
3031 }
3032
3033 status = cli->dispatch(cli,
3034 mem_ctx,
3035 &ndr_table_eventlog,
3036 NDR_EVENTLOG_REPORTEVENTA,
3037 &r);
3038
3039 if (!NT_STATUS_IS_OK(status)) {
3040 return status;
3041 }
3042
3043 if (DEBUGLEVEL >= 10) {
3044 NDR_PRINT_OUT_DEBUG(eventlog_ReportEventA, &r);
3045 }
3046
3047 if (NT_STATUS_IS_ERR(status)) {
3048 return status;
3049 }
3050
3051 /* Return variables */
3052
3053 /* Return result */
3054 return r.out.result;
3055 }
3056
3057 struct rpccli_eventlog_RegisterClusterSvc_state {
3058 struct eventlog_RegisterClusterSvc orig;
3059 struct eventlog_RegisterClusterSvc tmp;
3060 TALLOC_CTX *out_mem_ctx;
3061 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
3062 };
3063
3064 static void rpccli_eventlog_RegisterClusterSvc_done(struct tevent_req *subreq);
3065
3066 struct tevent_req *rpccli_eventlog_RegisterClusterSvc_send(TALLOC_CTX *mem_ctx,
3067 struct tevent_context *ev,
3068 struct rpc_pipe_client *cli)
3069 {
3070 struct tevent_req *req;
3071 struct rpccli_eventlog_RegisterClusterSvc_state *state;
3072 struct tevent_req *subreq;
3073
3074 req = tevent_req_create(mem_ctx, &state,
3075 struct rpccli_eventlog_RegisterClusterSvc_state);
3076 if (req == NULL) {
3077 return NULL;
3078 }
3079 state->out_mem_ctx = NULL;
3080 state->dispatch_recv = cli->dispatch_recv;
3081
3082 /* In parameters */
3083
3084 /* Out parameters */
3085
3086 /* Result */
3087 ZERO_STRUCT(state->orig.out.result);
3088
3089 if (DEBUGLEVEL >= 10) {
3090 NDR_PRINT_IN_DEBUG(eventlog_RegisterClusterSvc, &state->orig);
3091 }
3092
3093 /* make a temporary copy, that we pass to the dispatch function */
3094 state->tmp = state->orig;
3095
3096 subreq = cli->dispatch_send(state, ev, cli,
3097 &ndr_table_eventlog,
3098 NDR_EVENTLOG_REGISTERCLUSTERSVC,
3099 &state->tmp);
3100 if (tevent_req_nomem(subreq, req)) {
3101 return tevent_req_post(req, ev);
3102 }
3103 tevent_req_set_callback(subreq, rpccli_eventlog_RegisterClusterSvc_done, req);
3104 return req;
3105 }
3106
3107 static void rpccli_eventlog_RegisterClusterSvc_done(struct tevent_req *subreq)
3108 {
3109 struct tevent_req *req = tevent_req_callback_data(
3110 subreq, struct tevent_req);
3111 struct rpccli_eventlog_RegisterClusterSvc_state *state = tevent_req_data(
3112 req, struct rpccli_eventlog_RegisterClusterSvc_state);
3113 NTSTATUS status;
3114 TALLOC_CTX *mem_ctx;
3115
3116 if (state->out_mem_ctx) {
3117 mem_ctx = state->out_mem_ctx;
3118 } else {
3119 mem_ctx = state;
3120 }
3121
3122 status = state->dispatch_recv(subreq, mem_ctx);
3123 TALLOC_FREE(subreq);
3124 if (!NT_STATUS_IS_OK(status)) {
3125 tevent_req_nterror(req, status);
3126 return;
3127 }
3128
3129 /* Copy out parameters */
3130
3131 /* Copy result */
3132 state->orig.out.result = state->tmp.out.result;
3133
3134 /* Reset temporary structure */
3135 ZERO_STRUCT(state->tmp);
3136
3137 if (DEBUGLEVEL >= 10) {
3138 NDR_PRINT_OUT_DEBUG(eventlog_RegisterClusterSvc, &state->orig);
3139 }
3140
3141 tevent_req_done(req);
3142 }
3143
3144 NTSTATUS rpccli_eventlog_RegisterClusterSvc_recv(struct tevent_req *req,
3145 TALLOC_CTX *mem_ctx,
3146 NTSTATUS *result)
3147 {
3148 struct rpccli_eventlog_RegisterClusterSvc_state *state = tevent_req_data(
3149 req, struct rpccli_eventlog_RegisterClusterSvc_state);
3150 NTSTATUS status;
3151
3152 if (tevent_req_is_nterror(req, &status)) {
3153 tevent_req_received(req);
3154 return status;
3155 }
3156
3157 /* Steal possbile out parameters to the callers context */
3158 talloc_steal(mem_ctx, state->out_mem_ctx);
3159
3160 /* Return result */
3161 *result = state->orig.out.result;
3162
3163 tevent_req_received(req);
3164 return NT_STATUS_OK;
3165 }
3166
3167 NTSTATUS rpccli_eventlog_RegisterClusterSvc(struct rpc_pipe_client *cli,
3168 TALLOC_CTX *mem_ctx)
3169 {
3170 struct eventlog_RegisterClusterSvc r;
3171 NTSTATUS status;
3172
3173 /* In parameters */
3174
3175 if (DEBUGLEVEL >= 10) {
3176 NDR_PRINT_IN_DEBUG(eventlog_RegisterClusterSvc, &r);
3177 }
3178
3179 status = cli->dispatch(cli,
3180 mem_ctx,
3181 &ndr_table_eventlog,
3182 NDR_EVENTLOG_REGISTERCLUSTERSVC,
3183 &r);
3184
3185 if (!NT_STATUS_IS_OK(status)) {
3186 return status;
3187 }
3188
3189 if (DEBUGLEVEL >= 10) {
3190 NDR_PRINT_OUT_DEBUG(eventlog_RegisterClusterSvc, &r);
3191 }
3192
3193 if (NT_STATUS_IS_ERR(status)) {
3194 return status;
3195 }
3196
3197 /* Return variables */
3198
3199 /* Return result */
3200 return r.out.result;
3201 }
3202
3203 struct rpccli_eventlog_DeregisterClusterSvc_state {
3204 struct eventlog_DeregisterClusterSvc orig;
3205 struct eventlog_DeregisterClusterSvc tmp;
3206 TALLOC_CTX *out_mem_ctx;
3207 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
3208 };
3209
3210 static void rpccli_eventlog_DeregisterClusterSvc_done(struct tevent_req *subreq);
3211
3212 struct tevent_req *rpccli_eventlog_DeregisterClusterSvc_send(TALLOC_CTX *mem_ctx,
3213 struct tevent_context *ev,
3214 struct rpc_pipe_client *cli)
3215 {
3216 struct tevent_req *req;
3217 struct rpccli_eventlog_DeregisterClusterSvc_state *state;
3218 struct tevent_req *subreq;
3219
3220 req = tevent_req_create(mem_ctx, &state,
3221 struct rpccli_eventlog_DeregisterClusterSvc_state);
3222 if (req == NULL) {
3223 return NULL;
3224 }
3225 state->out_mem_ctx = NULL;
3226 state->dispatch_recv = cli->dispatch_recv;
3227
3228 /* In parameters */
3229
3230 /* Out parameters */
3231
3232 /* Result */
3233 ZERO_STRUCT(state->orig.out.result);
3234
3235 if (DEBUGLEVEL >= 10) {
3236 NDR_PRINT_IN_DEBUG(eventlog_DeregisterClusterSvc, &state->orig);
3237 }
3238
3239 /* make a temporary copy, that we pass to the dispatch function */
3240 state->tmp = state->orig;
3241
3242 subreq = cli->dispatch_send(state, ev, cli,
3243 &ndr_table_eventlog,
3244 NDR_EVENTLOG_DEREGISTERCLUSTERSVC,
3245 &state->tmp);
3246 if (tevent_req_nomem(subreq, req)) {
3247 return tevent_req_post(req, ev);
3248 }
3249 tevent_req_set_callback(subreq, rpccli_eventlog_DeregisterClusterSvc_done, req);
3250 return req;
3251 }
3252
3253 static void rpccli_eventlog_DeregisterClusterSvc_done(struct tevent_req *subreq)
3254 {
3255 struct tevent_req *req = tevent_req_callback_data(
3256 subreq, struct tevent_req);
3257 struct rpccli_eventlog_DeregisterClusterSvc_state *state = tevent_req_data(
3258 req, struct rpccli_eventlog_DeregisterClusterSvc_state);
3259 NTSTATUS status;
3260 TALLOC_CTX *mem_ctx;
3261
3262 if (state->out_mem_ctx) {
3263 mem_ctx = state->out_mem_ctx;
3264 } else {
3265 mem_ctx = state;
3266 }
3267
3268 status = state->dispatch_recv(subreq, mem_ctx);
3269 TALLOC_FREE(subreq);
3270 if (!NT_STATUS_IS_OK(status)) {
3271 tevent_req_nterror(req, status);
3272 return;
3273 }
3274
3275 /* Copy out parameters */
3276
3277 /* Copy result */
3278 state->orig.out.result = state->tmp.out.result;
3279
3280 /* Reset temporary structure */
3281 ZERO_STRUCT(state->tmp);
3282
3283 if (DEBUGLEVEL >= 10) {
3284 NDR_PRINT_OUT_DEBUG(eventlog_DeregisterClusterSvc, &state->orig);
3285 }
3286
3287 tevent_req_done(req);
3288 }
3289
3290 NTSTATUS rpccli_eventlog_DeregisterClusterSvc_recv(struct tevent_req *req,
3291 TALLOC_CTX *mem_ctx,
3292 NTSTATUS *result)
3293 {
3294 struct rpccli_eventlog_DeregisterClusterSvc_state *state = tevent_req_data(
3295 req, struct rpccli_eventlog_DeregisterClusterSvc_state);
3296 NTSTATUS status;
3297
3298 if (tevent_req_is_nterror(req, &status)) {
3299 tevent_req_received(req);
3300 return status;
3301 }
3302
3303 /* Steal possbile out parameters to the callers context */
3304 talloc_steal(mem_ctx, state->out_mem_ctx);
3305
3306 /* Return result */
3307 *result = state->orig.out.result;
3308
3309 tevent_req_received(req);
3310 return NT_STATUS_OK;
3311 }
3312
3313 NTSTATUS rpccli_eventlog_DeregisterClusterSvc(struct rpc_pipe_client *cli,
3314 TALLOC_CTX *mem_ctx)
3315 {
3316 struct eventlog_DeregisterClusterSvc r;
3317 NTSTATUS status;
3318
3319 /* In parameters */
3320
3321 if (DEBUGLEVEL >= 10) {
3322 NDR_PRINT_IN_DEBUG(eventlog_DeregisterClusterSvc, &r);
3323 }
3324
3325 status = cli->dispatch(cli,
3326 mem_ctx,
3327 &ndr_table_eventlog,
3328 NDR_EVENTLOG_DEREGISTERCLUSTERSVC,
3329 &r);
3330
3331 if (!NT_STATUS_IS_OK(status)) {
3332 return status;
3333 }
3334
3335 if (DEBUGLEVEL >= 10) {
3336 NDR_PRINT_OUT_DEBUG(eventlog_DeregisterClusterSvc, &r);
3337 }
3338
3339 if (NT_STATUS_IS_ERR(status)) {
3340 return status;
3341 }
3342
3343 /* Return variables */
3344
3345 /* Return result */
3346 return r.out.result;
3347 }
3348
3349 struct rpccli_eventlog_WriteClusterEvents_state {
3350 struct eventlog_WriteClusterEvents orig;
3351 struct eventlog_WriteClusterEvents tmp;
3352 TALLOC_CTX *out_mem_ctx;
3353 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
3354 };
3355
3356 static void rpccli_eventlog_WriteClusterEvents_done(struct tevent_req *subreq);
3357
3358 struct tevent_req *rpccli_eventlog_WriteClusterEvents_send(TALLOC_CTX *mem_ctx,
3359 struct tevent_context *ev,
3360 struct rpc_pipe_client *cli)
3361 {
3362 struct tevent_req *req;
3363 struct rpccli_eventlog_WriteClusterEvents_state *state;
3364 struct tevent_req *subreq;
3365
3366 req = tevent_req_create(mem_ctx, &state,
3367 struct rpccli_eventlog_WriteClusterEvents_state);
3368 if (req == NULL) {
3369 return NULL;
3370 }
3371 state->out_mem_ctx = NULL;
3372 state->dispatch_recv = cli->dispatch_recv;
3373
3374 /* In parameters */
3375
3376 /* Out parameters */
3377
3378 /* Result */
3379 ZERO_STRUCT(state->orig.out.result);
3380
3381 if (DEBUGLEVEL >= 10) {
3382 NDR_PRINT_IN_DEBUG(eventlog_WriteClusterEvents, &state->orig);
3383 }
3384
3385 /* make a temporary copy, that we pass to the dispatch function */
3386 state->tmp = state->orig;
3387
3388 subreq = cli->dispatch_send(state, ev, cli,
3389 &ndr_table_eventlog,
3390 NDR_EVENTLOG_WRITECLUSTEREVENTS,
3391 &state->tmp);
3392 if (tevent_req_nomem(subreq, req)) {
3393 return tevent_req_post(req, ev);
3394 }
3395 tevent_req_set_callback(subreq, rpccli_eventlog_WriteClusterEvents_done, req);
3396 return req;
3397 }
3398
3399 static void rpccli_eventlog_WriteClusterEvents_done(struct tevent_req *subreq)
3400 {
3401 struct tevent_req *req = tevent_req_callback_data(
3402 subreq, struct tevent_req);
3403 struct rpccli_eventlog_WriteClusterEvents_state *state = tevent_req_data(
3404 req, struct rpccli_eventlog_WriteClusterEvents_state);
3405 NTSTATUS status;
3406 TALLOC_CTX *mem_ctx;
3407
3408 if (state->out_mem_ctx) {
3409 mem_ctx = state->out_mem_ctx;
3410 } else {
3411 mem_ctx = state;
3412 }
3413
3414 status = state->dispatch_recv(subreq, mem_ctx);
3415 TALLOC_FREE(subreq);
3416 if (!NT_STATUS_IS_OK(status)) {
3417 tevent_req_nterror(req, status);
3418 return;
3419 }
3420
3421 /* Copy out parameters */
3422
3423 /* Copy result */
3424 state->orig.out.result = state->tmp.out.result;
3425
3426 /* Reset temporary structure */
3427 ZERO_STRUCT(state->tmp);
3428
3429 if (DEBUGLEVEL >= 10) {
3430 NDR_PRINT_OUT_DEBUG(eventlog_WriteClusterEvents, &state->orig);
3431 }
3432
3433 tevent_req_done(req);
3434 }
3435
3436 NTSTATUS rpccli_eventlog_WriteClusterEvents_recv(struct tevent_req *req,
3437 TALLOC_CTX *mem_ctx,
3438 NTSTATUS *result)
3439 {
3440 struct rpccli_eventlog_WriteClusterEvents_state *state = tevent_req_data(
3441 req, struct rpccli_eventlog_WriteClusterEvents_state);
3442 NTSTATUS status;
3443
3444 if (tevent_req_is_nterror(req, &status)) {
3445 tevent_req_received(req);
3446 return status;
3447 }
3448
3449 /* Steal possbile out parameters to the callers context */
3450 talloc_steal(mem_ctx, state->out_mem_ctx);
3451
3452 /* Return result */
3453 *result = state->orig.out.result;
3454
3455 tevent_req_received(req);
3456 return NT_STATUS_OK;
3457 }
3458
3459 NTSTATUS rpccli_eventlog_WriteClusterEvents(struct rpc_pipe_client *cli,
3460 TALLOC_CTX *mem_ctx)
3461 {
3462 struct eventlog_WriteClusterEvents r;
3463 NTSTATUS status;
3464
3465 /* In parameters */
3466
3467 if (DEBUGLEVEL >= 10) {
3468 NDR_PRINT_IN_DEBUG(eventlog_WriteClusterEvents, &r);
3469 }
3470
3471 status = cli->dispatch(cli,
3472 mem_ctx,
3473 &ndr_table_eventlog,
3474 NDR_EVENTLOG_WRITECLUSTEREVENTS,
3475 &r);
3476
3477 if (!NT_STATUS_IS_OK(status)) {
3478 return status;
3479 }
3480
3481 if (DEBUGLEVEL >= 10) {
3482 NDR_PRINT_OUT_DEBUG(eventlog_WriteClusterEvents, &r);
3483 }
3484
3485 if (NT_STATUS_IS_ERR(status)) {
3486 return status;
3487 }
3488
3489 /* Return variables */
3490
3491 /* Return result */
3492 return r.out.result;
3493 }
3494
3495 struct rpccli_eventlog_GetLogInformation_state {
3496 struct eventlog_GetLogInformation orig;
3497 struct eventlog_GetLogInformation tmp;
3498 TALLOC_CTX *out_mem_ctx;
3499 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
3500 };
3501
3502 static void rpccli_eventlog_GetLogInformation_done(struct tevent_req *subreq);
3503
3504 struct tevent_req *rpccli_eventlog_GetLogInformation_send(TALLOC_CTX *mem_ctx,
3505 struct tevent_context *ev,
3506 struct rpc_pipe_client *cli,
3507 struct policy_handle *_handle /* [in] [ref] */,
3508 uint32_t _level /* [in] */,
3509 uint8_t *_buffer /* [out] [ref,size_is(buf_size)] */,
3510 uint32_t _buf_size /* [in] [range(0,1024)] */,
3511 uint32_t *_bytes_needed /* [out] [ref] */)
3512 {
3513 struct tevent_req *req;
3514 struct rpccli_eventlog_GetLogInformation_state *state;
3515 struct tevent_req *subreq;
3516
3517 req = tevent_req_create(mem_ctx, &state,
3518 struct rpccli_eventlog_GetLogInformation_state);
3519 if (req == NULL) {
3520 return NULL;
3521 }
3522 state->out_mem_ctx = NULL;
3523 state->dispatch_recv = cli->dispatch_recv;
3524
3525 /* In parameters */
3526 state->orig.in.handle = _handle;
3527 state->orig.in.level = _level;
3528 state->orig.in.buf_size = _buf_size;
3529
3530 /* Out parameters */
3531 state->orig.out.buffer = _buffer;
3532 state->orig.out.bytes_needed = _bytes_needed;
3533
3534 /* Result */
3535 ZERO_STRUCT(state->orig.out.result);
3536
3537 if (DEBUGLEVEL >= 10) {
3538 NDR_PRINT_IN_DEBUG(eventlog_GetLogInformation, &state->orig);
3539 }
3540
3541 state->out_mem_ctx = talloc_named_const(state, 0,
3542 "rpccli_eventlog_GetLogInformation_out_memory");
3543 if (tevent_req_nomem(state->out_mem_ctx, req)) {
3544 return tevent_req_post(req, ev);
3545 }
3546
3547 /* make a temporary copy, that we pass to the dispatch function */
3548 state->tmp = state->orig;
3549
3550 subreq = cli->dispatch_send(state, ev, cli,
3551 &ndr_table_eventlog,
3552 NDR_EVENTLOG_GETLOGINFORMATION,
3553 &state->tmp);
3554 if (tevent_req_nomem(subreq, req)) {
3555 return tevent_req_post(req, ev);
3556 }
3557 tevent_req_set_callback(subreq, rpccli_eventlog_GetLogInformation_done, req);
3558 return req;
3559 }
3560
3561 static void rpccli_eventlog_GetLogInformation_done(struct tevent_req *subreq)
3562 {
3563 struct tevent_req *req = tevent_req_callback_data(
3564 subreq, struct tevent_req);
3565 struct rpccli_eventlog_GetLogInformation_state *state = tevent_req_data(
3566 req, struct rpccli_eventlog_GetLogInformation_state);
3567 NTSTATUS status;
3568 TALLOC_CTX *mem_ctx;
3569
3570 if (state->out_mem_ctx) {
3571 mem_ctx = state->out_mem_ctx;
3572 } else {
3573 mem_ctx = state;
3574 }
3575
3576 status = state->dispatch_recv(subreq, mem_ctx);
3577 TALLOC_FREE(subreq);
3578 if (!NT_STATUS_IS_OK(status)) {
3579 tevent_req_nterror(req, status);
3580 return;
3581 }
3582
3583 /* Copy out parameters */
3584 memcpy(state->orig.out.buffer, state->tmp.out.buffer, state->tmp.in.buf_size * sizeof(*state->orig.out.buffer));
3585 *state->orig.out.bytes_needed = *state->tmp.out.bytes_needed;
3586
3587 /* Copy result */
3588 state->orig.out.result = state->tmp.out.result;
3589
3590 /* Reset temporary structure */
3591 ZERO_STRUCT(state->tmp);
3592
3593 if (DEBUGLEVEL >= 10) {
3594 NDR_PRINT_OUT_DEBUG(eventlog_GetLogInformation, &state->orig);
3595 }
3596
3597 tevent_req_done(req);
3598 }
3599
3600 NTSTATUS rpccli_eventlog_GetLogInformation_recv(struct tevent_req *req,
3601 TALLOC_CTX *mem_ctx,
3602 NTSTATUS *result)
3603 {
3604 struct rpccli_eventlog_GetLogInformation_state *state = tevent_req_data(
3605 req, struct rpccli_eventlog_GetLogInformation_state);
3606 NTSTATUS status;
3607
3608 if (tevent_req_is_nterror(req, &status)) {
3609 tevent_req_received(req);
3610 return status;
3611 }
3612
3613 /* Steal possbile out parameters to the callers context */
3614 talloc_steal(mem_ctx, state->out_mem_ctx);
3615
3616 /* Return result */
3617 *result = state->orig.out.result;
3618
3619 tevent_req_received(req);
3620 return NT_STATUS_OK;
3621 }
3622
3623 NTSTATUS rpccli_eventlog_GetLogInformation(struct rpc_pipe_client *cli,
3624 TALLOC_CTX *mem_ctx,
3625 struct policy_handle *handle /* [in] [ref] */,
3626 uint32_t level /* [in] */,
3627 uint8_t *buffer /* [out] [ref,size_is(buf_size)] */,
3628 uint32_t buf_size /* [in] [range(0,1024)] */,
3629 uint32_t *bytes_needed /* [out] [ref] */)
3630 {
3631 struct eventlog_GetLogInformation r;
3632 NTSTATUS status;
3633
3634 /* In parameters */
3635 r.in.handle = handle;
3636 r.in.level = level;
3637 r.in.buf_size = buf_size;
3638
3639 if (DEBUGLEVEL >= 10) {
3640 NDR_PRINT_IN_DEBUG(eventlog_GetLogInformation, &r);
3641 }
3642
3643 status = cli->dispatch(cli,
3644 mem_ctx,
3645 &ndr_table_eventlog,
3646 NDR_EVENTLOG_GETLOGINFORMATION,
3647 &r);
3648
3649 if (!NT_STATUS_IS_OK(status)) {
3650 return status;
3651 }
3652
3653 if (DEBUGLEVEL >= 10) {
3654 NDR_PRINT_OUT_DEBUG(eventlog_GetLogInformation, &r);
3655 }
3656
3657 if (NT_STATUS_IS_ERR(status)) {
3658 return status;
3659 }
3660
3661 /* Return variables */
3662 memcpy(buffer, r.out.buffer, r.in.buf_size * sizeof(*buffer));
3663 *bytes_needed = *r.out.bytes_needed;
3664
3665 /* Return result */
3666 return r.out.result;
3667 }
3668
3669 struct rpccli_eventlog_FlushEventLog_state {
3670 struct eventlog_FlushEventLog orig;
3671 struct eventlog_FlushEventLog tmp;
3672 TALLOC_CTX *out_mem_ctx;
3673 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
3674 };
3675
3676 static void rpccli_eventlog_FlushEventLog_done(struct tevent_req *subreq);
3677
3678 struct tevent_req *rpccli_eventlog_FlushEventLog_send(TALLOC_CTX *mem_ctx,
3679 struct tevent_context *ev,
3680 struct rpc_pipe_client *cli,
3681 struct policy_handle *_handle /* [in] [ref] */)
3682 {
3683 struct tevent_req *req;
3684 struct rpccli_eventlog_FlushEventLog_state *state;
3685 struct tevent_req *subreq;
3686
3687 req = tevent_req_create(mem_ctx, &state,
3688 struct rpccli_eventlog_FlushEventLog_state);
3689 if (req == NULL) {
3690 return NULL;
3691 }
3692 state->out_mem_ctx = NULL;
3693 state->dispatch_recv = cli->dispatch_recv;
3694
3695 /* In parameters */
3696 state->orig.in.handle = _handle;
3697
3698 /* Out parameters */
3699
3700 /* Result */
3701 ZERO_STRUCT(state->orig.out.result);
3702
3703 if (DEBUGLEVEL >= 10) {
3704 NDR_PRINT_IN_DEBUG(eventlog_FlushEventLog, &state->orig);
3705 }
3706
3707 /* make a temporary copy, that we pass to the dispatch function */
3708 state->tmp = state->orig;
3709
3710 subreq = cli->dispatch_send(state, ev, cli,
3711 &ndr_table_eventlog,
3712 NDR_EVENTLOG_FLUSHEVENTLOG,
3713 &state->tmp);
3714 if (tevent_req_nomem(subreq, req)) {
3715 return tevent_req_post(req, ev);
3716 }
3717 tevent_req_set_callback(subreq, rpccli_eventlog_FlushEventLog_done, req);
3718 return req;
3719 }
3720
3721 static void rpccli_eventlog_FlushEventLog_done(struct tevent_req *subreq)
3722 {
3723 struct tevent_req *req = tevent_req_callback_data(
3724 subreq, struct tevent_req);
3725 struct rpccli_eventlog_FlushEventLog_state *state = tevent_req_data(
3726 req, struct rpccli_eventlog_FlushEventLog_state);
3727 NTSTATUS status;
3728 TALLOC_CTX *mem_ctx;
3729
3730 if (state->out_mem_ctx) {
3731 mem_ctx = state->out_mem_ctx;
3732 } else {
3733 mem_ctx = state;
3734 }
3735
3736 status = state->dispatch_recv(subreq, mem_ctx);
3737 TALLOC_FREE(subreq);
3738 if (!NT_STATUS_IS_OK(status)) {
3739 tevent_req_nterror(req, status);
3740 return;
3741 }
3742
3743 /* Copy out parameters */
3744
3745 /* Copy result */
3746 state->orig.out.result = state->tmp.out.result;
3747
3748 /* Reset temporary structure */
3749 ZERO_STRUCT(state->tmp);
3750
3751 if (DEBUGLEVEL >= 10) {
3752 NDR_PRINT_OUT_DEBUG(eventlog_FlushEventLog, &state->orig);
3753 }
3754
3755 tevent_req_done(req);
3756 }
3757
3758 NTSTATUS rpccli_eventlog_FlushEventLog_recv(struct tevent_req *req,
3759 TALLOC_CTX *mem_ctx,
3760 NTSTATUS *result)
3761 {
3762 struct rpccli_eventlog_FlushEventLog_state *state = tevent_req_data(
3763 req, struct rpccli_eventlog_FlushEventLog_state);
3764 NTSTATUS status;
3765
3766 if (tevent_req_is_nterror(req, &status)) {
3767 tevent_req_received(req);
3768 return status;
3769 }
3770
3771 /* Steal possbile out parameters to the callers context */
3772 talloc_steal(mem_ctx, state->out_mem_ctx);
3773
3774 /* Return result */
3775 *result = state->orig.out.result;
3776
3777 tevent_req_received(req);
3778 return NT_STATUS_OK;
3779 }
3780
3781 NTSTATUS rpccli_eventlog_FlushEventLog(struct rpc_pipe_client *cli,
3782 TALLOC_CTX *mem_ctx,
3783 struct policy_handle *handle /* [in] [ref] */)
3784 {
3785 struct eventlog_FlushEventLog r;
3786 NTSTATUS status;
3787
3788 /* In parameters */
3789 r.in.handle = handle;
3790
3791 if (DEBUGLEVEL >= 10) {
3792 NDR_PRINT_IN_DEBUG(eventlog_FlushEventLog, &r);
3793 }
3794
3795 status = cli->dispatch(cli,
3796 mem_ctx,
3797 &ndr_table_eventlog,
3798 NDR_EVENTLOG_FLUSHEVENTLOG,
3799 &r);
3800
3801 if (!NT_STATUS_IS_OK(status)) {
3802 return status;
3803 }
3804
3805 if (DEBUGLEVEL >= 10) {
3806 NDR_PRINT_OUT_DEBUG(eventlog_FlushEventLog, &r);
3807 }
3808
3809 if (NT_STATUS_IS_ERR(status)) {
3810 return status;
3811 }
3812
3813 /* Return variables */
3814
3815 /* Return result */
3816 return r.out.result;
3817 }
3818
3819 struct rpccli_eventlog_ReportEventAndSourceW_state {
3820 struct eventlog_ReportEventAndSourceW orig;
3821 struct eventlog_ReportEventAndSourceW tmp;
3822 TALLOC_CTX *out_mem_ctx;
3823 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
3824 };
3825
3826 static void rpccli_eventlog_ReportEventAndSourceW_done(struct tevent_req *subreq);
3827
3828 struct tevent_req *rpccli_eventlog_ReportEventAndSourceW_send(TALLOC_CTX *mem_ctx,
3829 struct tevent_context *ev,
3830 struct rpc_pipe_client *cli,
3831 struct policy_handle *_handle /* [in] [ref] */,
3832 time_t _timestamp /* [in] */,
3833 enum eventlogEventTypes _event_type /* [in] */,
3834 uint16_t _event_category /* [in] */,
3835 uint32_t _event_id /* [in] */,
3836 struct lsa_String *_sourcename /* [in] [ref] */,
3837 uint16_t _num_of_strings /* [in] [range(0,256)] */,
3838 uint32_t _data_size /* [in] [range(0,0x3FFFF)] */,
3839 struct lsa_String *_servername /* [in] [ref] */,
3840 struct dom_sid *_user_sid /* [in] [unique] */,
3841 struct lsa_String **_strings /* [in] [unique,size_is(num_of_strings)] */,
3842 uint8_t *_data /* [in] [unique,size_is(data_size)] */,
3843 uint16_t _flags /* [in] */,
3844 uint32_t *_record_number /* [in,out] [unique] */,
3845 time_t *_time_written /* [in,out] [unique] */)
3846 {
3847 struct tevent_req *req;
3848 struct rpccli_eventlog_ReportEventAndSourceW_state *state;
3849 struct tevent_req *subreq;
3850
3851 req = tevent_req_create(mem_ctx, &state,
3852 struct rpccli_eventlog_ReportEventAndSourceW_state);
3853 if (req == NULL) {
3854 return NULL;
3855 }
3856 state->out_mem_ctx = NULL;
3857 state->dispatch_recv = cli->dispatch_recv;
3858
3859 /* In parameters */
3860 state->orig.in.handle = _handle;
3861 state->orig.in.timestamp = _timestamp;
3862 state->orig.in.event_type = _event_type;
3863 state->orig.in.event_category = _event_category;
3864 state->orig.in.event_id = _event_id;
3865 state->orig.in.sourcename = _sourcename;
3866 state->orig.in.num_of_strings = _num_of_strings;
3867 state->orig.in.data_size = _data_size;
3868 state->orig.in.servername = _servername;
3869 state->orig.in.user_sid = _user_sid;
3870 state->orig.in.strings = _strings;
3871 state->orig.in.data = _data;
3872 state->orig.in.flags = _flags;
3873 state->orig.in.record_number = _record_number;
3874 state->orig.in.time_written = _time_written;
3875
3876 /* Out parameters */
3877 state->orig.out.record_number = _record_number;
3878 state->orig.out.time_written = _time_written;
3879
3880 /* Result */
3881 ZERO_STRUCT(state->orig.out.result);
3882
3883 if (DEBUGLEVEL >= 10) {
3884 NDR_PRINT_IN_DEBUG(eventlog_ReportEventAndSourceW, &state->orig);
3885 }
3886
3887 state->out_mem_ctx = talloc_named_const(state, 0,
3888 "rpccli_eventlog_ReportEventAndSourceW_out_memory");
3889 if (tevent_req_nomem(state->out_mem_ctx, req)) {
3890 return tevent_req_post(req, ev);
3891 }
3892
3893 /* make a temporary copy, that we pass to the dispatch function */
3894 state->tmp = state->orig;
3895
3896 subreq = cli->dispatch_send(state, ev, cli,
3897 &ndr_table_eventlog,
3898 NDR_EVENTLOG_REPORTEVENTANDSOURCEW,
3899 &state->tmp);
3900 if (tevent_req_nomem(subreq, req)) {
3901 return tevent_req_post(req, ev);
3902 }
3903 tevent_req_set_callback(subreq, rpccli_eventlog_ReportEventAndSourceW_done, req);
3904 return req;
3905 }
3906
3907 static void rpccli_eventlog_ReportEventAndSourceW_done(struct tevent_req *subreq)
3908 {
3909 struct tevent_req *req = tevent_req_callback_data(
3910 subreq, struct tevent_req);
3911 struct rpccli_eventlog_ReportEventAndSourceW_state *state = tevent_req_data(
3912 req, struct rpccli_eventlog_ReportEventAndSourceW_state);
3913 NTSTATUS status;
3914 TALLOC_CTX *mem_ctx;
3915
3916 if (state->out_mem_ctx) {
3917 mem_ctx = state->out_mem_ctx;
3918 } else {
3919 mem_ctx = state;
3920 }
3921
3922 status = state->dispatch_recv(subreq, mem_ctx);
3923 TALLOC_FREE(subreq);
3924 if (!NT_STATUS_IS_OK(status)) {
3925 tevent_req_nterror(req, status);
3926 return;
3927 }
3928
3929 /* Copy out parameters */
3930 if (state->orig.out.record_number && state->tmp.out.record_number) {
3931 *state->orig.out.record_number = *state->tmp.out.record_number;
3932 }
3933 if (state->orig.out.time_written && state->tmp.out.time_written) {
3934 *state->orig.out.time_written = *state->tmp.out.time_written;
3935 }
3936
3937 /* Copy result */
3938 state->orig.out.result = state->tmp.out.result;
3939
3940 /* Reset temporary structure */
3941 ZERO_STRUCT(state->tmp);
3942
3943 if (DEBUGLEVEL >= 10) {
3944 NDR_PRINT_OUT_DEBUG(eventlog_ReportEventAndSourceW, &state->orig);
3945 }
3946
3947 tevent_req_done(req);
3948 }
3949
3950 NTSTATUS rpccli_eventlog_ReportEventAndSourceW_recv(struct tevent_req *req,
3951 TALLOC_CTX *mem_ctx,
3952 NTSTATUS *result)
3953 {
3954 struct rpccli_eventlog_ReportEventAndSourceW_state *state = tevent_req_data(
3955 req, struct rpccli_eventlog_ReportEventAndSourceW_state);
3956 NTSTATUS status;
3957
3958 if (tevent_req_is_nterror(req, &status)) {
3959 tevent_req_received(req);
3960 return status;
3961 }
3962
3963 /* Steal possbile out parameters to the callers context */
3964 talloc_steal(mem_ctx, state->out_mem_ctx);
3965
3966 /* Return result */
3967 *result = state->orig.out.result;
3968
3969 tevent_req_received(req);
3970 return NT_STATUS_OK;
3971 }
3972
3973 NTSTATUS rpccli_eventlog_ReportEventAndSourceW(struct rpc_pipe_client *cli,
3974 TALLOC_CTX *mem_ctx,
3975 struct policy_handle *handle /* [in] [ref] */,
3976 time_t timestamp /* [in] */,
3977 enum eventlogEventTypes event_type /* [in] */,
3978 uint16_t event_category /* [in] */,
3979 uint32_t event_id /* [in] */,
3980 struct lsa_String *sourcename /* [in] [ref] */,
3981 uint16_t num_of_strings /* [in] [range(0,256)] */,
3982 uint32_t data_size /* [in] [range(0,0x3FFFF)] */,
3983 struct lsa_String *servername /* [in] [ref] */,
3984 struct dom_sid *user_sid /* [in] [unique] */,
3985 struct lsa_String **strings /* [in] [unique,size_is(num_of_strings)] */,
3986 uint8_t *data /* [in] [unique,size_is(data_size)] */,
3987 uint16_t flags /* [in] */,
3988 uint32_t *record_number /* [in,out] [unique] */,
3989 time_t *time_written /* [in,out] [unique] */)
3990 {
3991 struct eventlog_ReportEventAndSourceW r;
3992 NTSTATUS status;
3993
3994 /* In parameters */
3995 r.in.handle = handle;
3996 r.in.timestamp = timestamp;
3997 r.in.event_type = event_type;
3998 r.in.event_category = event_category;
3999 r.in.event_id = event_id;
4000 r.in.sourcename = sourcename;
4001 r.in.num_of_strings = num_of_strings;
4002 r.in.data_size = data_size;
4003 r.in.servername = servername;
4004 r.in.user_sid = user_sid;
4005 r.in.strings = strings;
4006 r.in.data = data;
4007 r.in.flags = flags;
4008 r.in.record_number = record_number;
4009 r.in.time_written = time_written;
4010
4011 if (DEBUGLEVEL >= 10) {
4012 NDR_PRINT_IN_DEBUG(eventlog_ReportEventAndSourceW, &r);
4013 }
4014
4015 status = cli->dispatch(cli,
4016 mem_ctx,
4017 &ndr_table_eventlog,
4018 NDR_EVENTLOG_REPORTEVENTANDSOURCEW,
4019 &r);
4020
4021 if (!NT_STATUS_IS_OK(status)) {
4022 return status;
4023 }
4024
4025 if (DEBUGLEVEL >= 10) {
4026 NDR_PRINT_OUT_DEBUG(eventlog_ReportEventAndSourceW, &r);
4027 }
4028
4029 if (NT_STATUS_IS_ERR(status)) {
4030 return status;
4031 }
4032
4033 /* Return variables */
4034 if (record_number && r.out.record_number) {
4035 *record_number = *r.out.record_number;
4036 }
4037 if (time_written && r.out.time_written) {
4038 *time_written = *r.out.time_written;
4039 }
4040
4041 /* Return result */
4042 return r.out.result;
4043 }
4044
aatanasov's samba4 branch